类与对象

// 使用 class 关键字定义一个类
class ClassName {
    // 成员变量 (Member Variables / Data Members)
    // 成员函数 (Member Functions / Methods)
};  // ⚠️ 注意：类定义末尾的分号是强制的，遗漏会导致编译错误

#include <iostream>  // 引入输入输出流库
#include <string>    // 引入 string 类型
 
class Student {
public:                          // 访问控制符，暂时用 public 以便外部访问
    std::string name;            // 成员变量：学生姓名（string 类型）
    int age;                     // 成员变量：学生年龄（int 类型）
    double gpa;                  // 成员变量：学生绩点（double 类型）
};                               // ⚠️ 分号不可省略
 
int main() {
    Student s1;                  // 创建 Student 类的一个对象 s1
    s1.name = "Alice";           // 通过 . 运算符访问并赋值成员变量
    s1.age = 20;                 // 设置年龄
    s1.gpa = 3.85;               // 设置绩点
 
    Student s2;                  // 创建另一个对象 s2
    s2.name = "Bob";             // s2 拥有完全独立的数据副本
    s2.age = 22;
    s2.gpa = 3.60;
 
    // s1 和 s2 的 name/age/gpa 互不干扰
    std::cout << s1.name << ": " << s1.gpa << std::endl;  // 输出: Alice: 3.85
    std::cout << s2.name << ": " << s2.gpa << std::endl;  // 输出: Bob: 3.6
    return 0;
}

class Example {
public:
    char   a;   // 1 字节
    int    b;   // 4 字节
    char   c;   // 1 字节
};
// sizeof(Example) 通常不是 6，而是 12！

class ExampleOptimized {
public:
    int    b;   // 4 字节（偏移 0）
    char   a;   // 1 字节（偏移 4）
    char   c;   // 1 字节（偏移 5）
    // 尾部填充 2 字节，使总大小为 8（4 的倍数）
};
// sizeof(ExampleOptimized) = 8，节省了 4 字节！

#include <iostream>
 
class Student {
public:
    std::string name;             // 非静态：每个对象各一份
    static int totalStudents;     // 静态：所有 Student 对象共享
 
    // 构造函数中递增计数器（构造函数详见后续章节）
    Student(const std::string& n) : name(n) {
        ++totalStudents;          // 每创建一个对象，计数器 +1
    }
};
 
// ⚠️ 静态成员变量必须在类外进行定义（分配存储空间）
// 这一步容易遗忘，遗忘会导致链接错误 (linker error)
int Student::totalStudents = 0;
 
int main() {
    Student s1("Alice");          // totalStudents 变为 1
    Student s2("Bob");            // totalStudents 变为 2
    Student s3("Charlie");        // totalStudents 变为 3
 
    // 推荐通过 类名::成员 的方式访问静态变量
    std::cout << "Total: " << Student::totalStudents << std::endl;  // 输出: Total: 3
 
    // 也可以通过对象访问（不推荐，容易造成误解）
    std::cout << "Total: " << s1.totalStudents << std::endl;        // 输出: Total: 3
    return 0;
}

class Config {
public:
    int width = 1920;                  // C++11: 类内直接给默认值
    int height = 1080;                 // 如果构造函数没有显式初始化，就使用这个默认值
    std::string title = "My Window";   // string 类型同样支持
    bool fullscreen = false;           // bool 类型
};
 
int main() {
    Config cfg;                        // 无需手动赋值，所有成员已有默认值
    // cfg.width == 1920, cfg.height == 1080, cfg.title == "My Window"
    return 0;
}

#include <iostream>
#include <string>
 
class Student {
public:
    std::string name;
    int age;
    double gpa;
 
    // ========== 方式一：类内定义 (Inline Definition) ==========
    // 直接在 class {} 内部写函数体
    // 编译器会隐式将其视为 inline 候选
    void display() {
        std::cout << "Name: " << name           // 直接访问成员变量 name
                  << ", Age: " << age            // 直接访问成员变量 age
                  << ", GPA: " << gpa            // 直接访问成员变量 gpa
                  << std::endl;
    }
 
    // ========== 方式二：类内只放声明 ==========
    void setInfo(const std::string& n, int a, double g);  // 只有声明，没有函数体
};
 
// ========== 方式二的定义部分：类外定义 (Out-of-Class Definition) ==========
// 使用 ClassName::functionName 语法，明确该函数属于哪个类
void Student::setInfo(const std::string& n, int a, double g) {
    name = n;     // 等价于 this->name = n;
    age = a;      // 等价于 this->age = a;
    gpa = g;      // 等价于 this->gpa = g;
}
 
int main() {
    Student s;                         // 创建对象
    s.setInfo("Alice", 20, 3.85);     // 调用成员函数设置数据
    s.display();                       // 调用成员函数展示数据
    return 0;                          // 输出: Name: Alice, Age: 20, GPA: 3.85
}

class Circle {
private:
    double radius;                        // 半径
 
public:
    // 构造函数：设置半径
    Circle(double r) : radius(r) {}
 
    // ✅ const 成员函数：承诺不修改任何成员变量
    double getArea() const {
        return 3.14159265358979 * radius * radius;  // 只读访问 radius
    }
 
    // ✅ const 成员函数：只读操作
    double getRadius() const {
        return radius;                    // 只是返回值，不做修改
    }
 
    // ✅ 非 const 成员函数：需要修改成员变量
    void setRadius(double r) {
        radius = r;                       // 修改了 radius
    }
};
 
int main() {
    const Circle c(5.0);                  // 创建一个 const 对象
    // c.setRadius(10.0);                 // ❌ 编译错误！const 对象不能调用非 const 成员函数
    double a = c.getArea();               // ✅ 合法：getArea() 是 const 函数
    return 0;
}

#include <iostream>
#include <string>
 
