运算符重载

Vector2D a(1, 2), b(3, 4);
 
// 你写的表达式：
Vector2D c = a + b;
 
// 编译器实际翻译为（成员函数形式）：
Vector2D c = a.operator+(b);

class Vector2D {
private:
    double x_;  // x 分量
    double y_;  // y 分量
 
public:
    // 构造函数，使用初始化列表
    Vector2D(double x = 0, double y = 0) : x_(x), y_(y) {}
 
    // 成员函数形式重载 + 运算符
    // 返回值为新的 Vector2D 对象（值语义，不修改原对象）
    // 参数用 const 引用，避免不必要的拷贝，同时承诺不修改右操作数
    // 函数本身标记 const，承诺不修改左操作数（即 *this）
    Vector2D operator+(const Vector2D& rhs) const {
        return Vector2D(x_ + rhs.x_, y_ + rhs.y_);  // 分量逐一相加，返回新对象
    }
 
    // 成员函数形式重载一元负号 - （取反运算符）
    // 一元运算符无额外参数，操作数就是 *this
    Vector2D operator-() const {
        return Vector2D(-x_, -y_);  // 每个分量取反
    }
};

Vector2D a(1, 2), b(3, 4);
 
Vector2D c = a + b;    // 等价于 a.operator+(b)
//          ^左操作数     ^右操作数
//          (this)       (rhs)
 
Vector2D d = -a;        // 等价于 a.operator-()
//           ^操作数
//           (this)

class Vector2D {
    // ... 成员变量和其他函数同上 ...
 
    // 声明友元，使非成员函数可以访问 private 成员
    friend Vector2D operator+(const Vector2D& lhs, const Vector2D& rhs);
};
 
// 非成员函数形式重载 +
// lhs = left-hand side（左操作数）, rhs = right-hand side（右操作数）
Vector2D operator+(const Vector2D& lhs, const Vector2D& rhs) {
    return Vector2D(lhs.x_ + rhs.x_, lhs.y_ + rhs.y_);  // 分量逐一相加
}

class Money {
    int cents_;  // 以分为单位存储金额
public:
    Money(int c) : cents_(c) {}  // 允许 int 隐式转换为 Money
 
    // 成员函数形式重载 +
    Money operator+(const Money& rhs) const {
        return Money(cents_ + rhs.cents_);  // 两个金额相加
    }
};
 
int main() {
    Money wallet(500);         // 500 分 = 5 元
 
    Money result1 = wallet + 100;  // ✅ OK! 100 隐式转换为 Money(100)
    // 等价于: wallet.operator+(Money(100))
 
    Money result2 = 100 + wallet;  // ❌ 编译错误!
    // 等价于: (100).operator+(wallet) —— int 没有 operator+(Money) 方法
}

// 非成员函数形式，完美解决对称性
Money operator+(const Money& lhs, const Money& rhs) {
    return Money(lhs.cents_ + rhs.cents_);  // 两侧均可隐式转换
}
 
// 现在两个方向都能编译通过：
// 100 + wallet → operator+(Money(100), wallet) ✅
// wallet + 100 → operator+(wallet, Money(100)) ✅

class Counter {
    int value_;  // 计数器内部值
public:
    Counter(int v = 0) : value_(v) {}  // 默认构造，初始值为 0
 
    // 前置 ++ ：先自增，再返回自身引用（无额外参数）
    Counter& operator++() {
        ++value_;          // 直接自增内部值
        return *this;      // 返回自身引用，支持 ++(++c) 这样的链式调用
    }
 
    // 后置 ++ ：先保存旧值，再自增，返回旧值副本
    // 参数中的 int 是一个"哑参数"(dummy parameter)，仅用于区分前置和后置
    Counter operator++(int) {
        Counter old = *this;  // 先保存当前状态的副本
        ++value_;             // 再自增（或者调用前置++：++(*this)）
        return old;           // 返回自增前的旧值（by value）
    }
 
    // 复合赋值 += ：修改自身并返回自身引用
    Counter& operator+=(const Counter& rhs) {
        value_ += rhs.value_;  // 将右操作数的值累加到自身
        return *this;          // 返回自身引用，支持链式调用 a += b += c
    }
 
