C++ string 类详解：接口使用与底层模拟实现

在迭代复杂容器时，auto 能简化代码：

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

int main() {
    std::map<std::string, std::string> dict = {
        { "apple", "苹果" },
        { "orange", "橙子" },
        { "pear", "梨" }
    };
    
    // 使用 auto 简化迭代器声明
    auto it = dict.begin();
    while (it != dict.end()) {
        cout << it->first << ":" << it->second << endl;
        ++it;
    }
    return 0;
}

范围 for 循环 C++11 引入基于范围的 for 循环，自动处理迭代，本质仍是迭代器遍历。适用于数组和容器。

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

int main() {
    int array[] = { 1, 2, 3, 4, 5 };
    
    // C++98 写法
    for (int i = 0; i < sizeof(array) / sizeof(array[0]); ++i) {
        array[i] *= 2;
    }
    
    // C++11 写法
    for (auto& e : array) e *= 2;
    for (auto e : array) cout << e << " ";
    cout << endl;
    
    string str("hello world");
    for (auto ch : str) {
        cout << ch << " ";
    }
    cout << endl;
    return 0;
}

string 类的常用接口说明

1. string 类对象的常见构造

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

void test1() {
    string s1;                    // 默认构造，为空字符串
    string s2("hello,world");     // C-string 构造
    string s3(3, 'a');            // n 个 char 构造
    string s4 = s2;               // 拷贝构造
    
    cout << s1 << endl;
    cout << s2 << endl;
    cout << s3 << endl;
    cout << s4 << endl;
}

int main() {
    test1();
    return 0;
}

2. string 类对象的容量操作

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

int main() {
    string s1 = "hello,world!";
    cout << s1.size() << endl;
    cout << s1.length() << endl;
    cout << s1.empty() << endl;
    
    cout << "clear 前的实际空间个数" << endl;
    cout << s1.capacity() << endl;
    
    s1.clear(); // 只清理内容，不回收空间
    cout << "clear 后的空间个数" << endl;
    cout << s1.capacity() << endl;
    cout << s1.empty() << endl;
    
    s1.reserve(20); // 预留空间
    cout << "reserve 后的实际空间个数" << endl;
    cout << s1.capacity() << endl;
    cout << s1.size() << endl;
    
    s1.resize(10, 'a'); // 调整大小，多余部分用 'a' 填充
    cout << s1 << endl;
    return 0;
}

注意： size() 与 length() 原理相同，统一接口习惯多用 size()。clear() 仅清空内容，不改变底层容量。resize(n) 若增大则可能扩容，减小则不释放空间；resize(n, c) 指定填充字符。reserve() 仅预留空间，不改变有效元素个数。

3. string 类对象的访问及遍历操作

支持多种遍历方式：

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

int main() {
    string s;
    s += "hello,world";
    
    // 范围 for 遍历
    cout << "范围 for 遍历 s:" << endl;
    for (auto& e : s) {
        cout << e << " ";
    }
    cout << endl;
    
    // 正向迭代器遍历
    cout << "正向迭代器遍历 s:" << endl;
    for (auto i = s.begin(); i != s.end(); i++) {
        cout << *i << " ";
    }
    cout << endl;
    
    // 逆向迭代器遍历
    cout << "逆向迭代器遍历 s" << endl;
    for (auto i = s.rbegin(); i != s.rend(); i++) {
        cout << *i << " ";
    }
    cout << endl;
    return 0;
}

4. string 类对象的修改操作

push_back() 示例：

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

int main() {
    string s1;
    s1.push_back('c');
    char a = 'd';
    s1.push_back(a);
    cout << s1 << endl;
    return 0;
}

find 与 npos 示例：

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

int main() {
    string s = "hello,world";
    string s2 = "llo";
    
    cout << s.find(s2) << endl;      // 查找子串
    cout << s.find("wor") << endl;   // 查找 C-string
    cout << s.find("wor", 5, 2) << endl; // 从 pos 开始，限制长度
    cout << s.find('l') << endl;     // 第一个 'l'
    cout << s.find('l', 5) << endl;  // 从索引 5 开始找
    cout << s.find("www") << endl;   // 找不到返回 npos
    return 0;
}