class Printer {
public:
    // 重载 1：打印整数
    void print(int value) {
        std::cout << "Integer: " << value << std::endl;
    }
 
    // 重载 2：打印浮点数
    void print(double value) {
        std::cout << "Double: " << value << std::endl;
    }
 
    // 重载 3：打印字符串
    void print(const std::string& value) {
        std::cout << "String: " << value << std::endl;
    }
};
 
int main() {
    Printer p;
    p.print(42);                  // 调用重载 1 → Integer: 42
    p.print(3.14);                // 调用重载 2 → Double: 3.14
    p.print(std::string("Hi"));   // 调用重载 3 → String: Hi
    return 0;
}

class TextBuffer {
private:
    std::string data;
 
public:
    TextBuffer(const std::string& s) : data(s) {}
 
    // 非 const 版本：返回可修改的引用
    char& at(size_t index) {
        std::cout << "[non-const at called]" << std::endl;
        return data[index];                 // 返回引用，调用者可以修改
    }
 
    // const 版本：返回只读的引用
    const char& at(size_t index) const {
        std::cout << "[const at called]" << std::endl;
        return data[index];                 // 返回 const 引用，调用者不可修改
    }
};
 
int main() {
    TextBuffer buf("Hello");
    buf.at(0) = 'h';                       // 调用非 const 版本，可以修改
 
    const TextBuffer cbuf("World");
    char ch = cbuf.at(0);                   // 调用 const 版本，只能读取
    // cbuf.at(0) = 'w';                    // ❌ 编译错误：const 引用不可赋值
    return 0;
}

#include <iostream>
#include <string>
#include <cmath>       // 用于 std::sqrt
 
class Vec2D {
public:
    double x;          // x 坐标分量
    double y;          // y 坐标分量
 
    // ---- 成员函数 ----
 
    // 设置坐标值（类内定义）
    void set(double newX, double newY) {
        x = newX;      // 设置 x 分量
        y = newY;      // 设置 y 分量
    }
 
    // 计算向量长度（模）—— const 函数，不修改对象
    double length() const {
        return std::sqrt(x * x + y * y);   // 勾股定理: sqrt(x² + y²)
    }
 
    // 向量加法：返回一个新的 Vec2D 对象
    Vec2D add(const Vec2D& other) const {
        Vec2D result;                       // 创建临时对象存放结果
        result.x = x + other.x;            // 分量相加
        result.y = y + other.y;            // 分量相加
        return result;                      // 按值返回（编译器会做 RVO 优化）
    }
 
    // 打印向量信息
    void display() const {
        std::cout << "(" << x << ", " << y << ")"  // 格式化输出
                  << "  |v| = " << length()         // 调用自身的 const 成员函数
                  << std::endl;
    }
};
 
int main() {
    Vec2D v1;                    // 创建向量 v1
    v1.set(3.0, 4.0);           // 设置为 (3, 4)
 
    Vec2D v2;                    // 创建向量 v2
    v2.set(1.0, 2.0);           // 设置为 (1, 2)
 
    Vec2D v3 = v1.add(v2);      // v3 = v1 + v2 = (4, 6)
 
    v1.display();                // 输出: (3, 4)  |v| = 5
    v2.display();                // 输出: (1, 2)  |v| = 2.23607
    v3.display();                // 输出: (4, 6)  |v| = 7.2111
    return 0;
}

// 以下两个定义在行为上完全等价：
 
struct PointA {
    double x;          // 默认 public
    double y;          // 默认 public
};
 
class PointB {
public:                // 必须显式声明 public
    double x;
    double y;
};

class Widget {
    char   tag;
    double value;
    int    id;
};

class BankAccount {
public:
    // --- public 接口：外界与该类交互的唯一合法途径 ---
 
    // 存款操作，外部可以调用
    void deposit(double amount) {
        if (amount > 0) {           // 对输入进行合法性校验
            balance_ += amount;     // 修改内部状态（私有数据）
        }
    }
 
    // 查询余额，外部可以调用（const 表示不修改对象状态）
    double getBalance() const {
        return balance_;            // 返回私有数据的只读副本
    }
 
private:
    double balance_ = 0.0;         // 余额：外界不可直接触碰
};
 
int main() {
    BankAccount acc;                // 创建银行账户对象
    acc.deposit(1000.0);           // ✅ 合法：deposit 是 public
    double b = acc.getBalance();   // ✅ 合法：getBalance 是 public
    // acc.balance_ = 999999.0;    // ❌ 编译错误：balance_ 是 private
    return 0;
}

class TemperatureSensor {
public:
    // 外部通过此接口获取温度（摄氏度）
    double getCelsius() const {
        return rawTocelsius(raw_value_);  // 调用私有转换函数
    }
 
    // 外部通过此接口更新传感器读数
    void updateReading(int raw) {
        raw_value_ = raw;                 // 更新内部原始数据
    }
 
private:
    int raw_value_ = 0;                   // 传感器的原始 ADC 值（实现细节）
 
    // 私有辅助函数：将原始值转换为摄氏度
    // 外部不需要知道转换公式，也不应该直接调用
    double rawTocelsius(int raw) const {
        return raw * 0.0625;              // 假设每个 ADC 单位 = 0.0625°C
    }
};

class Point {
public:
    Point(double x, double y) : x_(x), y_(y) {}  // 参数化构造
 
    // 计算当前点与另一个点的距离
    double distanceTo(const Point& other) const {
        // ✅ 合法！虽然 other.x_ 是 private，但我们在 Point 类内部
        double dx = x_ - other.x_;               // 直接访问 other 的私有成员
        double dy = y_ - other.y_;               // 同类对象之间无访问壁垒
        return std::sqrt(dx * dx + dy * dy);     // 计算欧几里得距离
    }
 
private:
    double x_, y_;                                // 坐标数据
};

class Shape {
public:
    // 纯虚函数：所有形状都必须能计算面积
    virtual double area() const = 0;
 