    // 获取内部值（const 成员函数，不修改对象）
    int getValue() const { return value_; }
};
 
// 基于 += 实现 +（DRY 原则：Don't Repeat Yourself）
// 这是一个非常经典的惯用法 (idiom)
Counter operator+(Counter lhs, const Counter& rhs) {
    lhs += rhs;    // 注意 lhs 是值传递（拷贝），所以修改 lhs 不影响原对象
    return lhs;    // 返回修改后的副本
}

// ===== 前置 ++c =====
// 步骤1: value_ 从 5 变为 6
// 步骤2: 返回 *this（引用，无拷贝）
//
//   Counter c:
//   ┌──────────┐
//   │ value_: 6│ ← 直接修改
//   └──────────┘
//       ↑
//     return (引用指向原对象)
 
// ===== 后置 c++ =====
// 步骤1: 创建 old 副本，old.value_ = 5
// 步骤2: value_ 从 5 变为 6
// 步骤3: 返回 old（值返回，是旧状态的副本）
//
//   Counter c:           Counter old (副本):
//   ┌──────────┐         ┌──────────┐
//   │ value_: 6│         │ value_: 5│ ← 保存了旧值
//   └──────────┘         └──────────┘
//                             ↑
//                           return (返回这个副本)

#include <iostream>  // 标准输入输出
#include <cmath>     // 数学函数（sqrt）
 
class Vector2D {
private:
    double x_;  // x 分量
    double y_;  // y 分量
 
public:
    // 构造函数，默认值为原点 (0, 0)
    Vector2D(double x = 0.0, double y = 0.0) : x_(x), y_(y) {}
 
    // ---------- 访问器 ----------
    double getX() const { return x_; }  // 获取 x 分量
    double getY() const { return y_; }  // 获取 y 分量
 
    // ---------- 一元运算符（成员函数）----------
 
    // 取反：返回方向相反的新向量
    Vector2D operator-() const {
        return Vector2D(-x_, -y_);  // 每个分量取反
    }
 
    // ---------- 复合赋值运算符（成员函数）----------
 
    // 向量加法赋值
    Vector2D& operator+=(const Vector2D& rhs) {
        x_ += rhs.x_;  // x 分量累加
        y_ += rhs.y_;  // y 分量累加
        return *this;   // 返回自身引用
    }
 
    // 标量乘法赋值（向量 × 标量）
    Vector2D& operator*=(double scalar) {
        x_ *= scalar;  // x 分量缩放
        y_ *= scalar;  // y 分量缩放
        return *this;   // 返回自身引用
    }
 
    // ---------- 关系运算符（成员函数，比较模长）----------
    bool operator==(const Vector2D& rhs) const {
        // 浮点数比较需要容差（epsilon），此处简化处理
        return (x_ == rhs.x_) && (y_ == rhs.y_);  // 分量完全相等
    }
 
    bool operator!=(const Vector2D& rhs) const {
        return !(*this == rhs);  // 复用 operator==，取反即可
    }
 
    // 求模长（辅助方法）
    double magnitude() const {
        return std::sqrt(x_ * x_ + y_ * y_);  // 勾股定理
    }
};
 
// ---------- 非成员二元算术运算符（基于 += 实现）----------
 
// 向量 + 向量
Vector2D operator+(Vector2D lhs, const Vector2D& rhs) {
    lhs += rhs;    // lhs 是值拷贝，直接在上面操作
    return lhs;    // 返回结果
}
 
// 向量 × 标量
Vector2D operator*(Vector2D v, double scalar) {
    v *= scalar;   // v 是值拷贝
    return v;      // 返回缩放后的向量
}
 
// 标量 × 向量（交换律支持，这就是非成员函数的价值）
Vector2D operator*(double scalar, Vector2D v) {
    v *= scalar;   // 复用 *= 的逻辑
    return v;      // 标量在左、向量在右也能工作
}
 
