C 语言基础转向 C++ 的实战指南

注意 cin 读取字符串时会自动跳过前导空格，但如果需要处理整行输入（含空格），请使用 getline。若要去除前导零，将参数 " " 改为 "0" 即可。

提取和拼接子串

#include <iostream>
#include <string>
using namespace std;

int main(void) {
    string s = "hello , world";
    // 从第 0 个位置开始截取长度为 5 的子串
    string s1 = s.substr(0, 5);
    // 从第 6 个位置开始截取后面的所有字符
    string s2 = s.substr(6);
    // 将 s1 和 s2 拼接为一个字符串
    string s3 = s1 + s2;
    // 运行下二者输出的结果相同
    cout << s1 << s2 << "\n";
    cout << s3;
}

substr 是截取子串的成员函数，参数分别为起始位置和长度（省略长度则截取至末尾）。

一些常用的 C++ 操作

C++ sort 排序函数的用法

#include <algorithm>
#include <iostream>
#include <string>
using namespace std;

bool comp(int& a, int& b) {
    return a > b;
}

int main(void) {
    int a[1000] = {0, 1, 1, 4, 5, 1, 4};
    // sort 第一个参数是起始位置，第二个参数是终止位置（不包含）
    sort(a + 1, a + 1 + 6);
    for (int i = 1; i <= 6; i++) cout << a[i];
    
    // C++ 排序默认升序，如需降序可添加自定义比较函数
    cout << "\n";
    sort(a + 1, a + 1 + 6, comp);
    for (int i = 1; i <= 6; i++) cout << a[i];
}

std::sort 时间复杂度为 O(nlogn)，远快于冒泡排序。自定义比较函数 comp 中使用了引用传递 & 以避免数值复制，虽然不加也能运行，但在大数据量下建议加上。

数组去重

#include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;

int main(void) {
    // 使用原始数组的方法
    // 数组去重需要先排序
    int a[1000] = {0, 1, 1, 4, 5, 1, 4};
    sort(a + 1, a + 1 + 6);
    
    // unique 返回的是去重后有效范围的末尾迭代器
    int* pos = unique(a + 1, a + 1 + 6);
    // 计算去重后的数组个数
    int new_count = pos - (a + 1);
    for (int i = 1; i <= new_count; i++) cout << a[i] << " ";
}

unique 会将重复元素移到末尾，并不真正删除，因此需要结合 end() 或计算新长度来使用。

二分查找

#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;

int main(void) {
    // 演示用有序数组
    int a[105];
    for (int i = 1; i <= 100; i++) a[i] = i;
    
    // 查找第一个小于等于 25 的元素
    int* lb1 = lower_bound(a + 1, a + 101, 25);
    int index1 = lb1 - a;
    cout << "elem is " << *(lb1) << " index is " << index1 << endl;
    
    // 查找第一个大于 25 的元素
    int* ub2 = upper_bound(a + 1, a + 101, 25);
    int index2 = ub2 - a;
    cout << "elem is " << *(ub2) << " index is " << index2 << endl;
    
    // 超出范围的情况
    int* result = lower_bound(a + 1, a + 101, 101);
    if (result == a + 101) {
        cout << "lower_bound(101) return a+101\n";
    }
    return 0;
}

lower_bound 返回第一个不小于目标值的迭代器，upper_bound 返回第一个大于目标值的迭代器。若返回值为数组末尾，说明未找到或超出范围。

STL 容器相关

这部分涉及数据结构，如栈、队列、红黑树等。

常见的 STL 容器使用

常见队列

#include <algorithm>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;

int main(void) {
    queue<int> q;
    // 模拟插入数据
    for (int i = 0; i < 10; i++) q.push(i);
    
    // 一般不知道队列元素个数，用 while 循环处理
    // empty() 返回 bool，非空即为真
    while (!q.empty()) {
        // 查看队头和队尾
        cout << q.front() << " " << q.back() << "\n";
        // 弹出队头
        q.pop();
    }
    
    // 双端队列支持两端插入和弹出
    deque<int> qu;
    for (int i = 0; i < 10; i++) {
        qu.push_back(i);
        // qu.push_front(i);
    }
    while (!qu.empty()) {
        cout << qu.front() << " " << qu.back() << "\n";
        qu.pop_back();
        qu.pop_front();
    }
}