    // 公开接口：打印形状信息
    void printInfo() const {
        std::cout << "Color: " << color_        // 访问 protected 成员
                  << ", Area: " << area()        // 调用虚函数（多态）
                  << std::endl;
    }
 
protected:
    std::string color_ = "red";                  // 颜色：子类可能需要访问/修改
    // 外部不应直接改颜色，但 Circle、Rectangle 等子类需要
 
private:
    int internal_id_ = 0;                        // 内部 ID：连子类都不需要知道
};
 
class Circle : public Shape {
public:
    Circle(double r) : radius_(r) {}             // 构造函数
 
    double area() const override {               // 实现基类的纯虚函数
        return 3.14159265 * radius_ * radius_;   // π * r²
    }
 
    void setColor(const std::string& c) {
        color_ = c;                              // ✅ 合法：color_ 是 protected
        // internal_id_ = 42;                    // ❌ 编译错误：internal_id_ 是 private
    }
 
private:
    double radius_;                              // 半径：Circle 自己的私有数据
};
 
int main() {
    Circle c(5.0);
    c.printInfo();          // ✅ 合法：printInfo 是 public
    c.setColor("blue");     // ✅ 合法：setColor 是 public
    // c.color_ = "green";  // ❌ 编译错误：color_ 是 protected，外部不可访问
    return 0;
}

class Student {
public:
    // Getter：只读访问，用 const 修饰
    const std::string& getName() const {
        return name_;                    // 返回常引用，避免拷贝开销
    }
 
    // Setter：写入时可以加入校验逻辑
    void setAge(int age) {
        if (age >= 0 && age <= 150) {    // 校验：年龄必须合理
            age_ = age;                  // 通过校验后才真正赋值
        }
        // 不合理的值直接忽略（也可抛异常）
    }
 
    int getAge() const {
        return age_;                     // 返回年龄的只读副本
    }
 
private:
    std::string name_ = "Unknown";      // 姓名：外部不可直接修改
    int age_ = 0;                        // 年龄：外部不可直接修改
};

class ImmutablePoint {
public:
    // 构造时一次性设定所有数据
    ImmutablePoint(double x, double y) : x_(x), y_(y) {}
 
    double getX() const { return x_; }  // 只读
    double getY() const { return y_; }  // 只读
    // 没有 setX / setY —— 构造后不可修改
 
private:
    const double x_;                    // const 成员：双重保险
    const double y_;
};

class Base {
protected:
    int value_ = 10;                         // protected 成员
};
 
class Derived : public Base {
public:
    void foo(Derived& d, Base& b) {
        value_ = 20;                         // ✅ 合法：访问自身继承来的 protected
        d.value_ = 30;                       // ✅ 合法：通过 Derived 类型访问
        // b.value_ = 40;                    // ❌ 编译错误！通过 Base 类型访问
    }
    // 原因：编译器无法确认 b 实际上是不是 Derived
    // 如果 b 是另一个派生类(如 OtherDerived)的对象，
    // 那 Derived 无权访问 OtherDerived 的 protected 成员
};

class MyClass {
public:          // 1. 公开接口放最前面 —— 用户最关心的
    // 类型别名 (Type aliases)
    // 构造函数 / 析构函数
    // 公有成员函数
    // 公有静态函数
 
protected:       // 2. 继承接口次之
    // protected 成员函数
    // protected 数据（尽量避免）
 
private:         // 3. 内部实现放最后 —— 用户不需要关心
    // 私有辅助函数
    // 私有数据成员
};

class Animal {
protected:
    std::string name_ = "Animal";
};
 
class Dog : public Animal {
public:
    void printName(Animal& a) {
        std::cout << a.name_ << std::endl;   // 第 A 行
    }
    void printOwn() {
        std::cout << name_ << std::endl;      // 第 B 行
    }
};
 
int main() {
    Dog d;
    Animal a;
    d.printName(a);
    d.printOwn();
    return 0;
}

class Point {
public:
    int x;  // 成员变量：x 坐标
    int y;  // 成员变量：y 坐标
    // 没有写任何构造函数
    // 编译器会隐式生成: Point() {}
};
 
int main() {
    Point p;              // 调用编译器生成的默认构造函数
    std::cout << p.x;     // ⚠️ 未定义行为！x 是垃圾值（garbage value）
    return 0;
}

class Point {
public:
    int x;  // x 坐标
    int y;  // y 坐标
 
    // 用户定义的默认构造函数（无参数）
    Point() {
        x = 0;  // 将 x 初始化为 0
        y = 0;  // 将 y 初始化为 0
    }
};
 
int main() {
    Point p;              // 调用用户定义的默认构造函数
    std::cout << p.x;     // ✅ 安全，输出 0
    return 0;
}

class Widget {
public:
    // 显式要求编译器生成默认构造函数
    // 即使类中存在其他构造函数，也能保留默认版本
    Widget() = default;
 
    // 参数化构造函数
    Widget(int val) : value(val) {}
 
private:
    int value;  // 成员变量
};
 
class NonCopyable {
public:
    NonCopyable() = default;                          // 允许默认构造
    NonCopyable(const NonCopyable&) = delete;         // 禁止拷贝构造
    NonCopyable& operator=(const NonCopyable&) = delete; // 禁止拷贝赋值
};

class Foo {
public:
    Foo(int x) {}   // 只定义了参数化构造函数
};
 
int main() {
    Foo f1(42);   // ✅ 正常：匹配参数化构造函数
    Foo f2;       // ❌ 编译错误！没有默认构造函数可用
    return 0;
}

class Rectangle {
public:
    double width;   // 矩形的宽
    double height;  // 矩形的高
 
    // 参数化构造函数：接收宽和高作为参数
    Rectangle(double w, double h) {
        width = w;    // 用传入的 w 初始化 width
        height = h;   // 用传入的 h 初始化 height
    }
 