// ---------- 使用示例 ----------
int main() {
    Vector2D a(3.0, 4.0);   // 创建向量 a = (3, 4)
    Vector2D b(1.0, 2.0);   // 创建向量 b = (1, 2)
 
    Vector2D c = a + b;     // c = (4, 6)，调用 operator+(a的副本, b)
    Vector2D d = 2.0 * a;   // d = (6, 8)，调用 operator*(2.0, a的副本)
    Vector2D e = a * 0.5;   // e = (1.5, 2)，调用 operator*(a的副本, 0.5)
    Vector2D f = -a;        // f = (-3, -4)，调用 a.operator-()
 
    a += b;                 // a 变为 (4, 6)，调用 a.operator+=(b)
 
    if (a != b) {           // 调用 a.operator!=(b)，内部复用 operator==
        std::cout << "a and b are different vectors" << std::endl;
    }
 
    return 0;
}

class Num {
    int val_;
public:
    Num(int v = 0) : val_(v) {}
    Num operator+(const Num& rhs) const { return Num(val_ + rhs.val_); }
    int getVal() const { return val_; }
};
 
int main() {
    Num a(10);
    Num b = a + 5;
    Num c = 5 + a;  // 此行
    std::cout << b.getVal() << std::endl;
}

// ==========================================
// MyString.h — 贯穿全文的示例类
// ==========================================
#include <iostream>  // 引入标准输入输出流
#include <cstring>   // 引入 C 风格字符串操作函数 (strlen, strcpy 等)
 
class MyString {
private:
    char* m_data;    // 指向堆上动态分配的字符数组（核心数据）
    size_t m_len;    // 记录字符串长度（不含 '\0'）
 
public:
    // ---------- 构造函数 ----------
    MyString(const char* str = "") {            // 默认参数为空串
        m_len = std::strlen(str);               // 计算传入字符串的长度
        m_data = new char[m_len + 1];           // 在堆上分配 长度+1 的空间（+1 留给 '\0'）
        std::strcpy(m_data, str);               // 将内容复制到堆内存中
    }
 
    // ---------- 拷贝构造函数 ----------
    MyString(const MyString& other) {           // 参数为同类型的 const 引用
        m_len = other.m_len;                    // 复制长度
        m_data = new char[m_len + 1];           // 重新分配独立的堆空间（深拷贝的关键）
        std::strcpy(m_data, other.m_data);      // 复制实际数据
    }
 
    // ---------- 析构函数 ----------
    ~MyString() {                               // 对象生命周期结束时自动调用
        delete[] m_data;                        // 释放堆上分配的字符数组，防止内存泄漏
        m_data = nullptr;                       // 良好习惯：置空悬垂指针
    }
 
    // ---------- Getter ----------
    const char* c_str() const { return m_data; }  // 提供只读访问，模仿 std::string::c_str()
    size_t length() const { return m_len; }        // 返回字符串长度
 
    // 后续所有运算符重载将在此类中添加...
};

// ==========================================
// 赋值运算符 operator= 的深拷贝实现
// ==========================================
MyString& MyString::operator=(const MyString& other) {  // 返回自身引用，参数为 const 引用
    // —— 第一步：自赋值检测 (Self-assignment guard) ——
    if (this == &other) {      // 如果左操作数和右操作数是同一个对象
        return *this;          // 直接返回自身，避免不必要的操作
    }
 
    // —— 第二步：释放旧资源 (Release old memory) ——
    delete[] m_data;           // 先释放当前对象持有的旧堆内存
                               // 如果不释放就分配新内存，旧内存就泄漏了
 
    // —— 第三步：深拷贝新数据 (Deep copy new data) ——
    m_len = other.m_len;                    // 复制长度信息
    m_data = new char[m_len + 1];           // 分配全新的堆空间
    std::strcpy(m_data, other.m_data);      // 将 other 的数据逐字节复制过来
 
    // —— 第四步：返回自身引用 (Return *this) ——
    return *this;              // 返回当前对象的引用，支持链式赋值 a = b = c
}

MyString* ptr = &a;     // ptr 指向 a
a = *ptr;               // 实际上就是 a = a，自赋值！
 
MyString& ref = a;      // ref 是 a 的别名
a = ref;                // 同样是自赋值！

