C++ string 字符串类完全指南：告别 C 风格字符串的痛

#include <iostream>
#include <cstring>
using namespace std;
 
int main()
{
    char buf[32] = "hello";       // 手动定一块 32 字节的数组
    strcat(buf, " world");        // 拼接：必须保证 buf 够大，否则越界
    cout << buf << endl;          // 输出：hello world
 
    // 如果目标不够大，strcat 会把内容写到 buf 后面，
    // 直接破坏相邻内存 —— 这就是经典的缓冲区溢出漏洞
    char small[8] = "hi";
    // strcat(small, " this is a very long tail"); // 危险！千万别这样写
 
    // 看错 \0 位置的经典翻车现场
    char arr[] = {'a', 'b', 'c'};   // 注意：这个数组末尾没有 \0
    // printf 不知道在哪停，会把 arr 后面的随机内存也打印出来
    cout << arr << endl;            // 输出 abc 之后可能接一堆乱码
 
    return 0;
}

#include <iostream>
#include <string>   // string 类所在的头文件
using namespace std; // 把标准库的名字引入当前作用域
 
int main()
{
    string s = "hello";   // 创建一个 string 对象
    cout << s << endl;    // 直接用 cout 输出
    return 0;
}

#include <iostream>
using namespace std;
 
int main()
{
    auto a = 10;      // a 被推导为 int
    auto b = 'x';     // b 被推导为 char
    auto c = 3.14;    // c 被推导为 double
 
    int x = 5;
    auto y = &x;      // y 被推导为 int*（指针）
    auto* z = &x;     // z 也是 int*，和 y 没有区别
    auto& m = x;      // 注意：这里是引用，改 m 就是改 x
 
    m = 99;
    cout << x << endl;   // 输出：99
 
    return 0;
}

#include <iostream>
#include <string>
using namespace std;
 
int main()
{
    int arr[] = {1, 2, 3, 4, 5};
 
    // 加 & 表示引用：直接改元素
    for (auto& e : arr)
        e *= 2;              // 每个元素都翻倍
 
    // 不加 & 是"值拷贝"：e 只是当前元素的副本
    for (auto e : arr)
        cout << e << " ";    // 输出：2 4 6 8 10
    cout << endl;
 
    // 遍历 string：逐个取出字符
    string str("hello");
    for (auto ch : str)
        cout << ch << " ";   // 输出：h e l l o
    cout << endl;
 
    // 用 auto& 去修改字符串里的字符
    for (auto& ch : str)
        ch = ch - 32;        // ASCII 小写转大写：hello -> HELLO
    cout << str << endl;     // 输出：HELLO
 
    return 0;
}

#include <iostream>
#include <string>
using namespace std;
 
int main()
{
    string s1;                  // 空字符串
    string s2("hello world");   // 用 C 字符串构造
    string s3(s2);              // 拷贝构造：s3 成为 s2 的副本
    string s4(5, 'a');          // 5 个 'a'，即 "aaaaa"
 
    cout << "s1:[" << s1 << "]" << endl;   // s1:[]
    cout << "s2:[" << s2 << "]" << endl;   // hello world
    cout << "s3:[" << s3 << "]" << endl;   // hello world
    cout << "s4:[" << s4 << "]" << endl;   // aaaaa
    return 0;
}

#include <iostream>
#include <string>
using namespace std;
 
int main()
{
    string full = "Hello C++ World";
 
    // 从下标 6 开始，取 3 个字符：正是 "C++"
    string sub(full, 6, 3);
    cout << sub << endl;            // C++
 
    // 省略长度，等价于"从 pos 一直取到末尾"
    string tail(full, 11);
    cout << tail << endl;           // World
 
    return 0;
}

#include <iostream>
#include <string>
#include <vector>
using namespace std;
 
int main()
{
    // 从 vector 的一段区间构造 string
    vector<char> vc = {'C', '+', '+', '1', '7'};
    string from_v(vc.begin(), vc.begin() + 3);  // 取前 3 个
    cout << from_v << endl;                     // C++
 
    // 初始化列表构造：把花括号里的一串字符变成字符串
    string s{'a', 'b', 'c'};
    cout << s << endl;                          // abc
 
    return 0;
}