substr 示例：

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

int main() {
    string s = "hello,world";
    cout << s.substr(2, 3) << endl; // 从索引 2 开始取 3 个字符
    return 0;
}

注意： 尾部追加字符时，push_back、append、+= 性能差异不大，通常 += 更简洁。预估字符数量时，可先用 reserve 预留空间以减少扩容开销。

5. string 类非成员函数

输入输出运算符重载通常在模拟实现中完成。getline 是 std 命名空间下的全局函数，用于读取整行（含空格）。

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

int main() {
    string s;
    
    cout << "cin >> s 输入效果:" << endl;
    cin >> s; // 遇到空格停止
    cout << s << endl;
    
    cout << "getline 输入效果:" << endl;
    getline(cin, s); // 读取整行，默认分隔符 '\n'
    cout << s << endl;
    
    return 0;
}

注意： cin >> s 后缓冲区残留换行符会影响后续 getline，需用 cin.ignore() 清除。

6. VS 和 g++ 下 string 结构的说明

VS 下结构： 32 位平台下占 28 字节。内部使用联合体存储：短字符串（<16 字符）使用内部固定数组（SSO），长字符串指向堆空间。包含长度、容量字段及额外指针。

g++ 下结构： 采用写时拷贝（Copy-On-Write）。对象占 4 字节，仅含一个指针指向堆空间。堆空间包含长度、容量、引用计数等信息。

7. string 函数接口的应用

反转字母

class Solution {
public:
    bool isLetter(char ch) {
        if (ch >= 'a' && ch <= 'z') return true;
        if (ch >= 'A' && ch <= 'Z') return true;
        return false;
    }
    
    string reverseOnlyLetters(string S) {
        if (S.empty()) return S;
        size_t begin = 0, end = S.size() - 1;
        while (begin < end) {
            while (begin < end && !isLetter(S[begin])) ++begin;
            while (begin < end && !isLetter(S[end])) --end;
            swap(S[begin], S[end]);
            ++begin;
            --end;
        }
        return S;
    }
};

第一个只出现一次的字符

class Solution {
public:
    int firstUniqChar(string s) {
        int count[256] = {0};
        int size = s.size();
        for (int i = 0; i < size; ++i) count[s[i]] += 1;
        for (int i = 0; i < size; ++i)
            if (1 == count[s[i]]) return i;
        return -1;
    }
};

字符串相加

class Solution {
public:
    string addStrings(string num1, string num2) {
        int end1 = num1.size() - 1;
        int end2 = num2.size() - 1;
        int value1 = 0, value2 = 0, next = 0;
        string addret;
        
        while (end1 >= 0 || end2 >= 0) {
            if (end1 >= 0) value1 = num1[end1--] - '0';
            else value1 = 0;
            if (end2 >= 0) value2 = num2[end2--] - '0';
            else value2 = 0;
            
            int valueret = value1 + value2 + next;
            if (valueret > 9) {
                next = 1;
                valueret -= 10;
            } else {
                next = 0;
            }
            addret += (valueret + '0');
        }
        if (next == 1) addret += '1';
        reverse(addret.begin(), addret.end());
        return addret;
    }
};

string 类的模拟实现

经典的 string 类问题

面试中常要求模拟实现 string 类，核心在于构造、拷贝构造、赋值运算符重载及析构函数。

以下实现存在浅拷贝问题：

class String {
public:
    String(const char* str = "") {
        if (nullptr == str) {
            assert(false);
            return;
        }
        _str = new char[strlen(str) + 1];
        strcpy(_str, str);
    }
    
    ~String() {
        if (_str) {
            delete[] _str;
            _str = nullptr;
        }
    }
private:
    char* _str;
};

// 测试
void TestString() {
    String s1("hello bit!!!");
    String s2(s1); // 调用默认拷贝构造，导致浅拷贝
}

程序结束时 s1 和 s2 会重复释放同一块内存，导致崩溃。这是因为编译器合成的默认拷贝构造只是简单的值拷贝，未处理资源管理。

浅拷贝与深拷贝

浅拷贝：直接复制成员变量。若成员包含动态资源，会导致多对象共享同一资源，析构时重复释放。