    // 计算面积的成员函数
    double area() const {
        return width * height;  // 返回宽 × 高
    }
};
 
int main() {
    Rectangle r1(3.0, 4.0);    // 直接初始化（Direct initialization）
    Rectangle r2 = {5.0, 6.0}; // 列表初始化（C++11 List initialization）
    Rectangle r3{7.0, 8.0};    // 列表初始化（不带等号的简洁形式）
 
    std::cout << r1.area();     // 输出 12
    return 0;
}

Rectangle r4(3.5, 7);      // ✅ int 7 隐式转换为 double 7.0，允许
Rectangle r5{3.5, 7};      // ✅ 同上，允许（int → double 是扩展，不是窄化）
 
int a = 3.14;               // ⚠️ 窄化转换，编译器可能只给 warning
// int b{3.14};             // ❌ 编译错误！花括号禁止窄化转换

class Color {
public:
    int r, g, b;    // RGB 三通道
    float alpha;    // 透明度
 
    // 版本1：无参数 → 默认白色不透明
    Color() {
        r = 255;            // 红色通道最大值
        g = 255;            // 绿色通道最大值
        b = 255;            // 蓝色通道最大值
        alpha = 1.0f;       // 完全不透明
    }
 
    // 版本2：三参数 → 指定 RGB，透明度默认为 1.0
    Color(int red, int green, int blue) {
        r = red;            // 设置红色通道
        g = green;          // 设置绿色通道
        b = blue;           // 设置蓝色通道
        alpha = 1.0f;       // 透明度默认不透明
    }
 
    // 版本3：四参数 → 指定 RGB + 透明度
    Color(int red, int green, int blue, float a) {
        r = red;            // 设置红色通道
        g = green;          // 设置绿色通道
        b = blue;           // 设置蓝色通道
        alpha = a;          // 设置透明度
    }
};
 
int main() {
    Color white;                    // 调用版本1
    Color red(255, 0, 0);          // 调用版本2
    Color semiBlue(0, 0, 255, 0.5f); // 调用版本3
    return 0;
}

class Color {
public:
    int r, g, b;     // RGB 三通道
    float alpha;     // 透明度
 
    // 一个构造函数通过默认参数覆盖多种使用场景
    Color(int red = 255, int green = 255, int blue = 255, float a = 1.0f)
        : r(red)         // 初始化 r
        , g(green)       // 初始化 g
        , b(blue)        // 初始化 b
        , alpha(a)       // 初始化 alpha
    {}
};
 
int main() {
    Color white;                       // 全部使用默认值 → (255,255,255,1.0)
    Color red(255, 0, 0);             // 只传3个 → alpha 使用默认值 1.0
    Color semiBlue(0, 0, 255, 0.5f);  // 全部自定义
    return 0;
}

class Meter {
public:
    double value;  // 长度值（米）
 
    // 单参数构造函数 → 可作为隐式转换函数
    Meter(double v) : value(v) {}
};
 
void printLength(Meter m) {
    std::cout << m.value << " meters" << std::endl;
}
 
int main() {
    printLength(3.14);  // 😱 编译通过！double 被隐式转换为 Meter
    // 等价于: printLength(Meter(3.14));
    return 0;
}

class Meter {
public:
    double value;  // 长度值（米）
 
    // explicit 阻止隐式转换
    explicit Meter(double v) : value(v) {}
};
 
void printLength(Meter m) {
    std::cout << m.value << " meters" << std::endl;
}
 
int main() {
    // printLength(3.14);          // ❌ 编译错误！不允许隐式转换
    printLength(Meter(3.14));      // ✅ 显式构造，意图清晰
    return 0;
}

class Student {
public:
    std::string name;  // 姓名
    int age;           // 年龄
 
    // 方式一：函数体内赋值（Assignment in body）
    Student(std::string n, int a) {
        // 进入函数体之前，name 已经被默认构造（调用了 string()）
        // 然后这里再用 = 赋值覆盖 → 做了两次工作！
        name = n;   // 赋值操作（operator=）
        age = a;    // 赋值操作
    }
 
    // 方式二：初始化列表（Member Initializer List）
    Student(std::string n, int a)
        : name(n)   // 直接用 n 构造 name → 只调用一次拷贝构造
        , age(a)     // 直接初始化 age
    {
        // 函数体为空，所有初始化已在列表中完成
    }
};

class Config {
public:
    const int MAX_SIZE;  // 常量成员：一旦初始化就不能修改
 
    // ❌ 错误写法：const 变量不能被赋值
    // Config(int size) { MAX_SIZE = size; }  // 编译错误！
 
    // ✅ 正确写法：在初始化列表中初始化
    Config(int size)
        : MAX_SIZE(size)     // const 成员必须在这里初始化
    {}
};

class Observer {
public:
    int& target;  // 引用成员：必须绑定到某个变量
 
    // ❌ 引用不能先悬空再绑定
    // Observer(int& t) { target = t; }  // 编译错误！
 
    // ✅ 引用必须在初始化时绑定
    Observer(int& t)
        : target(t)          // 引用在这里绑定到 t
    {}
};

class Engine {
public:
    int horsepower;  // 马力
 
    // Engine 只有参数化构造函数，没有默认构造函数
    Engine(int hp) : horsepower(hp) {}
};
 
class Car {
public:
    Engine engine;   // 成员类型 Engine 没有默认构造函数
 
    // ❌ 编译器无法默认构造 engine
    // Car() { engine = Engine(150); }  // 编译错误！
 
    // ✅ 必须在初始化列表中构造 engine
    Car()
        : engine(150)        // 直接调用 Engine(int) 构造 engine
    {}
};

class Trap {
public:
    int a;  // 声明顺序：先 a
    int b;  // 声明顺序：后 b
 