队列基于先进先出（FIFO）思想，内部通常由数组实现，上述操作时间复杂度均为 O(1)。若已引入 using namespace std;，可省略 std:: 前缀。

栈

#include <algorithm>
#include <iostream>
#include <vector>
#include <stack>
#include <queue>
using namespace std;

int main(void) {
    stack<int> s;
    for (int i = 0; i < 10; i++) s.push(i);
    while (!s.empty()) {
        // 默认弹出最后一个元素
        cout << s.top() << " ";
        s.pop();
    }
}

栈遵循先进后出（FILO）原则，操作接口与队列类似，主要区别在于访问和移除元素的顺序。

map(键值对)

Map 即字典，通过键映射值，底层通常为红黑树，插入复杂度 O(logn)。

#include <algorithm>
#include <iostream>
#include <vector>
#include <stack>
#include <queue>
#include <map>
using namespace std;

int main(void) {
    map<int, int> mp;
    int temp = 114514;
    for (int i = 0; i < 10; i++) {
        // 插入数据（两种方法均可）
        if (i < 4) mp[i] = temp * (10 - i);
        else mp.insert({i, temp * (10 - i)});
    }
    
    // 遍历 map
    for (auto& [key, value] : mp) {
        cout << "mp[" << key << "] = " << value << "\n";
    }
    
    // 查找操作，时间复杂度 O(logn)
    if (mp.find(2) != mp.end()) cout << "Yes";
    if (mp.find(10) == mp.end()) cout << "No";
    cout << "\n";
    
    int idx = 0;
    while (1) {
        mp.erase(idx);
        idx++;
        if (mp.empty()) {
            cout << "已弹出所有元素";
            break;
        }
    }
    return 0;
}

基础操作包括插入、删除、遍历和查找。还有一种 unordered_map，底层为哈希表，查找插入速度为 O(1)，但无序。

set(集合)

Set 类似于只有一个 value 的 Map，自动有序且去重，时间复杂度与 Map 一致。

#include <algorithm>
#include <iostream>
#include <vector>
#include <stack>
#include <queue>
#include <map>
#include <set>
using namespace std;

int main(void) {
    set<int> s;
    for (int i = 0; i < 100; i++) s.insert(0);
    s.insert(5);
    s.insert(3);
    s.insert(114514);
    
    // set 里面自动有序且会自动去重
    for (auto i : s) cout << i << " ";
    cout << "\n";
    
    if (s.find(3) != s.end()) cout << "Yes" << " ";
    if (s.find(6) == s.end()) cout << "No" << " ";
    cout << "\n";
    
    // 查看集合的大小
    cout << s.size() << "\n";
    for (auto i : s) s.erase(i);
    cout << s.size() << "\n";
    return 0;
}

C++ 进阶相关

标准输入输出加快

ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);

在大量 IO 操作时，关闭同步可显著提升速度。

lambda 表达式

std::vector<int> arr = {1, 1, 4, 5, 1, 4};
std::sort(arr.begin(), arr.end(), [](int& a, int& b) { return a > b; });

Lambda 允许直接在调用处定义匿名函数，常用于排序比较逻辑。

优先队列自定义排序

struct Node {
    int x, y;
    bool operator<(Node &a) const {
        return x < a.x;
    };
};

int main(void) {
    std::priority_queue<Node> q;
}

结构体无法直接比较大小，需重载 operator<。优先队列（堆）内部为二叉搜索树，插入弹出复杂度 logn，默认取最大元素。

stringstream 流

#include <vector>
#include <string>
#include <sstream>
#include <iostream>
using namespace std;

int main(void) {
    // 将字符类型转化为整数
    string s = "1 2 3 4 5 6";
    vector<int> arr;
    stringstream stream(s);
    int num;
    while (stream >> num) {
        arr.push_back(num);
    }
    for (auto i : arr) cout << i << " ";
    cout << "\n";
    
    // 将数据按某个字符串分割
    string data = "apple,banana,orange,grape";
    stringstream ss(data);
    string fruit;
    while (getline(ss, fruit, ',')) cout << fruit << endl;
    return 0;
}

stringstream 可用于字符串与数字间的转换，或按分隔符解析字符串。

结语

以上内容属于 C++ 基础范畴。若从事 C++ 行业，这是基本功；若仅参与算法竞赛，以上技巧也足以应对大部分题目。即便只是简单练习，掌握这些编码规范也能显著提升开发效率。