operator+ 应返回值而非引用，避免返回局部对象引用导致未定义行为；operator+= 才返回引用；输入输出流重载必须为非成员友元函数。
operator+ 重载必须返回值，不能返回引用
多数初学者在重载 operator+ 时习惯写成 MyClass& operator+(const MyClass& a, const MyClass& b)，这会导致返回局部对象的引用，引发未定义行为。加法语义是生成新对象，不是修改原对象。
- 正确做法：返回
MyClass（值类型），让编译器决定是否启用 RVO 或移动构造 - 如果真想避免拷贝，确保类已正确定义移动构造函数
- 不要为了“效率”强行返回引用——除非你明确在做
operator+=
class Vec {
public:
int x, y;
Vec(int x = 0, int y = 0) : x(x), y(y) {}
Vec operator+(const Vec& other) const {
return Vec(x + other.x, y + other.y); // ✅ 返回值，安全
}
Vec& operator+=(const Vec& other) {
x += other.x; y += other.y;
return *this; // ✅ operator+= 才返回引用
}
};输入输出流重载要用非成员函数，且必须声明为友元
operator 和 operator>> 的左操作数是 std::ostream 或 std::istream，而你无法修改标准库类。所以它们只能是非成员函数；又因需访问类的私有成员，通常需加 friend 声明。
- 不能把
operator 写成MyClass::operator —— 编译不过 - 如果类成员全是 public，可不加
friend，但违背封装原则 - 参数顺序固定：
std::ostream& operator
class Date {
int year, month, day;
public:
Date(int y, int m, int d) : year(y), month(m), day(d) {}
friend std::ostream& operator<<(std::ostream& os, const Date& d) {
return os << d.year << "-" << d.month << "-" << d.day; // ✅ 可访问私有成员
}
};前置++和后置++重载签名不同，后置必须带 int 形参
编译器靠参数列表区分前置（++a）和后置（a++）。C++ 规定后置版本必须接受一个 int（仅作标记，不使用），这是语法约定，不是设计选择。
- 前置：返回
T&（通常*this引用），无参数 - 后置：返回
T（旧值副本），必须有一个int参数（哪怕没名字） - 别漏掉
const限定符——如果你的类支持只读对象自增，前置也应加const？不，因为要改状态，所以前置通常不加const
class Counter {
int val;
public:
Counter(int v = 0) : val(v) {}
Counter& operator++() { // 前置
++val;
return *this;
}
Counter operator++(int) { // 后置：int 是必需的哑元
Counter old = *this;
++val;
return old;
}
};赋值运算符重载要注意自我赋值和异常安全
operator= 是唯一一个编译器默认生成、但用户重载后不会自动生成移动赋值的运算符。它必须处理 a = a 这种自我赋值，否则可能提前释放资源再试图访问野指针。
- 经典做法：先检查
this == &other，但更推荐“拷贝-交换”惯用法（copy-and-swap），天然规避自我赋值和部分异常问题 - 若类管理动态内存，记得在赋值前释放旧资源（或用智能指针托管）
- 返回
*this引用，以支持链式赋值如a = b = c
class String {
char* data;
public:
String(const char* s = "") : data(new char[strlen(s)+1]) {
strcpy(data, s);
}
String& operator=(String other) { // 注意：传值，触发拷贝/移动
swap(data, other.data);
return *this; // ✅ 拷贝-交换，简洁且安全
}
void swap(char*& a, char*& b) { char* t = a; a = b; b = t; }
};C++ 运算符重载真正难的不是语法，而是对语义一致性的坚持——比如 operator== 必须满足自反、对称、传递，operator 要提供严格弱序。这些约束不会报错，但会在 std::sort 或 std::map 里悄悄出问题。