MyString a("Hello"), b, c;   // 创建三个对象
c = b = a;                   // 链式赋值：先执行 b = a，其返回值再赋给 c
                              // 等价于 c = (b = a);
                              // 如果 operator= 返回 void，这一行就无法编译

// ==========================================
// Copy-and-Swap 惯用法实现
// ==========================================
 
// 首先为类提供一个 swap 函数
void MyString::swap(MyString& other) noexcept {  // noexcept: swap 绝不抛异常
    std::swap(m_data, other.m_data);              // 交换两个指针（极低成本）
    std::swap(m_len, other.m_len);                // 交换两个长度值
}
 
// 注意参数是按值传递 (by value)，而非 const 引用！
MyString& MyString::operator=(MyString other) {   // 拷贝发生在参数传入时
    swap(other);                                   // 用 swap 交换当前对象和副本的内部数据
    return *this;                                  // 返回自身引用
}                                                  // other 离开作用域，析构函数自动释放"旧数据"

// ==========================================
// 相等运算符 operator== 的实现
// ==========================================
bool MyString::operator==(const MyString& other) const {  // 注意末尾的 const！
    // 优化：如果长度不同，内容一定不同，提前返回
    if (m_len != other.m_len) {        // 先比较长度，O(1) 快速排除
        return false;                   // 长度不等，直接返回 false
    }
    // 长度相同时，逐字符比较内容
    return std::strcmp(m_data, other.m_data) == 0;  // strcmp 返回 0 表示完全相同
}

const MyString a("test");    // a 是 const 对象
const MyString b("test");    // b 也是 const 对象
if (a == b) { /* ... */ }    // 如果 operator== 不是 const，这行编译失败！

// ==========================================
// 不等运算符 operator!= —— 复用 operator==
// ==========================================
bool MyString::operator!=(const MyString& other) const {
    return !(*this == other);   // 直接对 operator== 的结果取反
                                 // *this 就是当前对象，调用上面已定义的 ==
}

// ==========================================
// 支持 MyString == "hello" 的写法
// ==========================================
bool MyString::operator==(const char* str) const {
    if (str == nullptr) {               // 防御性编程：检查空指针
        return m_len == 0;              // 空指针视为空串，与长度为0的对象相等
    }
    return std::strcmp(m_data, str) == 0;  // 直接比较底层 C 字符串
}

MyString name("Alice");          // 创建 MyString 对象
if (name == "Alice") {           // 直接与字面量比较，无需构造临时对象
    std::cout << "Match!\n";     // 输出匹配信息
}

MyString s("Hello");
std::cout << s;       // 左操作数是 std::cout (类型 ostream)，右操作数是 s (类型 MyString)

// 错误示范！
std::ostream& MyString::operator<<(std::ostream& os) {
    os << m_data;
    return os;
}
// 使用方式变成了：s << std::cout;  ← 完全反直觉！

// ==========================================
// 在类声明中声明为 friend (MyString.h)
// ==========================================
class MyString {
    // ... 省略之前的成员 ...
 
    // 声明友元：允许此全局函数访问 MyString 的 private 成员
    friend std::ostream& operator<<(std::ostream& os, const MyString& str);
    friend std::istream& operator>>(std::istream& is, MyString& str);
};
 
// ==========================================
// 在类外部定义 (MyString.cpp)
// ==========================================
std::ostream& operator<<(std::ostream& os, const MyString& str) {
    os << str.m_data;    // 直接访问私有成员 m_data（因为是 friend）
                          // 将字符串内容写入输出流
    return os;            // 返回流引用，支持链式调用：cout << a << b << c
}

MyString a("Hello"), b("World");
std::cout << a << " " << b << std::endl;
// 展开过程：
// ((((std::cout << a) << " ") << b) << std::endl)
//   ↑ 返回 cout 引用  ↑ 返回 cout 引用  ↑ 返回 cout 引用

std::ostream& operator<<(std::ostream& os, const MyString& str) {
    // 正式输出：只输出内容
    os << str.m_data;
 
    // 调试输出（可通过编译宏控制）：
    #ifdef DEBUG_MODE
    os << " [len=" << str.m_len             // 输出长度信息
       << ", addr=" << (void*)str.m_data    // 输出堆地址（强转 void* 防止被当作字符串输出）
       << "]";
    #endif
 
    return os;                               // 别忘了返回流引用
}