#include <iostream>
#include <string>
using namespace std;
 
int main()
{
    string s("hello");
    cout << "size: " << s.size() << endl;         // 5
    cout << "length: " << s.length() << endl;     // 5，和 size 一样
    cout << "capacity: " << s.capacity() << endl; // 一般大于等于 size
    cout << "empty: " << s.empty() << endl;       // 0，表示非空
 
    s.reserve(50);                                // 预留 50 的空间
    cout << "after reserve, capacity: " << s.capacity() << endl; // >= 50
 
    s.resize(8, '!');                             // 扩到 8 个，空位填 '!'
    cout << s << endl;                            // hello!!!   (5 + 3 个 !)
 
    s.clear();                                    // 清空有效字符
    cout << "size: " << s.size()                  // 0
         << ", capacity: " << s.capacity() << endl; // 容量不变
 
    return 0;
}

#include <iostream>
#include <string>
#include <stdexcept>   // out_of_range 异常定义在这里
using namespace std;
 
int main()
{
    string s("hello");
 
    cout << s[0] << endl;        // 下标访问：h
    cout << s.at(1) << endl;     // at 访问：e
    cout << s.front() << endl;   // 第一个字符：h
    cout << s.back() << endl;    // 最后一个字符：o
 
    // 下标越界不检查，属于未定义行为，千万别在生产代码里写
    // cout << s[100] << endl;   // 危险！
 
    // at 越界会抛异常，可以被捕获
    try
    {
        cout << s.at(100) << endl;   // 抛出 out_of_range
    }
    catch (const out_of_range& e)
    {
        cout << "捕获异常: " << e.what() << endl;
    }
 
    // 迭代器正序遍历
    string::iterator it = s.begin();
    while (it != s.end())
    {
        cout << *it;              // 逐字符取出来打印
        ++it;                     // 指向下一个
    }
    cout << endl;
 
    // 反向迭代器：从后往前
    string::reverse_iterator rit = s.rbegin();
    while (rit != s.rend())
    {
        cout << *rit;             // 输出：olleh
        ++rit;
    }
    cout << endl;
 
    // 范围 for，本质就是迭代器的语法糖
    for (auto ch : s)
        cout << ch;
    cout << endl;
 
    return 0;
}

#include <iostream>
#include <string>
using namespace std;
 
int main()
{
    string s("Hello");
 
    s.push_back('!');          // 尾插一个字符：Hello!
    s += " C++";               // 追加字符串：Hello! C++
    s.append(" World");        // 再追加：Hello! C++ World
    s.append(2, '!');          // 追加两个感叹号：Hello! C++ World!!
    cout << s << endl;
 
    s.insert(0, ">>");         // 在下标 0 处插入 ">>"
    cout << s << endl;         // >>Hello! C++ World!!
 
    s.erase(0, 2);             // 从下标 0 开始删 2 个字符
    cout << s << endl;
 
    s.replace(11, 5, "Mars");   // 把下标 11 起 5 个字符 "World" 替换成 "Mars"
    cout << s << endl;         // Hello! C++ Mars!!
 
    s.pop_back();              // 去掉末尾 '!'
    cout << s << endl;         // Hello o C++ World!
 
    s.clear();                 // 全部清空
    cout << "[" << s << "]" << endl;  // 空串，只剩中括号
 
    return 0;
}

#include <iostream>
#include <chrono>
#include <string>
using namespace std;
 
int main()
{
    // 不预留：每追加到容量上限就扩容搬家一次，扩容次数随数据规模增长
    string a;
    auto t0 = chrono::steady_clock::now();
    for (int i = 0; i < 100000; ++i)
        a += "abc;";
    auto t1 = chrono::steady_clock::now();
 
    // 预留：一次把空间抬到位，全程零扩容
    string b;
    b.reserve(500000);
    for (int i = 0; i < 100000; ++i)
        b += "abc;";
    auto t2 = chrono::steady_clock::now();
 
    cout << "不预留耗时(ms): "
         << chrono::duration_cast<chrono::milliseconds>(t1 - t0).count() << endl;
    cout << "预留后耗时(ms): "
         << chrono::duration_cast<chrono::milliseconds>(t2 - t1).count() << endl;
    cout << "b 的最终长度: " << b.size() << endl;
    return 0;
}