    // 初始化列表的书写顺序：先 b 后 a
    // 但实际执行顺序仍然是：先 a 后 b（按声明顺序）
    Trap(int val)
        : b(val)         // 虽然写在前面，但实际第二个执行
        , a(b)           // 虽然写在后面，但实际第一个执行
    {                    // ⚠️ 此时 b 还未初始化！a 得到的是垃圾值！
    }
};

class GameCharacter {
public:
    std::string name = "Unknown";   // 类内默认值
    int health = 100;                // 类内默认值
    int level = 1;                   // 类内默认值
    bool isAlive = true;             // 类内默认值
 
    // 默认构造函数：什么都不用写，成员会使用类内默认值
    GameCharacter() = default;
 
    // 参数化构造函数：初始化列表中的值会覆盖类内默认值
    GameCharacter(std::string n, int hp, int lv)
        : name(std::move(n))  // 覆盖默认值 "Unknown"
        , health(hp)          // 覆盖默认值 100
        , level(lv)           // 覆盖默认值 1
        // isAlive 没有出现在列表中 → 使用类内默认值 true
    {}
};

#include <iostream>   // 标准输入输出
#include <string>     // std::string
#include <utility>    // std::move
 
class BankAccount {
public:
    // ─── 类内默认值（C++11 NSDMI）───
    std::string owner = "Anonymous";  // 账户持有人
    double balance = 0.0;             // 余额
    const int id;                     // 账户 ID（const，必须初始化列表）
    bool isActive = true;             // 账户状态
 
    // ─── 默认构造函数 ───
    // id 是 const，必须在初始化列表中给值
    BankAccount()
        : id(0)                       // const 成员在此初始化
    {
        // owner, balance, isActive 使用类内默认值
        std::cout << "Default account created." << std::endl;
    }
 
    // ─── 参数化构造函数 ───
    explicit BankAccount(int accountId, std::string name, double initialBalance)
        : owner(std::move(name))      // 移动构造 string，高效
        , balance(initialBalance)     // 初始化余额
        , id(accountId)               // 初始化 const 成员
        // isActive 未出现 → 使用类内默认值 true
    {
        // 可以在函数体中做额外的验证逻辑
        if (balance < 0.0) {          // 如果初始余额为负数
            balance = 0.0;            // 修正为 0
            std::cout << "Warning: negative balance corrected to 0." << std::endl;
        }
    }
 
    // ─── 成员函数 ───
    void display() const {
        std::cout << "[ID: " << id            // 输出账户 ID
                  << "] " << owner            // 输出持有人
                  << " | Balance: $" << balance  // 输出余额
                  << " | Active: " << std::boolalpha << isActive  // 输出状态
                  << std::endl;
    }
};
 
int main() {
    BankAccount defaultAcc;                              // 调用默认构造函数
    BankAccount myAcc(1001, "Alice", 5000.0);            // 调用参数化构造函数
    BankAccount badAcc(1002, "Bob", -100.0);             // 触发余额修正
 
    defaultAcc.display();  // [ID: 0] Anonymous | Balance: $0 | Active: true
    myAcc.display();       // [ID: 1001] Alice | Balance: $5000 | Active: true
    badAcc.display();      // [ID: 1002] Bob | Balance: $0 | Active: true
 
    return 0;
}

class Logger {
public:
    std::string tag;       // 日志标签
    int level;             // 日志级别
    bool enabled;          // 是否启用
 
    // "主"构造函数：包含完整的初始化逻辑
    Logger(std::string t, int lv, bool en)
        : tag(std::move(t))   // 初始化标签
        , level(lv)           // 初始化级别
        , enabled(en)         // 初始化启用状态
    {
        std::cout << "Logger [" << tag << "] initialized." << std::endl;
    }
 
    // 委托构造函数：两个参数的版本，默认 enabled = true
    Logger(std::string t, int lv)
        : Logger(std::move(t), lv, true)   // 委托给三参数版本
    {
        // 注意：此处函数体在被委托构造函数体之后执行
    }
 
    // 委托构造函数：无参版本
    Logger()
        : Logger("DEFAULT", 0)             // 委托给两参数版本（链式委托）
    {}
};
 
int main() {
    Logger l1;                                // Logger() → Logger(s,i) → Logger(s,i,b)
    Logger l2("Network", 3);                  // Logger(s,i) → Logger(s,i,b)
    Logger l3("Database", 5, false);          // 直接调用三参数版本
    return 0;
}

class Animal {
public:
    std::string species;   // 物种名
 
    // 基类的参数化构造函数
    Animal(std::string s)
        : species(std::move(s))    // 初始化物种名
    {
        std::cout << "Animal(" << species << ") constructed." << std::endl;
    }
};
 
class Dog : public Animal {
public:
    std::string name;      // 狗的名字
 
    // 派生类构造函数：必须在初始化列表中调用基类构造函数
    Dog(std::string dogName)
        : Animal("Canis lupus familiaris")  // 先构造基类部分
        , name(std::move(dogName))          // 再初始化派生类成员
    {
        std::cout << "Dog(" << name << ") constructed." << std::endl;
    }
};
 
int main() {
    Dog myDog("Buddy");
    // 输出:
    // Animal(Canis lupus familiaris) constructed.
    // Dog(Buddy) constructed.
    return 0;
}

#include <iostream>
 
class X {
public:
    int a;
    int b;
 
    X(int val) : b(val), a(b) {}
};
 
int main() {
    X obj(42);
    std::cout << obj.a << " " << obj.b << std::endl;
    return 0;
}

class MyClass {
public:
    MyClass() {                        // 构造函数：对象诞生时调用
        std::cout << "构造" << std::endl;
    }
    ~MyClass() {                       // 析构函数：对象销毁时调用
        std::cout << "析构" << std::endl;
    }
};

#include <iostream>
#include <string>
 