// ==========================================
// 流提取运算符 operator>> 的实现
// ==========================================
std::istream& operator>>(std::istream& is, MyString& str) {
    // —— 第一步：准备一个临时缓冲区 ——
    const size_t BUF_SIZE = 1024;          // 设定最大输入长度（实际项目中可动态扩展）
    char buffer[BUF_SIZE];                  // 栈上临时缓冲区
 
    // —— 第二步：从流中读取输入 ——
    is >> buffer;                           // 默认以空白符为分隔符读取一个"单词"
                                            // 注意：这不会读取整行，只读取到下一个空格/换行
 
    // —— 第三步：检查读取是否成功 ——
    if (is) {                               // 检查流状态：如果读取成功
        delete[] str.m_data;                // 释放旧数据
        str.m_len = std::strlen(buffer);    // 更新长度
        str.m_data = new char[str.m_len + 1];  // 分配新空间
        std::strcpy(str.m_data, buffer);    // 复制缓冲区内容到新空间
    }
    // 如果读取失败（如遇到 EOF），str 保持原值不变
 
    return is;                              // 返回流引用，支持链式输入：cin >> a >> b
}

// ==========================================
// 更安全的 operator>> 实现（借助 std::string）
// ==========================================
std::istream& operator>>(std::istream& is, MyString& str) {
    std::string temp;            // std::string 会自动管理内存，无溢出风险
    is >> temp;                  // 读取输入到 std::string
 
    if (is) {                    // 流状态正常
        delete[] str.m_data;                          // 释放旧内存
        str.m_len = temp.length();                    // 更新长度
        str.m_data = new char[str.m_len + 1];         // 分配新空间
        std::strcpy(str.m_data, temp.c_str());        // 从 std::string 复制到 char 数组
    }
 
    return is;                   // 返回流引用
}

int main() {
    MyString greeting;                          // 默认构造，内部为空串 ""
 
    std::cout << "请输入一个单词: ";            // 提示用户输入
    std::cin >> greeting;                       // 调用 operator>>，读取用户输入
 
    std::cout << "你输入的是: " << greeting     // 调用 operator<<，输出结果
              << " (长度: " << greeting.length() << ")" 
              << std::endl;
 
    // 链式输入演示
    MyString first, second;                     // 两个空串对象
    std::cout << "请输入两个单词: ";
    std::cin >> first >> second;                // 链式读取，先读 first，再读 second
    std::cout << first << " & " << second << std::endl;
 
    return 0;
}

MyString a("Hi");
MyString b = a;       // 这是【拷贝构造】！b 是新对象，正在初始化。等价于 MyString b(a);
MyString c("Go");
c = a;                // 这是【赋值运算符】！c 已经存在，正在被覆盖。

// 错误！返回局部对象引用
MyString& operator=(const MyString& other) {
    MyString temp(other);    // 局部临时对象
    return temp;             // temp 在函数结束时被销毁，返回的引用变成悬垂引用！
}

#include <iostream>
#include <cstring>
 
class Str {
    char* p;
public:
    Str(const char* s = "") {
        p = new char[strlen(s) + 1];
        strcpy(p, s);
    }
    // 注意：没有自定义拷贝构造函数和 operator=
    ~Str() { delete[] p; }
 
    friend std::ostream& operator<<(std::ostream& os, const Str& s) {
        return os << s.p;
    }
};
 
int main() {
    Str a("CPP");
    Str b("Java");
    b = a;
    std::cout << b << std::endl;
    return 0;
}

class Point {
    int x, y;
public:
    Point(int a, int b) : x(a), y(b) {}
    // 请选择正确的声明
};

class MyClass {
private:
    int secret;  // 私有数据，外部正常情况下不可访问
 
public:
    MyClass(int val) : secret(val) {}  // 构造函数初始化私有成员
 
    // 在类内部声明友元函数：授权 showSecret 可以访问私有成员
    // 注意：这只是"声明"，不是"定义"，函数体在类外部实现
    friend void showSecret(const MyClass& obj);
};
 
