1. 运算符与表达式：C++编程的基石
在C++的世界里，运算符和表达式就像建筑工地上的各种工具和材料。想象你是一位建筑工程师，运算符就是你的锤子、锯子和水平仪，而表达式则是你用这些工具搭建起来的房屋框架。没有它们，你连最简单的木凳都造不出来。
我至今记得第一次用C++写计算器程序时的场景。当时为了一个简单的除法运算，我折腾了整整一个下午才搞明白整数除法和浮点数除法的区别。这种看似基础的概念，在实际编程中往往成为新手最容易栽跟头的地方。运算符和表达式构成了C++最基本的计算单元，从简单的加减乘除到复杂的类型转换，它们无处不在。
这篇文章将带你系统梳理C++中的运算符体系，从最基础的算术运算开始，逐步深入到重载运算符等高级特性。无论你是刚接触C++的新手，还是想巩固基础的中级开发者，这些内容都将成为你编程工具箱中不可或缺的部分。
2. 基础运算符详解
2.1 算术运算符：程序世界的四则运算
算术运算符是我们最早接触的运算符类型，包括加减乘除这些基本运算。但在C++中，它们的行为可能比你想象的更复杂。
cpp复制int a = 10 / 3; // 结果是3，不是3.333...
double b = 10.0 / 3; // 这才是3.333...
这里有个关键点：当两个整数相除时，结果会被截断为整数。这是我见过新手最常犯的错误之一。要得到浮点结果，至少有一个操作数必须是浮点类型。
取模运算符(%)也值得特别注意：
cpp复制int remainder = 10 % 3; // 结果是1
它只能用于整数类型，很多初学者尝试对浮点数使用%会导致编译错误。
提示：在商业计算中，建议使用标准库中的< cmath >函数而不是原生运算符，因为它们提供了更好的精度控制和错误处理。
2.2 关系与逻辑运算符：程序决策的核心
关系运算符(>, <, ==等)和逻辑运算符(&&, ||, !)构成了程序决策的基础。它们通常出现在条件语句和循环中。
一个常见的陷阱是混淆赋值(=)和相等(==)：
cpp复制if (x = 5) { // 这总是为真，因为这是赋值不是比较
// ...
}
逻辑运算符的短路特性也非常重要：
cpp复制if (ptr != nullptr && ptr->isValid()) {
// 安全访问ptr成员
}
如果ptr为nullptr，后半部分不会执行，避免了空指针解引用。
2.3 位运算符：底层操作的利器
位运算符(&, |, ^, ~, <<, >>)允许我们直接操作数据的二进制表示。它们在系统编程、加密算法和性能优化中特别有用。
例如，快速判断奇偶：
cpp复制bool isOdd = num & 1; // 比num % 2 == 1更高效
位移运算符常用于乘除2的幂次方：
cpp复制int doubled = num << 1; // 相当于num * 2
int halved = num >> 1; // 相当于num / 2
注意：右移有符号数的行为是实现定义的，可能进行算术移位(保留符号位)或逻辑移位。对无符号数总是逻辑移位。
3. 表达式求值与类型转换
3.1 表达式求值顺序的陷阱
C++中表达式的求值顺序比你想象的更复杂。例如：
cpp复制int i = 0;
cout << i << " " << ++i << endl; // 输出可能是"0 1"或"1 1"
这是因为函数参数的求值顺序是未指定的。类似的还有：
cpp复制arr[i] = i++; // 未定义行为
黄金法则：不要在同一个表达式中对同一变量进行多次修改。
3.2 隐式类型转换的暗流
C++会自动进行多种隐式类型转换，这可能导致意外的结果：
cpp复制int i = 3.14; // i变为3
double d = 10; // d变为10.0
unsigned u = -1; // 非常大的正数！
更隐蔽的是整数提升：
cpp复制uint8_t a = 200;
uint8_t b = 100;
uint8_t c = a + b; // 可能溢出，因为a+b先被提升为int
3.3 显式类型转换的四种方式
C++提供了四种显式类型转换方式：
- static_cast：最常用的安全转换
cpp复制double d = 3.14;
int i = static_cast<int>(d);
- dynamic_cast：用于多态类型的向下转换
- const_cast：移除const限定符
- reinterpret_cast：低级的重新解释（极其危险）
建议：优先使用static_cast，避免C风格的(int)d转换，它们更危险且不易搜索。
4. 运算符重载：赋予自定义类型原生体验
4.1 重载基础：让类像内置类型一样工作
运算符重载允许我们为自定义类型定义运算符行为。例如为复数类重载+：
cpp复制class Complex {
public:
Complex operator+(const Complex& other) const {
return Complex(real + other.real, imag + other.imag);
}
// ...
};
Complex a(1,2), b(3,4);
Complex c = a + b; // 现在可以这样使用
4.2 流运算符重载：自定义输入输出
重载<<和>>可以实现自定义的流操作：
cpp复制ostream& operator<<(ostream& os, const Complex& c) {
return os << "(" << c.real << "," << c.imag << ")";
}
Complex c(1,2);
cout << c; // 输出(1,2)
4.3 下标和函数调用运算符
这些运算符让类可以像数组或函数一样使用：
cpp复制class MyArray {
public:
int& operator[](size_t index) { return data[index]; }
// ...
};
MyArray arr;
arr[0] = 10; // 使用下标运算符
函数调用运算符：
cpp复制class Adder {
public:
int operator()(int a, int b) { return a + b; }
};
Adder add;
int sum = add(3,4); // 像函数一样使用
注意：运算符重载应当保持直观语义，不要为了炫技而滥用。例如，重载+应该执行某种"加法"操作。
5. 高级话题与性能考量
5.1 移动语义与运算符重载
现代C++中，移动语义可以显著提升运算符重载的性能：
cpp复制Matrix operator+(Matrix&& lhs, const Matrix& rhs) {
// 可以重用lhs的存储空间
lhs += rhs;
return std::move(lhs);
}
5.2 三路比较运算符(C++20)
C++20引入了<=>三路比较运算符，简化了比较运算符的实现：
cpp复制struct Point {
int x, y;
auto operator<=>(const Point&) const = default;
};
// 现在==,!=,<,<=,>,>=都自动可用
5.3 表达式模板：延迟求值技术
在数值计算库中，表达式模板可以避免临时对象创建：
cpp复制Vector x = a + b + c;
// 传统方式会创建a+b的临时对象
// 表达式模板可以一次性计算a+b+c
这种高级技术常用于线性代数库如Eigen。
6. 常见陷阱与最佳实践
6.1 运算符优先级陷阱
即使是有经验的程序员也常被运算符优先级坑到：
cpp复制int mask = 1 << 4 + 1; // 实际上是1 << (4 + 1)
bool result = a & b == 0; // 实际上是a & (b == 0)
建议：不确定时就用括号，它们不影响性能但能避免错误。
6.2 重载运算符的对称性
当重载二元运算符时，通常需要提供对称版本：
cpp复制class Complex {
Complex operator+(int); // Complex + int
friend Complex operator+(int, const Complex&); // int + Complex
};
6.3 异常安全考虑
运算符重载应该保持基本的异常安全保证：
cpp复制String& String::operator=(const String& other) {
if (this != &other) {
String temp(other); // 先构造副本
swap(temp); // 再交换，保证强异常安全
}
return *this;
}
7. 实战案例：设计一个安全的分数类
让我们把这些知识应用到一个实际的Fraction类设计中：
cpp复制class Fraction {
int numerator;
int denominator;
void normalize() {
int gcd = std::gcd(numerator, denominator);
numerator /= gcd;
denominator /= gcd;
if (denominator < 0) {
numerator = -numerator;
denominator = -denominator;
}
}
public:
Fraction(int num, int denom = 1)
: numerator(num), denominator(denom)
{
if (denominator == 0) throw std::runtime_error("Zero denominator");
normalize();
}
// 算术运算符
Fraction operator+(const Fraction& other) const {
return Fraction(
numerator * other.denominator + other.numerator * denominator,
denominator * other.denominator
);
}
// 比较运算符
bool operator==(const Fraction& other) const {
return numerator == other.numerator && denominator == other.denominator;
}
// 流运算符
friend std::ostream& operator<<(std::ostream& os, const Fraction& f) {
return os << f.numerator << "/" << f.denominator;
}
// 类型转换
explicit operator double() const {
return static_cast<double>(numerator) / denominator;
}
};
这个实现展示了多个关键点：
- 构造函数中的参数验证
- 运算符重载的规范实现
- 友元函数用于流操作
- 显式类型转换运算符
- 自动约分保持规范形式
在实际项目中，你还需要考虑更多边界情况，比如溢出处理、异常安全等。但以上代码已经展示了一个健壮的运算符重载实现的核心要素。