#include <iostream>
#include <string>
using namespace std;
 
int main()
{
    string s("hello world, hello C++");
 
    // 从前往后找 "hello" 第一次出现的位置
    size_t pos = s.find("hello");
    cout << "find: " << pos << endl;          // 0
 
    // 从后往前找字符 'l' 最后出现的位置
    size_t rp = s.rfind('l');
    cout << "rfind: " << rp << endl;
 
    // 找不到时返回 npos
    size_t np = s.find("xyz");
    if (np == string::npos)
        cout << "没找到!" << endl;
 
    // 截取前 5 个字符
    string sub = s.substr(0, 5);
    cout << "substr: " << sub << endl;        // hello
 
    // 从 pos+1 继续往后找第二次出现的 "hello"
    size_t pos2 = s.find("hello", pos + 1);
    cout << "second find: " << pos2 << endl;  // 13
 
    // find_first_of：找下面任意一个标点第一次出现的位置
    string punct = ",.!?";
    size_t p = s.find_first_of(punct);
    cout << "first punct at: " << p << endl;  // 下标 11（那个逗号）
 
    // 从一个表格式文本里抠字段：找到第一个、第二个分隔符
    string row = "apple,banana,orange";
    size_t comma1 = row.find(',');
    string first = row.substr(0, comma1);
    size_t comma2 = row.find(',', comma1 + 1);
    string second = row.substr(comma1 + 1, comma2 - comma1 - 1);
    string third = row.substr(comma2 + 1);
    cout << first << " / " << second << " / " << third << endl;
 
    return 0;
}

#include <iostream>
#include <string>
using namespace std;
 
int main()
{
    string line;
    cout << "请输入一行文本（可含空格）: ";
    getline(cin, line);              // 读整行，看下一节 getline 详解
 
    // 从后往前找最后一个空格
    size_t pos = line.rfind(' ');
    // 若整行没有空格，rfind 返回 npos，此时就把整行当"最后一个单词"
    size_t len;
    if (pos == string::npos)
        len = line.size();
    else
        len = line.size() - pos - 1;
 
    cout << "最后一个单词长度: " << len << endl;
    return 0;
}

#include <iostream>
#include <string>
using namespace std;
 
int main()
{
    string a("apple");
    string b("banana");
    string c("apple");
 
    cout << (a == c) << endl;    // 1（true），两个字符串相等
    cout << (a < b)  << endl;    // 1，字典序 apple < banana
    cout << (a != b) << endl;    // 1，不相等
 
    // 字典序逐字符比较的直观例子
    string big("hello");
    string small("hello world");  // 前缀相同，更短者更小
    cout << (big < small) << endl;   // 1
 
    int r = a.compare("apple");  // 相等返回 0
    cout << "compare: " << r << endl;   // 0
 
    r = a.compare(b);            // a 比 b 小，返回负数
    cout << "compare b: " << r << endl; // 负数（常见实现是 -1）
 
    r = b.compare(1, 3, a, 1, 3); // b 的 [1,4) "ana" vs a 的 [1,4) "ppl"
    cout << "compare 子串: " << r << endl; // "ana" < "ppl"，负数
 
    return 0;
}

#include <iostream>
#include <string>
using namespace std;
 
int main()
{
    // 数字 -> 字符串
    int n = 2024;
    string s = to_string(n);        // "2024"
    cout << s << endl;
 
    double d = 3.14;
    string sd = to_string(d);       // "3.140000"（默认保留 6 位小数）
    cout << sd << endl;
 
    // 字符串 -> 数字
    string num("12345");
    int m = stoi(num);              // 12345
    cout << m << endl;
 
    string pd("3.99");
    double f = stod(pd);            // 3.99
    cout << f << endl;
 
    return 0;
}

#include <iostream>
#include <string>
using namespace std;
 