// 友元函数的定义——注意，它不属于类，没有 MyClass:: 作用域符
// 它就是一个普通的全局函数，只不过被 MyClass "信任"了
void showSecret(const MyClass& obj) {
    // 直接访问 obj 的私有成员 secret，这在普通函数中是不可能的
    std::cout << "Secret value: " << obj.secret << std::endl;
}
 
int main() {
    MyClass m(42);       // 创建对象，secret = 42
    showSecret(m);       // 调用友元函数，输出: Secret value: 42
    return 0;
}

// 成员函数重载 +，等价于 a.operator+(b)
MyClass operator+(const MyClass& rhs);

std::cout << obj;   // 左操作数是 ostream，不是 MyClass
std::cin >> obj;    // 左操作数是 istream，不是 MyClass

Complex c(3, 4);
Complex r1 = c + 5;     // 可以：成员函数 c.operator+(5)，编译器将 5 隐式转换
Complex r2 = 5 + c;     // 错误！5.operator+(c) —— int 没有这个成员函数！

// 友元全局函数，两个参数地位完全对等
friend Complex operator+(const Complex& lhs, const Complex& rhs);

#include <iostream>   // 引入标准输入输出流
#include <string>     // 引入 string 类型
 
class Student {
private:
    std::string name;  // 学生姓名（私有）
    int age;           // 学生年龄（私有）
    double gpa;        // 学生绩点（私有）
 
public:
    // 构造函数：使用初始化列表设置所有成员
    Student(const std::string& n, int a, double g)
        : name(n), age(a), gpa(g) {}
 
    // 声明友元：允许全局的 operator<< 访问 Student 的私有成员
    // 返回 ostream& 是为了支持链式调用：cout << s1 << s2
    friend std::ostream& operator<<(std::ostream& os, const Student& stu);
 
    // 声明友元：允许全局的 operator>> 访问并修改 Student 的私有成员
    // 注意 stu 不是 const，因为需要往里写入数据
    friend std::istream& operator>>(std::istream& is, Student& stu);
};
 
// ===== operator<< 的定义 =====
// 参数1：ostream& os —— 输出流的引用（不能是 const，因为写入操作会改变流状态）
// 参数2：const Student& stu —— 被输出的学生对象（const 因为只读取不修改）
// 返回值：ostream& —— 返回流本身的引用，以支持链式调用
std::ostream& operator<<(std::ostream& os, const Student& stu) {
    os << "Student{"                    // 输出前缀
       << "name: " << stu.name         // 直接访问私有成员 name（友元特权）
       << ", age: " << stu.age         // 直接访问私有成员 age
       << ", gpa: " << stu.gpa         // 直接访问私有成员 gpa
       << "}";                          // 输出后缀
    return os;                          // 返回流引用，支持 cout << s1 << s2
}
 
// ===== operator>> 的定义 =====
// 参数1：istream& is —— 输入流的引用
// 参数2：Student& stu —— 要写入数据的学生对象（非 const）
// 返回值：istream& —— 返回流引用，支持 cin >> s1 >> s2
std::istream& operator>>(std::istream& is, Student& stu) {
    std::cout << "Enter name: ";        // 提示用户输入姓名
    is >> stu.name;                     // 从输入流读取数据到私有成员 name
    std::cout << "Enter age: ";         // 提示用户输入年龄
    is >> stu.age;                      // 读取到私有成员 age
    std::cout << "Enter GPA: ";        // 提示用户输入绩点
    is >> stu.gpa;                      // 读取到私有成员 gpa
    return is;                          // 返回流引用，支持链式输入
}
 
int main() {
    Student s1("Alice", 20, 3.8);       // 创建一个预设的 Student 对象
    std::cout << s1 << std::endl;       // 链式输出，先调用 operator<<(cout, s1)，返回 cout
    // 输出: Student{name: Alice, age: 20, gpa: 3.8}
 
    Student s2("", 0, 0.0);            // 创建一个空的 Student 对象
    std::cin >> s2;                     // 调用 operator>>(cin, s2)，用户交互式输入
    std::cout << s2 << std::endl;       // 输出用户刚才输入的数据
    return 0;
}