class Tracer {
public:
    std::string name_;                                  // 用于标识当前对象
    Tracer(const std::string& name) : name_(name) {    // 参数化构造，记录名字
        std::cout << "[构造] " << name_ << std::endl;
    }
    ~Tracer() {                                         // 析构时打印，方便追踪
        std::cout << "[析构] " << name_ << std::endl;
    }
};
 
Tracer global("全局对象");        // 全局对象：程序启动时构造，程序退出时析构
 
void foo() {
    Tracer local("foo局部对象");  // 栈对象：进入 foo 时构造
    // ... foo 返回时，local 被析构
}
 
int main() {
    std::cout << "--- main 开始 ---" << std::endl;
 
    Tracer a("栈对象A");          // 栈对象：声明处构造
 
    {                              // 花括号开辟一个新的作用域
        Tracer b("栈对象B");      // b 在这个小作用域内有效
    }                              // b 在此处被析构
 
    foo();                         // 调用 foo，内部 local 在 foo 结束时析构
 
    Tracer* p = new Tracer("堆对象P");  // 堆对象：new 时构造
    delete p;                            // 必须手动 delete，此处调用析构
 
    std::cout << "--- main 结束 ---" << std::endl;
    return 0;
    // 栈对象A 在 main 返回后析构
    // 全局对象 最后析构
}

#include <iostream>
#include <cstring>       // std::strlen, std::strcpy
 
class SimpleString {
private:
    char* data_;         // 指向堆上字符数组的指针（资源）
    size_t length_;      // 字符串长度
 
public:
    // 构造函数：获取资源
    SimpleString(const char* str = "") {
        length_ = std::strlen(str);                 // 计算传入字符串的长度
        data_ = new char[length_ + 1];              // 在堆上分配 length+1 个字节（+1 给 '\0'）
        std::strcpy(data_, str);                     // 将内容复制到堆内存中
        std::cout << "  [构造] 分配了 " << (length_ + 1) << " 字节" << std::endl;
    }
 
    // 析构函数：释放资源
    ~SimpleString() {
        std::cout << "  [析构] 释放 \"" << data_ << "\" 占用的 "
                  << (length_ + 1) << " 字节" << std::endl;
        delete[] data_;   // 释放构造函数中 new[] 分配的数组内存
        data_ = nullptr;  // 良好习惯：释放后置空指针，防止悬空指针（dangling pointer）
    }
 
    void print() const {
        std::cout << "  内容: \"" << data_ << "\", 长度: " << length_ << std::endl;
    }
};
 
int main() {
    SimpleString s1("Hello, RAII!");    // 构造时分配内存
    s1.print();                          // 正常使用
    // main 结束时 s1 自动析构 → 堆内存自动释放，无需手动 delete
    return 0;
}

// ======== 栈（Stack） ========        ======== 堆（Heap） ========
//
//  s1:                                   +---+---+---+---+---+---+---+
//  +-----------+                         | H | e | l | l | o | , |   |
//  | data_   ------>  (指向堆)   ------> +---+---+---+---+---+---+---+
//  | length_ = 12 |                      | R | A | I | I | ! |\0 |
//  +-----------+                         +---+---+---+---+---+---+
//
// 当 s1 析构时，delete[] data_ 释放堆上这 13 字节

~MyClass() noexcept {           // C++11 起，析构函数默认就是 noexcept
    try {
        // 如果清理操作可能失败，在内部 try-catch
        riskyCleanup();
    } catch (...) {
        // 吞掉异常，记录日志即可，绝不让异常逃逸
        std::cerr << "清理失败，但不能抛出异常" << std::endl;
    }
}

#include <iostream>
 
class Base {
public:
    Base() { std::cout << "Base 构造" << std::endl; }
    ~Base() { std::cout << "Base 析构" << std::endl; }   // ⚠️ 非虚析构！
};
 
class Derived : public Base {
private:
    int* data_;                                           // 派生类持有堆资源
public:
    Derived() : Base(), data_(new int[100]) {             // 构造时分配 400 字节
        std::cout << "Derived 构造，分配了 100 个 int" << std::endl;
    }
    ~Derived() {                                          // 派生类析构释放资源
        delete[] data_;                                   // 释放堆数组
        std::cout << "Derived 析构，释放了 100 个 int" << std::endl;
    }
};
 
int main() {
    Base* ptr = new Derived();   // 基类指针指向派生类对象（多态的标准用法）
    delete ptr;                   // ⚠️ 通过基类指针 delete
    return 0;
}

class Base {
public:
    Base() { std::cout << "Base 构造" << std::endl; }
    virtual ~Base() {                                   // ✅ 虚析构函数！
        std::cout << "Base 析构" << std::endl;
    }
};
 
class Derived : public Base {
private:
    int* data_;
public:
    Derived() : Base(), data_(new int[100]) {
        std::cout << "Derived 构造" << std::endl;
    }
    ~Derived() override {                               // override 明确标注重写
        delete[] data_;
        std::cout << "Derived 析构" << std::endl;
    }
};
 
int main() {
    Base* ptr = new Derived();
    delete ptr;                  // ✅ 现在会正确调用 Derived 的析构函数
    return 0;
}

class Interface {
public:
    virtual ~Interface() = 0;    // 声明为纯虚析构 → Interface 变成抽象类
};
 
// 必须在类外提供实现！否则链接器报错（linker error）
Interface::~Interface() {
    std::cout << "Interface 纯虚析构函数体" << std::endl;
}
 
class Impl : public Interface {
public:
    ~Impl() override {
        std::cout << "Impl 析构" << std::endl;
    }
};
 
int main() {
    // Interface obj;            // ❌ 编译错误：不能实例化抽象类
    Interface* p = new Impl();   // ✅ 可以通过指针使用
    delete p;                    // Impl 析构 → Interface 析构
    return 0;
}