int main()
{
    string s("  42abc");     // 前导空格 + 数字 + 尾巴
    size_t used = 0;         // used 会被填成"实际消费的字符数"
    int v = stoi(s, &used);  // 跳过前导空格后解析出 42
    cout << "值: " << v << ", 消费字符数: " << used << endl;
 
    // 用 used 判断是否"整个字符串都是数字"
    bool whole = (used == s.size());
    cout << "整个串都被解析成数字了吗: " << whole << endl; // 0(false)
 
    // 十六进制解析
    string hexs("ff");
    int hv = stoi(hexs, nullptr, 16);
    cout << "十六进制 ff = " << hv << endl;  // 255
 
    // 完全无法解析 -> 抛异常
    try
    {
        int bad = stoi("hello");
        cout << bad << endl;
    }
    catch (const invalid_argument& e)
    {
        cout << "解析失败，抛 invalid_argument" << endl;
    }
 
    return 0;
}

#include <iostream>
#include <string>
#include <cstdio>   // 引入 C 的 sprintf/snprintf 等
using namespace std;
 
int main()
{
    string s("hello");
    const char* c = s.c_str();   // 拿到 C 风格字符串，供 C 库函数使用
    cout << c << endl;           // hello
 
    // 演示 1：把 string 用 C 风格 printf 输出（printf 只认 const char*）
    printf("printf 版: %s\n", s.c_str());
 
    // 演示 2：把 string 内容格式化成另一个 C 缓冲区
    char buf[64];
    snprintf(buf, sizeof(buf), "%s + %d", s.c_str(), 100);
    string merged(buf);          // 再包回 string
    cout << merged << endl;      // hello + 100
 
    // 演示 1 的关键：printf 这一行执行完，s 还没被改动时 c 有效；
    // 一旦下面 s 被改动，c 就说不准了，所以前面 printf 必须"用完即取"
    s += "!!";
    c = s.c_str();               // 需要时重新取
    cout << c << endl;           // hello!!
 
    return 0;
}

#include <iostream>
#include <string>
using namespace std;
 
int main()
{
    string s("hello");
    const char* c = s.c_str();   // 拿到 C 风格字符串，供 C 库函数使用
    cout << c << endl;           // hello
 
    // 读一整行（包含空格）
    cout << "请输入一行: ";
    string line;
    getline(cin, line);          // 推荐用 getline，而不是 cin>>line
    cout << "你输入了: " << line << endl;
 
    // cin >> string 只能读单个词：遇到空白就停
    cout << "请输入用空格隔开的若干词: ";
    string word;
    cin >> word;
    cout << "cin >> 只读到了第一个词: " << word << endl;
 
    // getline 的三参版：用别的字符当分隔符
    cout << "请输入（用 ',' 分隔，如 a,b,c）: ";
    string token;
    getline(cin, token, ',');
    cout << "逗号前的那段: " << token << endl;
 
    return 0;
}

#include <iostream>
#include <cstring>
using namespace std;
 
int main()
{
    cout << "sizeof(std::string) = " << sizeof(string) << endl;
 
    // 判断一个 string 是否命中 SSO（数据就存在对象内部）
    auto is_sso = [](const string& s) {
        const char* obj_begin = reinterpret_cast<const char*>(&s);
        const char* obj_end   = obj_begin + sizeof(s);
        const char* data      = s.data();
        return data >= obj_begin && data < obj_end;   // 数据指针落在对象地址区间内
    };
 
    string s1("hi");                     // 短串
    string s2("a string longer than fifteen chars xxxxx");
    cout << "短串是否 SSO(内部存储): " << is_sso(s1) << endl;   // 1
    cout << "长串是否 SSO(内部存储): " << is_sso(s2) << endl;   // 0（堆上）
 
    // 遍历 0~30 个 'a'，找到第一个触发堆分配的阈值
    for (int n = 0; n <= 30; ++n)
        if (!is_sso(string(n, 'a')))
        {
            cout << "从 " << n << " 个字符开始不再命中 SSO" << endl;
            break;
        }
 
    return 0;
}

#include <iostream>
#include <cstring>
#include <cassert>
using namespace std;
 
// —— 演示浅拷贝的灾难现场 ——
// 注意：这段代码本身是"错误的示范"，会崩溃/未定义行为，仅供理解原理，
// 不要拿去当正常代码跑。真要跑，关掉内存检查、接受它崩给你看。
class Shallow
{
public:
    Shallow(const char* str = "")
    {
        if (nullptr == str) { assert(false); return; }
        _str = new char[strlen(str) + 1];
        strcpy(_str, str);
    }
    // 没写拷贝构造/赋值 => 编译器生成"位拷贝"（浅拷贝）
    ~Shallow()
    {
        delete[] _str;          // 两个对象会各 delete 一次同一块内存 => 崩溃
    }
 
private:
    char* _str;
};
 
