标准库中的运算符重载：std::string、std::vector、std::complex 深度分析

说实话，C++ 标准库里的运算符重载，是我觉得最值得学习的地方。你想想看，如果 std::string 不能用 + 拼接字符串，std::vector 不能用 [] 访问元素，那写代码得多痛苦？

我个人习惯把标准库的运算符重载分成三类：容器类（如 string、vector）、数值类（如 complex）、智能指针类（如 shared_ptr）。今天咱们重点聊前两类，因为它们最能体现运算符重载的设计哲学。

std::string：最优雅的字符串操作

我在项目中遇到过不少团队，明明用着 C++，却还在用 strcat、strcpy 那一套。其实 std::string 的运算符重载已经做得非常完善了。

拼接与追加：operator+ 和 operator+=

这两个运算符是 string 最常用的。我刚开始用的时候还担心性能问题，后来看了源码才放心——operator+= 是原地操作，不会频繁重新分配内存。

std::string s1 = "Hello, ";
std::string s2 = "World!";

// operator+ 返回新对象
std::string s3 = s1 + s2;  // "Hello, World!"

// operator+= 原地追加
s1 += s2;  // s1 变成 "Hello, World!"

// 混合类型也支持
std::string s4 = s1 + " C++";  // 字符串字面量
std::string s5 = s1 + '!';     // 单个字符

比较操作：operator==、operator!=、operator< 等

string 重载了全套比较运算符。它们按字典序比较，大小写敏感。这一点和 C 风格的 strcmp 完全一致，但写法更自然。

std::string a = "apple";
std::string b = "banana";

if (a < b) {
    // 成立，因为 'a' < 'b'
}

// 与 C 字符串比较
if (a == "apple") {
    // 成立，string 重载了与 const char* 的比较
}

下标访问：operator[]

这个没什么好说的，和数组一样用。但要注意边界问题——operator[] 不检查越界，越界是未定义行为。如果你想要安全检查，用 at() 成员函数。

std::string s = "C++";
char c = s[0];  // 'C'
s[1] = '-';     // 变成 "C-+"

// 危险操作
// char d = s[100];  // 未定义行为！

std::vector：容器操作的基石

vector 的运算符重载相对克制，但每个都恰到好处。我个人觉得，vector 的运算符设计是「少即是多」的典范。

下标访问：operator[]

和 string 一样，vector 的 operator[] 也不做边界检查。这是为了性能考虑——毕竟 vector 的设计目标之一就是「零开销抽象」。

std::vector<int> vec = {1, 2, 3, 4, 5};
int x = vec[2];  // 3
vec[0] = 10;     // 修改第一个元素

赋值操作：operator=

vector 的赋值运算符做了深拷贝。这意味着赋值后两个 vector 完全独立，修改一个不会影响另一个。

std::vector<int> v1 = {1, 2, 3};
std::vector<int> v2;

v2 = v1;  // 深拷贝
v1[0] = 100;

// v2[0] 仍然是 1，不受影响

比较操作：operator== 和 operator!=

vector 的比较是逐元素进行的。两个 vector 相等，当且仅当它们长度相同且每个对应元素都相等。

std::vector<int> a = {1, 2, 3};
std::vector<int> b = {1, 2, 3};
std::vector<int> c = {1, 2, 4};

if (a == b) {
    // 成立
}

if (a != c) {
    // 成立，因为最后一个元素不同
}

std::complex：数学运算的自然表达

说到运算符重载，std::complex 是我觉得最「理所当然」的一个。复数如果没有运算符重载，那代码简直没法看。

算术运算符：+、-、*、/

complex 重载了全套算术运算符，支持复数与复数、复数与标量之间的运算。我记得第一次用的时候，感觉就像在写数学公式一样自然。

#include <complex>

std::complex<double> c1(3.0, 4.0);  // 3 + 4i
std::complex<double> c2(1.0, 2.0);  // 1 + 2i

// 复数运算
auto sum = c1 + c2;      // (4.0, 6.0)
auto diff = c1 - c2;     // (2.0, 2.0)
auto prod = c1 * c2;     // (-5.0, 10.0)
auto quot = c1 / c2;     // (2.2, -0.4)

// 与标量混合运算
auto scaled = c1 * 2.0;  // (6.0, 8.0)

比较与输入输出

complex 重载了 == 和 !=，但没有 <、> 等关系运算符——因为复数在数学上就没有全序关系。这一点设计得非常严谨。

另外，operator<< 和 operator>> 也被重载了，方便直接打印和读取复数。

std::complex<double> c(3.0, 4.0);

// 输出格式：(3,4)
std::cout << c << std::endl;

// 从输入读取
std::cin >> c;

知识体系总览

下面这张图总结了标准库中三个典型类型的运算符重载情况。我建议你把它当作速查表，写代码时随时参考。

总结与避坑指南

好了，咱们来捋一捋今天的内容。标准库的运算符重载，说白了就是让自定义类型用起来像内置类型一样顺手。string 让你用 + 拼字符串，vector 让你用 [] 取元素，complex 让你用 * 做复数乘法——这些都是「直觉驱动」的设计。

最后分享几个我踩过的坑：

• string 拼接性能：别在循环里用 +，用 += 或 append()。我见过有人用 + 拼接 10 万次，程序跑了 3 秒多，改成 += 后瞬间完成。
• vector 下标越界：如果你不确定索引是否合法，用 at() 而不是 []。虽然 at() 会抛异常，但总比程序崩溃强。
• complex 的精度：默认用 double 类型。如果你需要更高精度，用 long double；如果内存敏感，用 float。