// ============= 内存布局（简化示意） =============
//
// Base 的 vtable:                   Derived 的 vtable:
// +-----------------------+         +-----------------------+
// | slot 0: ~Base()       |         | slot 0: ~Derived()    |  ← 覆盖了 Base 的析构
// | slot 1: virtualFunc() |         | slot 1: virtualFunc() |
// +-----------------------+         +-----------------------+
//
// 当 Base* ptr = new Derived() 时：
//
// ptr ---> [ vptr | Base成员 | Derived成员 | data_ ]
//             |
//             v
//         Derived 的 vtable
//             |
//             slot 0 → ~Derived()   ← delete ptr 时通过 vptr 找到这里

class DefaultDemo {
public:
    ~DefaultDemo() = default;     // 显式要求编译器生成默认析构函数
    // 等价于不写析构函数，但更具自文档性（self-documenting）
};
 
class NoCopy {
public:
    ~NoCopy() = delete;           // 禁止析构！对象无法被正常销毁
    // ⚠️ 极端用法：栈对象无法编译，堆对象 delete 也会报错
    // 实际应用非常罕见，几乎不会用到
};

class PolymorphicBase {
public:
    virtual ~PolymorphicBase() = default;   // ✅ 虚析构 + 默认实现，简洁优雅
};

#include <iostream>
 
class Member {
    std::string tag_;                                   // 成员标识
public:
    Member(const std::string& t) : tag_(t) {
        std::cout << "  Member(" << tag_ << ") 构造" << std::endl;
    }
    ~Member() {
        std::cout << "  Member(" << tag_ << ") 析构" << std::endl;
    }
};
 
class GrandBase {
public:
    GrandBase()  { std::cout << "GrandBase 构造" << std::endl; }
    virtual ~GrandBase() { std::cout << "GrandBase 析构" << std::endl; }
};
 
class Parent : public GrandBase {
    Member m1_{"Parent::m1"};                           // 第一个成员
    Member m2_{"Parent::m2"};                           // 第二个成员
public:
    Parent()  { std::cout << "Parent 构造" << std::endl; }
    ~Parent() override { std::cout << "Parent 析构" << std::endl; }
};
 
class Child : public Parent {
    Member m3_{"Child::m3"};                            // 派生类的成员
public:
    Child()  { std::cout << "Child 构造" << std::endl; }
    ~Child() override { std::cout << "Child 析构" << std::endl; }
};
 
int main() {
    std::cout << "===== 构造过程 =====" << std::endl;
    Child c;
    std::cout << "\n===== 析构过程 =====" << std::endl;
    return 0;
}

#include <iostream>
class Animal {
public:
    Animal()          { std::cout << "A"; }
    virtual ~Animal() { std::cout << "a"; }
};
 
class Dog : public Animal {
public:
    Dog()          { std::cout << "D"; }
    ~Dog() override { std::cout << "d"; }
};
 
class Puppy : public Dog {
public:
    Puppy()          { std::cout << "P"; }
    ~Puppy() override { std::cout << "p"; }
};
 
int main() {
    Animal* p = new Puppy();
    std::cout << "|";
    delete p;
    return 0;
}

ClassName(const ClassName& other);

// ========== 场景 1：直接初始化 ==========
MyClass a;           // 默认构造
MyClass b(a);        // 拷贝构造：用 a 初始化 b
 
// ========== 场景 2：拷贝初始化（= 号初始化） ==========
MyClass c = a;       // 注意！这是拷贝构造，不是赋值！
                     // 因为 c 正在被创建（初始化），不是已存在的对象
 
// ========== 场景 3：函数参数按值传递 ==========
void process(MyClass obj) {   // obj 是 a 的拷贝
    // ...
}
process(a);          // 调用拷贝构造，将 a 复制到形参 obj
 
// ========== 场景 4：函数按值返回 ==========
MyClass create() {
    MyClass local;   // 局部对象
    return local;    // 理论上触发拷贝构造（实际中常被 RVO/NRVO 优化掉）
}

class IntArray {
private:
    int* data_;       // 指向堆上动态数组的裸指针
    size_t size_;     // 数组大小
 
public:
    // ---------- 参数化构造函数 ----------
    explicit IntArray(size_t size)
        : data_(new int[size]())   // 在堆上分配数组，零初始化
        , size_(size)              // 记录大小
    {}
 
    // ---------- 析构函数 ----------
    ~IntArray() {
        delete[] data_;            // 释放堆内存
        data_ = nullptr;           // 防止悬空指针（好习惯）
    }
 
    // ---------- 访问接口 ----------
    int& operator[](size_t index) {       // 下标运算符重载
        return data_[index];              // 返回引用以支持读写
    }
 
    size_t size() const { return size_; } // 返回数组大小
};

int main() {
    IntArray a(5);       // a.data_ -> [0, 0, 0, 0, 0]（堆内存块 A）
    a[0] = 42;           // 修改第一个元素
 
    IntArray b(a);       // 编译器合成的拷贝构造：浅拷贝
                         // b.data_ 现在也指向堆内存块 A！
                         // b.size_ = 5
 
    b[0] = 99;           // 修改 b 的数据——但 a 的数据也被改了！
    // 此时 a[0] == 99，因为 a 和 b 共享同一块内存
 
    return 0;            // 灾难发生：a 和 b 的析构函数都会 delete[] 同一块内存
                         // 第二次 delete[] -> 未定义行为（通常是崩溃）
}

class IntArray {
    // ... （成员变量与析构同上）
 
public:
    // ---------- 深拷贝构造函数 ----------
    IntArray(const IntArray& other)
        : data_(new int[other.size_])   // 关键：分配全新的堆内存
        , size_(other.size_)            // 拷贝大小
    {
        // 将 other 的数据逐元素复制到新内存中
        for (size_t i = 0; i < size_; ++i) {
            data_[i] = other.data_[i];  // 复制每个元素的值
        }
        // 也可以使用 std::copy 或 std::memcpy 替代循环：
        // std::copy(other.data_, other.data_ + size_, data_);
    }
};