class Engine {
private:
    int horsepower;           // 马力——私有数据
    double temperature;       // 引擎温度——私有数据
 
public:
    Engine(int hp) : horsepower(hp), temperature(90.0) {}  // 构造函数
 
    // 将 Car 声明为友元类
    // Car 的所有成员函数都可以访问 Engine 的私有成员
    friend class Car;
};
 
class Car {
private:
    Engine engine;            // Car 拥有一个 Engine 对象（组合关系）
 
public:
    Car(int hp) : engine(hp) {}  // 构造时初始化引擎马力
 
    void showEngineInfo() const {
        // 直接访问 engine 的私有成员——因为 Car 是 Engine 的友元
        std::cout << "Horsepower: " << engine.horsepower << std::endl;   // 访问私有
        std::cout << "Temperature: " << engine.temperature << std::endl; // 访问私有
    }
 
    void overheat() {
        engine.temperature += 50.0;  // 直接修改 Engine 的私有数据
        std::cout << "Engine overheating! Temp: " << engine.temperature << std::endl;
    }
};
 
int main() {
    Car myCar(350);           // 创建一辆 350 马力的车
    myCar.showEngineInfo();   // 输出: Horsepower: 350 \n Temperature: 90
    myCar.overheat();         // 输出: Engine overheating! Temp: 140
    return 0;
}

class Point {
private:
    double x, y;          // 私有坐标数据
 
public:
    Point(double x, double y) : x(x), y(y) {}  // 构造函数
 
    // 提供公有的只读访问接口，代替友元
    double getX() const { return x; }   // getter for x
    double getY() const { return y; }   // getter for y
};
 
// 无需友元，通过 public getter 实现功能
double distance(const Point& a, const Point& b) {
    double dx = a.getX() - b.getX();   // 通过 getter 获取 x 差值
    double dy = a.getY() - b.getY();   // 通过 getter 获取 y 差值
    return std::sqrt(dx * dx + dy * dy); // 计算欧几里得距离
}

class B;  // 前向声明：告诉编译器 B 是一个类，但此时编译器不知道 B 的任何细节
 
class A {
private:
    int data;                           // A 的私有数据
 
public:
    A(int d) : data(d) {}              // 构造函数
 
    // 声明 B 的成员函数 showA 为 A 的友元
    // 此时编译器只需要知道 B 存在（前向声明足够），不需要知道 B 的完整定义
    friend void B::showA(const A& a);  // ⚠️ 编译错误！
};
 
class B {
public:
    void showA(const A& a) {
        std::cout << a.data << std::endl;  // 想访问 A 的私有成员
    }
};

class A;   // 前向声明 A（B 的 showA 参数中用到了 A&）
 
class B {
public:
    void showA(const A& a);  // 先声明（不定义），参数是 A 的引用，前向声明够用
};
 
class A {
private:
    int data;                           // A 的私有数据
 
public:
    A(int d) : data(d) {}              // 构造函数
    friend void B::showA(const A& a);  // 现在 B 已完整定义，编译器知道 showA 存在 ✅
};
 
// 此时 A 也已完整定义，可以在函数体中访问 A 的私有成员
void B::showA(const A& a) {
    std::cout << a.data << std::endl;   // 友元特权，访问 A 的私有成员
}

class Vector2D {
private:
    double x, y;                        // 二维向量的两个分量
 
public:
    Vector2D(double x, double y) : x(x), y(y) {}  // 构造函数
 
    // Hidden Friend：友元函数直接在类内部定义
    // 这个函数虽然写在类里面，但它不是成员函数！
    // 它是一个全局函数，只是"恰好"在类内部定义了
    friend Vector2D operator+(const Vector2D& a, const Vector2D& b) {
        return Vector2D(a.x + b.x, a.y + b.y);  // 直接访问两个对象的私有成员
    }
 
    // Hidden Friend 重载 <<
    friend std::ostream& operator<<(std::ostream& os, const Vector2D& v) {
        os << "(" << v.x << ", " << v.y << ")";  // 访问私有成员输出
        return os;                                 // 返回流引用
    }
};
 