int main()
{
    Shallow a("hello");
    Shallow b(a);   // 浅拷贝：a._str 和 b._str 指向同一块内存
    // —— 到这里 a、b 析构时，同一块堆内存被释放两次，
    // 通常表现为 double free 或程序崩溃 ——
    cout << "(浅拷贝实例，供理解原理，出现崩溃属预期)" << endl;
    return 0;
}

#include <iostream>
#include <cstring>
#include <cassert>
using namespace std;
 
// 传统写法：深拷贝的"老实"版本
class String
{
public:
    String(const char* str = "")       // 构造函数，默认空串
    {
        if (nullptr == str)            // 不允许传空指针
        {
            assert(false);             // 触发断言，帮忙快速定位问题
            return;
        }
        _str = new char[strlen(str) + 1]; // 在堆上开空间（+1 给 \0）
        strcpy(_str, str);              // 拷贝内容过去
    }
 
    // 拷贝构造：重新开一块空间再复制 —— 这就是深拷贝
    String(const String& s)
        : _str(new char[strlen(s._str) + 1])
    {
        strcpy(_str, s._str);
    }
 
    // 拷贝赋值（传统写法）
    String& operator=(const String& s)
    {
        if (this != &s)                 // 防止自己给自己赋值（self-assignment）
        {
            char* tmp = new char[strlen(s._str) + 1]; // 先开新空间
            strcpy(tmp, s._str);        // 复制内容
            delete[] _str;              // 再释放旧空间
            _str = tmp;                 // 指向新空间
        }
        return *this;                   // 支持连续赋值 a = b = c;
    }
 
    ~String()                           // 析构：释放自己这块资源
    {
        if (_str)
        {
            delete[] _str;
            _str = nullptr;             // 置空，防止误用
        }
    }
 
    // 加一点能力方便演示
    const char* c_str() const { return _str; }
 
private:
    char* _str;                         // 指向堆上那块字符串内存
};
 
int main()
{
    String s1("hello bit");
    String s2(s1);    // 拷贝构造，s2 拥有独立的拷贝
    String s3;
    s3 = s1;          // 赋值，s3 也拥有独立拷贝
    // 三个对象各自管理自己的内存，析构时互不干扰
    cout << s1.c_str() << " / " << s2.c_str() << " / " << s3.c_str() << endl;
    return 0;
}

#include <iostream>
#include <cstring>
#include <cassert>
using namespace std;
 
// 现代写法：借助临时对象 + swap，简洁、自防自赋值、异常安全
class String
{
public:
    String(const char* str = "")
    {
        if (nullptr == str)
        {
            assert(false);
            return;
        }
        _str = new char[strlen(str) + 1];
        strcpy(_str, str);
    }
 
    // 拷贝构造（现代版）
    String(const String& s)
        : _str(nullptr)              // 先置空，方便后面交换
    {
        String tmp(s._str);          // 复用构造函数，造出 s 的一个副本
        swap(_str, tmp._str);        // 把自己的指针和副本的空间交换
    }
 
    // 赋值（现代版）：以值传参，天然触发拷贝构造
    String& operator=(String s)
    {
        swap(_str, s._str);          // 交换后，s 里存的正是旧的 this 空间
        return *this;                // s 是局部变量，析构时会释放旧空间
    }
 
    ~String()
    {
        if (_str)
        {
            delete[] _str;
            _str = nullptr;
        }
    }
 
    const char* c_str() const { return _str; }
 
private:
    char* _str;
};
 
int main()
{
    String s1("hello");
    String s2(s1);     // 拷贝构造：s2 拿到独立副本
    String s3("world");
    s3 = s1;           // 赋值：s3 先把旧空间让给临时对象 s（形参），再拿走 s1 的副本
    s3 = s3;           // 自己赋给自己：交换后自己的空间和临时对象又换回来，安全
    cout << s1.c_str() << " / " << s2.c_str() << " / " << s3.c_str() << endl;
    return 0;
}