ClassName& operator=(const ClassName& other);

IntArray a(5);       // 默认构造
IntArray b(a);       // 拷贝构造（b 正在被创建）
IntArray c(3);       // 默认构造
c = a;               // 拷贝赋值（c 已经存在，被重新赋值）

// ❌ 危险的拷贝赋值实现
IntArray& operator=(const IntArray& other) {
    delete[] data_;                      // 先释放自己的旧内存
    data_ = new int[other.size_];        // 分配新内存
    size_ = other.size_;                 // 拷贝大小
    for (size_t i = 0; i < size_; ++i) {
        data_[i] = other.data_[i];       // 拷贝数据
    }
    return *this;                        // 返回自身引用
}

// ✅ 带自赋值检查的拷贝赋值
IntArray& operator=(const IntArray& other) {
    if (this == &other) {               // 检查：是否在给自己赋值？
        return *this;                    // 如果是，直接返回，什么都不做
    }
 
    delete[] data_;                      // 释放旧资源
    data_ = new int[other.size_];        // 分配新资源
    size_ = other.size_;                 // 更新大小
    for (size_t i = 0; i < size_; ++i) {
        data_[i] = other.data_[i];       // 深拷贝数据
    }
    return *this;                        // 返回自身引用以支持链式赋值
}

class IntArray {
private:
    int* data_;
    size_t size_;
 
public:
    // ---------- 构造函数 ----------
    explicit IntArray(size_t size = 0)
        : data_(size ? new int[size]() : nullptr)  // 条件分配
        , size_(size)
    {}
 
    // ---------- 析构函数 ----------
    ~IntArray() {
        delete[] data_;            // 释放堆内存（delete nullptr 是安全的）
    }
 
    // ---------- 深拷贝构造函数 ----------
    IntArray(const IntArray& other)
        : data_(other.size_ ? new int[other.size_] : nullptr)  // 分配新内存
        , size_(other.size_)                                    // 拷贝大小
    {
        std::copy(other.data_, other.data_ + size_, data_);     // 拷贝全部数据
    }
 
    // ---------- swap 友元函数 ----------
    // 使用 friend 函数而非成员函数，以便支持 ADL（Argument-Dependent Lookup）
    friend void swap(IntArray& first, IntArray& second) noexcept {
        using std::swap;                 // 引入 std::swap 作为候选
        swap(first.data_, second.data_); // 交换指针（极轻量，不抛异常）
        swap(first.size_, second.size_); // 交换大小
    }
 
    // ---------- 拷贝赋值运算符（Copy-and-Swap） ----------
    IntArray& operator=(IntArray other) {  // ⚠️ 注意：参数是按值传递！
        // 按值传递已经完成了 "Copy" 这一步（调用了拷贝构造函数）
        swap(*this, other);                // "Swap"：交换 this 和 other 的内部状态
        return *this;                      // other 在函数结束时析构，释放旧资源
    }
 
    // ---------- 下标访问 ----------
    int& operator[](size_t i) { return data_[i]; }
    const int& operator[](size_t i) const { return data_[i]; }
    size_t size() const { return size_; }
};

class Widget {
public:
    // 显式要求编译器生成默认拷贝构造
    Widget(const Widget&) = default;
 
    // 显式要求编译器生成默认拷贝赋值
    Widget& operator=(const Widget&) = default;
};
 
class UniqueResource {
public:
    // 禁止拷贝构造——此类型的对象不可被复制
    UniqueResource(const UniqueResource&) = delete;
 
    // 禁止拷贝赋值
    UniqueResource& operator=(const UniqueResource&) = delete;
 
    // 这就是 std::unique_ptr 不能被拷贝的原理！
};

UniqueResource a;
UniqueResource b(a);     // ❌ 编译错误：use of deleted function
UniqueResource c;
c = a;                   // ❌ 编译错误：use of deleted function

#include <cstring>    // strlen, strcpy
#include <algorithm>  // std::swap
#include <iostream>   // std::ostream
 
class String {
private:
    char* data_;      // 指向堆上字符数组的指针
    size_t length_;   // 字符串长度（不含 '\0'）
 
public:
    // ========== 构造函数 ==========
    // 从 C 风格字符串构造
    String(const char* str = "")                    // 默认参数为空串
        : length_(std::strlen(str))                 // 计算长度
        , data_(new char[std::strlen(str) + 1])     // 分配 长度+1 的空间（含 '\0'）
    {
        std::strcpy(data_, str);                    // 将字符串内容拷贝到堆内存
    }
 
    // ========== 析构函数 ==========
    ~String() {
        delete[] data_;                             // 释放字符数组
    }
 
    // ========== 拷贝构造函数（深拷贝） ==========
    String(const String& other)
        : length_(other.length_)                    // 拷贝长度
        , data_(new char[other.length_ + 1])        // 分配独立的新内存
    {
        std::strcpy(data_, other.data_);            // 深拷贝字符串内容
    }
 
    // ========== swap 函数 ==========
    friend void swap(String& a, String& b) noexcept {
        using std::swap;                            // 启用 ADL
        swap(a.data_, b.data_);                     // 交换指针
        swap(a.length_, b.length_);                 // 交换长度
    }
 
    // ========== 拷贝赋值（Copy-and-Swap） ==========
    String& operator=(String other) {               // 按值传递 → 自动拷贝
        swap(*this, other);                         // 交换内部状态
        return *this;                               // other 析构时释放旧资源
    }
 
    // ========== 工具函数 ==========
    size_t length() const { return length_; }       // 返回长度
    const char* c_str() const { return data_; }     // 返回 C 风格字符串
 
    // ========== 输出运算符重载 ==========
    friend std::ostream& operator<<(std::ostream& os, const String& s) {
        return os << s.data_;                       // 输出字符串内容
    }
};