int main() {
    Vector2D a(1.0, 2.0);               // 向量 a = (1, 2)
    Vector2D b(3.0, 4.0);               // 向量 b = (3, 4)
    std::cout << a + b << std::endl;     // 输出: (4, 6)
    return 0;
}

#include <iostream>
 
class Box {
private:
    int width;
 
public:
    Box(int w) : width(w) {}
 
    friend Box operator+(const Box& a, const Box& b) {
        return Box(a.width + b.width);
    }
 
    friend std::ostream& operator<<(std::ostream& os, const Box& b) {
        os << "[" << b.width << "]";
        return os;
    }
};
 
int main() {
    Box a(3), b(7), c(10);
    std::cout << a + b + c << std::endl;
    return 0;
}

// 当你写下：
MyString a, b, c;
c = a + b;
 
// 编译器实际执行的是：
c.operator=(a.operator+(b));
// 或者如果是非成员重载：
c.operator=(operator+(a, b));

class MyString {
    char* m_data;   // 堆上动态分配的字符数组
    size_t m_len;   // 字符串长度
 
public:
    // 赋值运算符重载 —— 使用 copy-and-swap 惯用法
    MyString& operator=(MyString other) {  // 注意：参数按值传递，自动触发拷贝构造
        swap(*this, other);                // 交换当前对象与临时副本的内部资源
        return *this;                      // 返回自身引用，支持链式赋值 a = b = c
    }                                      // other 离开作用域时自动释放旧资源
 
    // 友元 swap 函数，交换两个对象的内部状态
    friend void swap(MyString& first, MyString& second) noexcept {
        using std::swap;          // 启用 ADL（Argument-Dependent Lookup）
        std::swap(first.m_data, second.m_data);  // 交换指针，O(1)
        std::swap(first.m_len, second.m_len);    // 交换长度
    }
};

class Point {
    double m_x;   // x 坐标
    double m_y;   // y 坐标
 
public:
    // 声明友元 —— 允许该非成员函数访问 private 成员
    friend std::ostream& operator<<(std::ostream& os, const Point& pt);
    friend std::istream& operator>>(std::istream& is, Point& pt);
};
 
// 流插入运算符 —— 输出格式: (x, y)
std::ostream& operator<<(std::ostream& os, const Point& pt) {
    os << "(" << pt.m_x << ", " << pt.m_y << ")";  // 直接访问私有成员
    return os;                                        // 返回流引用，支持链式输出
}
 
// 流提取运算符 —— 从输入流读取两个 double
std::istream& operator>>(std::istream& is, Point& pt) {
    is >> pt.m_x >> pt.m_y;   // 按顺序读入 x 和 y
    if (!is) {                 // 检查流状态，输入失败则恢复默认值
        pt = Point{};          // 将对象重置为默认状态
    }
    return is;                 // 返回流引用，支持链式输入
}

class Student {
    std::string m_name;   // 学生姓名
    int m_score;          // 学生成绩
 
public:
    // == 运算符：逐字段比较
    bool operator==(const Student& rhs) const {  // const 保证不修改当前对象
        return m_name == rhs.m_name              // 比较姓名
            && m_score == rhs.m_score;           // 且比较成绩
    }
 
    // != 运算符：直接基于 == 取反，避免逻辑重复
    bool operator!=(const Student& rhs) const {
        return !(*this == rhs);   // 复用 operator==，单一职责
    }
};
 
// C++20 起，只需定义 operator<=> 即可自动生成全部比较运算符
// auto operator<=>(const Student&) const = default;

class Vector2D {
    double x, y;
public:
    Vector2D(double x, double y) : x(x), y(y) {}
 
    Vector2D& operator+(const Vector2D& rhs) {
        x += rhs.x;
        y += rhs.y;
        return *this;
    }
};
 
int main() {
    Vector2D a(1, 2), b(3, 4), c(0, 0);
    c = a + b;
    // 此时 a 的值是多少？
}

// 正确的 operator+ 实现
Vector2D operator+(const Vector2D& rhs) const {  // 注意 const
    return Vector2D(x + rhs.x, y + rhs.y);       // 返回新对象
}