深拷贝：每个对象拥有独立资源。涉及资源管理的类，必须显式定义拷贝构造函数、赋值运算符重载及析构函数。

传统版写法的 String 类

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(new char[strlen(s._str) + 1]) {
        strcpy(_str, s._str);
    }
    
    String& operator=(const String& s) {
        if (this != &s) {
            char* pStr = new char[strlen(s._str) + 1];
            strcpy(pStr, s._str);
            delete[] _str;
            _str = pStr;
        }
        return *this;
    }
    
    ~String() {
        if (_str) {
            delete[] _str;
            _str = nullptr;
        }
    }
private:
    char* _str;
};

现代版写法的 String 类

利用交换语义优化赋值运算符：

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 strTmp(s._str);
        swap(_str, strTmp._str);
    }
    
    String& operator=(String s) {
        swap(_str, s._str);
        return *this;
    }
    
    ~String() {
        if (_str) {
            delete[] _str;
            _str = nullptr;
        }
    }
private:
    char* _str;
};

写时拷贝 (了解)

在浅拷贝基础上增加引用计数。构造时计数为 1，每增加一个对象引用则计数加 1，销毁时减 1。仅当计数为 1 时才释放资源。这避免了不必要的深拷贝开销。

string 类的模拟实现 (完整示例)

#pragma once
#include <iostream>
#include <cstring>
#include <cassert>
using namespace std;

class mystring {
public:
    // 构造
    mystring(const char* s = "") {
        if (s == nullptr) {
            assert(false);
            return;
        }
        _str = new char[strlen(s) + 1];
        strcpy(_str, s);
        _capacity = _size = strlen(s);
    }
    
    // 拷贝构造
    mystring(const mystring& s) {
        _str = new char[s._capacity + 1];
        strcpy(_str, s._str);
        _size = s._size;
        _capacity = s._capacity;
    }
    
    // 析构
    ~mystring() {
        delete[] _str;
        _str = nullptr;
        _size = _capacity = 0;
    }
    
    // 赋值
    mystring& operator=(const mystring& s) {
        delete[] _str;
        _str = new char[strlen(s._str) + 1];
        strcpy(_str, s._str);
        _size = s._size;
        _capacity = s._capacity;
        return *this;
    }
    
    // 比较运算符重载
    // 两个字符串相加
    mystring operator+(const mystring& s) const {
        mystring strtmp = *this;
        int newlenth = strlen(s._str) + strlen(_str) + 1;
        if (newlenth > strtmp._capacity) {
            char* newchar = new char[newlenth * 2];
            strcpy(newchar, strtmp._str);
            delete[] strtmp._str;
            strtmp._str = newchar;
            strtmp._capacity = newlenth * 2;
        }
        strcat(strtmp._str, s._str);
        strtmp._size = newlenth - 1;
        return strtmp;
    }
    
    // +=
    mystring& operator+=(const mystring& s) {
        mystring strtmp = s;
        *this = (*this + strtmp);
        return *this;
    }
    
    // 交换
    void swap(mystring& s) {
        std::swap(_str, s._str);
        std::swap(_size, s._size);
        std::swap(_capacity, s._capacity);
    }
    
    // 打印
    void print() const {
        for (int i = 0; i < _size; i++) {
            printf("%c", _str[i]);
        }
        printf("\n");
    }
    
private:
    char* _str;
    int _size;
    int _capacity;
};

ostream& operator<<(ostream& out, const mystring& s) {
    s.print();
    return out;
}

istream& operator>>(istream& in, mystring& s) {
    int i = 0;
    char ch;
    while (in.get(ch) && ch != ' ' && ch != '\n') {
        s._str[i++] = ch;
    }
    s._str[i] = '\0';
    s._size = i;
    return in;
}

从手动计算长度、处理内存溢出的痛点，到使用 std::string 一行代码实现拼接查找，再到亲手拆解其动态扩容、深拷贝的底层逻辑，string 类的学习本质上是对 C++ 封装思想的实践。它把复杂的内存管理藏在底层，把简洁的接口留给开发者，既解决了 C 语言字符串的问题，也为后续 STL 容器的学习打下基础。