#include <iostream>
#include <string>
using namespace std;
 
int main()
{
    string s("abaccdeff");
 
    int count[256] = {0};          // ASCII 码作下标，先全置 0
    for (auto ch : s)              // 第一遍：统计每个字符出现次数
        ++count[(unsigned char)ch];
 
    bool found = false;
    for (size_t i = 0; i < s.size(); ++i)   // 第二遍：按原始顺序找第一个计数值为 1 的
    {
        if (count[(unsigned char)s[i]] == 1)
        {
            cout << "第一个只出现一次的字符: " << s[i] << endl;
            found = true;
            break;
        }
    }
 
    if (!found)
        cout << "所有字符都出现多次" << endl;
 
    return 0;
}

#include <iostream>
#include <string>
#include <algorithm>   // std::reverse
using namespace std;
 
string addStrings(string num1, string num2)
{
    string ret;                       // 结果，先逆序累计，最后统一反转
    int i = (int)num1.size() - 1;
    int j = (int)num2.size() - 1;
    int carry = 0;                    // 进位
 
    while (i >= 0 || j >= 0 || carry != 0)
    {
        int d1 = (i >= 0) ? num1[i--] - '0' : 0;   // 逐位取出，不够的前补 0
        int d2 = (j >= 0) ? num2[j--] - '0' : 0;
        int sum = d1 + d2 + carry;
        carry = sum / 10;             // 判断是否满 10 进 1
        ret += char('0' + sum % 10);  // 当前位数字转回字符，尾插
    }
 
    reverse(ret.begin(), ret.end());  // 因为是低位在前，反转成正常的高位在前
    return ret;
}
 
int main()
{
    cout << addStrings("789", "123") << endl;        // 912
    cout << addStrings("999", "1") << endl;          // 1000（连续进位）
    cout << addStrings("0", "0") << endl;            // 0
    cout << addStrings("123456789012345678901", "98765432109876543210")
         << endl;                                    // 大数相加：222222221122222222111
    return 0;
}

#include <iostream>
#include <string>
#include <cctype>     // isdigit
using namespace std;
 
int main()
{
    string s = "abc123de45f6";
    size_t i = 0;
    while (i < s.size())
    {
        if (isdigit((unsigned char)s[i]))          // 是数字，开始收集一段
        {
            size_t j = i;
            while (j < s.size() && isdigit((unsigned char)s[j])) ++j;  // 一直扩到数字串结束
            cout << s.substr(i, j - i) << endl;    // 输出这一整段数字
            i = j;                                  // 跳过它，避免重复找
        }
        else
        {
            ++i;                                    // 不是数字，继续往后挪
        }
    }
    return 0;
}
// 输出：
// 123
// 45
// 6

#include <iostream>
#include <string>
using namespace std;
 
int main()
{
    string line;
    while (getline(cin, line))      // 读整行，包括空格
    {
        size_t pos = line.rfind(' ');             // 找最后一个空格
        size_t len;
        if (pos == string::npos)
            len = line.size();                    // 整行就是一个单词，长度就是整行长
        else
            len = line.size() - pos - 1;          // 最后一个空格后面那一小段
        cout << len << endl;
    }
    return 0;
}

#include <cstring>
#include <cassert>
 
class String
{
public:
    String(const char* str = "")
    {
        if (nullptr == str) { assert(false); return; }
        _str = new char[strlen(str) + 1];
        strcpy(_str, str);
    }
 
    // 拷贝构造（现代版）：先构造一个已经深拷贝好的临时对象 tmp，
    // 再把自己的 _str 和 tmp 的 _str 交换 —— 数据就"到了"自己手里
    String(const String& s)
        : _str(nullptr)
    {
        String tmp(s);          // tmp 内部完成深拷贝
        swap(_str, tmp._str);   // 换过来之后，tmp 析构时释放的只是原来的空指针
    }
 
    // 赋值（现代版）：按值传参会先自动做一次"拷贝构造"，得到一个深拷贝的形参 s，
    // 直接 swap 即可。这个版本天然安全：自赋值、异常场景都不用额外操心
    String& operator=(String s)
    {
        swap(_str, s._str);
        return *this;
    }
 
    ~String()
    {
        delete[] _str;
    }
 
private:
    char* _str;
};