继承与多态 ⭐⭐

// 基类（父类）
class Base {
public:
    int pub_val;        // 公有成员
protected:
    int prot_val;       // 受保护成员
private:
    int priv_val;       // 私有成员
};
 
// 派生类（子类），以 public 方式继承 Base
// 语法：class 派生类名 : 继承方式 基类名
class Derived : public Base {
    // Derived 继承了 Base 的所有成员
    // 但对它们的"访问权限"取决于继承方式
};

#include <iostream>
#include <string>
using namespace std;
 
// ========== 基类：Animal ==========
class Animal {
public:
    string name;                        // 公有：名字，任何地方都能访问
 
    void eat() {                        // 公有方法
        cout << name << " is eating." << endl;
    }
 
protected:
    int age;                            // 受保护：年龄，仅类内和派生类可访问
 
    void sleep() {                      // 受保护方法
        cout << name << " is sleeping." << endl;
    }
 
private:
    string secret_id = "X-001";         // 私有：秘密编号，仅 Animal 类内可访问
 
    void internal_check() {             // 私有方法
        cout << "Internal check: " << secret_id << endl;
    }
};
 
// ========== 派生类：Dog，public 继承 Animal ==========
class Dog : public Animal {
public:
    void bark() {                       // Dog 自己的公有方法
        cout << name << " says: Woof!" << endl;  // ✅ name 是 public，可以访问
    }
 
    void show_info() {
        cout << "Name: " << name << endl;   // ✅ public 成员 → 可访问
        cout << "Age: " << age << endl;     // ✅ protected 成员 → 派生类内可访问
        sleep();                            // ✅ protected 方法 → 派生类内可调用
        // cout << secret_id;              // ❌ 编译错误！private 成员不可访问
        // internal_check();               // ❌ 编译错误！private 方法不可访问
    }
};
 
int main() {
    Dog dog;                            // 创建 Dog 对象
    dog.name = "Buddy";                 // ✅ name 在 public 继承后仍是 public
    dog.eat();                          // ✅ eat() 在 public 继承后仍是 public
    dog.bark();                         // ✅ Dog 自己的 public 方法
    // dog.age = 3;                     // ❌ age 是 protected，外部不可访问
    // dog.sleep();                     // ❌ sleep() 是 protected，外部不可访问
    dog.show_info();                    // ✅ 通过 public 方法间接访问 protected 成员
    return 0;
}

Animal* ptr = new Dog();    // ✅ 向上转型：基类指针指向派生类对象
ptr->name = "Rex";          // ✅ 通过基类指针访问 public 成员
ptr->eat();                 // ✅ 调用基类的 eat()
// ptr->bark();             // ❌ 基类指针看不到派生类独有的方法
delete ptr;                 // 注意：后续章节会讲虚析构函数的必要性

// ========== protected 继承示例 ==========
class Base {
public:
    void hello() {                          // 基类的 public 方法
        cout << "Hello from Base!" << endl;
    }
protected:
    int value = 42;                         // 基类的 protected 成员
};
 
// protected 继承
class Mid : protected Base {
public:
    void use_base() {
        hello();                            // ✅ hello() 在 Mid 中变为 protected，类内可访问
        cout << value << endl;              // ✅ value 仍然是 protected，类内可访问
    }
};
 
// Mid 的派生类
class Bottom : public Mid {
public:
    void deep_access() {
        hello();                            // ✅ hello() 在 Mid 中是 protected，Bottom 作为派生类可访问
        cout << value << endl;              // ✅ 同理
    }
};
 
int main() {
    Mid m;
    // m.hello();                           // ❌ hello() 已变为 protected，外部无法调用
    m.use_base();                           // ✅ 通过 Mid 自己的 public 方法间接调用
 
    Bottom b;
    b.deep_access();                        // ✅ Bottom 可以访问 protected 成员
    // b.hello();                           // ❌ 仍然是 protected，外部不可访问
    return 0;
}

Mid m;
// Base* ptr = &m;                          // ❌ 编译错误！protected 继承不允许外部进行向上转型
// 原因：外部"不知道" Mid 和 Base 有继承关系（这层关系被 protected 隐藏了）

class Mid : protected Base {
public:
    Base* get_base_ptr() {
        return this;                        // ✅ 类内部可以向上转型
    }
};

// ========== private 继承示例 ==========
class Engine {
public:
    void start() {                          // 基类 public 方法
        cout << "Engine started." << endl;
    }
protected:
    int horsepower = 200;                   // 基类 protected 成员
};
 
// Car 以 private 方式继承 Engine
// 语义：Car 不是一种 Engine，但 Car 内部用了 Engine 来实现功能
class Car : private Engine {
public:
    void ignite() {
        start();                            // ✅ start() 在 Car 中变为 private，类内可访问
        cout << "HP: " << horsepower << endl; // ✅ horsepower 变为 private，类内可访问
    }
};
 
// Car 的派生类
class SportsCar : public Car {
public:
    void turbo() {
        // start();                         // ❌ start() 在 Car 中已变为 private，孙子类无法访问
        // cout << horsepower;              // ❌ 同理，无法访问
    }
};
 
int main() {
    Car car;
    car.ignite();                           // ✅
    // car.start();                         // ❌ 外部无法调用，已变为 private
    // Engine* ptr = &car;                  // ❌ private 继承不允许外部向上转型
    return 0;
}

class Derived1 : Base { };             // 等价于 class Derived1 : private Base { }
                                        // class 默认是 private 继承
 
struct Derived2 : Base { };            // 等价于 struct Derived2 : public Base { }
                                        // struct 默认是 public 继承

#include <iostream>
using namespace std;
 
class Base {
public:
    Base() { cout << "[1] Base 构造" << endl; }       // 基类构造函数
    ~Base() { cout << "[4] Base 析构" << endl; }      // 基类析构函数
};
 
class Derived : public Base {
public:
    Derived() { cout << "[2] Derived 构造" << endl; }  // 派生类构造函数
    ~Derived() { cout << "[3] Derived 析构" << endl; } // 派生类析构函数
};
 
int main() {
    cout << "--- 创建对象 ---" << endl;
    Derived d;                                          // 创建派生类对象
    cout << "--- 对象即将销毁 ---" << endl;
    return 0;                                           // d 离开作用域，自动析构
}

class Base {
public:
    Base(int x) {                                       // 基类没有默认构造函数
        cout << "Base(" << x << ")" << endl;
    }
};
 
class Derived : public Base {
public:
    // 必须在初始化列表中调用 Base(int)
    Derived(int x, int y) : Base(x) {                  // 先初始化基类部分
        cout << "Derived(" << y << ")" << endl;
    }
};
 
int main() {
    Derived d(10, 20);                                  // 输出：Base(10) → Derived(20)
    return 0;
}

#include <iostream>
using namespace std;
 
class Base {
public:
    void func() {                                       // 基类无参版本
        cout << "Base::func()" << endl;
    }
    void func(int x) {                                  // 基类有参版本
        cout << "Base::func(" << x << ")" << endl;
    }
};
 
class Derived : public Base {
public:
    void func() {                                       // 派生类定义了同名 func()
        cout << "Derived::func()" << endl;
    }
    // 注意：此时 Base::func() 和 Base::func(int) 都被隐藏了！
};
 
int main() {
    Derived d;
    d.func();                                           // ✅ 调用 Derived::func()
    // d.func(42);                                      // ❌ 编译错误！Base::func(int) 被隐藏了
    d.Base::func(42);                                   // ✅ 使用作用域限定符显式调用
    return 0;
}

class Derived : public Base {
public:
    using Base::func;                                   // 将 Base 的所有 func 引入 Derived 作用域
    void func() {                                       // 派生类自己的版本仍然存在
        cout << "Derived::func()" << endl;
    }
};
 
int main() {
    Derived d;
    d.func();                                           // ✅ Derived::func()（精确匹配）
    d.func(42);                                         // ✅ Base::func(int)（通过 using 引入）
    return 0;
}

class Base {
public:
    int a;          // 4 bytes
    int b;          // 4 bytes
};
 
class Derived : public Base {
public:
    int c;          // 4 bytes
    int d;          // 4 bytes
};

#include <iostream>
using namespace std;
 
class A {
public:
    A() { cout << "A "; }
    ~A() { cout << "~A "; }
};
 
class B : public A {
public:
    B() { cout << "B "; }
    ~B() { cout << "~B "; }
};
 
class C : public B {
public:
    C() { cout << "C "; }
    ~C() { cout << "~C "; }
};
 
int main() {
    C obj;
    return 0;
}

#include <iostream>
using namespace std;
 
// 基类：动物
class Animal {
public:
    // 注意：这里没有 virtual 关键字
    void speak() {                          // 基类版本的 speak
        cout << "Animal speaks..." << endl;
    }
};
 
// 派生类：猫
class Cat : public Animal {
public:
    void speak() {                          // 派生类"隐藏"了基类的 speak
        cout << "Meow~" << endl;
    }
};
 
int main() {
    Cat myCat;                              // 创建一个 Cat 对象
    Animal* ptr = &myCat;                   // 用基类指针指向派生类对象（向上转型，完全合法）
    ptr->speak();                           // ❓ 输出什么？
    return 0;
}

#include <iostream>
using namespace std;
 
class Animal {
public:
    // ✅ 加上 virtual —— 这个函数现在是"虚函数"
    virtual void speak() {                  // 声明为虚函数
        cout << "Animal speaks..." << endl;
    }
};
 
class Cat : public Animal {
public:
    // 派生类重写（Override）基类的虚函数
    // 这里加不加 virtual 都可以，它已经"继承"了虚函数的性质
    void speak() {                          // 重写基类的 speak
        cout << "Meow~" << endl;
    }
};
 
class Dog : public Animal {
public:
    void speak() {                          // 重写基类的 speak
        cout << "Woof!" << endl;
    }
};
 
int main() {
    Cat myCat;                              // Cat 对象
    Dog myDog;                              // Dog 对象
 
    Animal* p1 = &myCat;                    // 基类指针 → Cat 对象
    Animal* p2 = &myDog;                    // 基类指针 → Dog 对象
 
    p1->speak();                            // ✅ 输出 "Meow~"  —— 调用的是 Cat::speak()
    p2->speak();                            // ✅ 输出 "Woof!"  —— 调用的是 Dog::speak()
 
    return 0;
}

void makeItSpeak(Animal animal) {           // ⚠️ 值传递：发生了对象切片（Object Slicing）！
    animal.speak();                         // 静态绑定 → 始终调用 Animal::speak()
}
 
void makeItSpeak(Animal& animal) {          // ✅ 引用传递：保留了多态性
    animal.speak();                         // 动态绑定 → 根据实际对象类型调用
}
 
void makeItSpeak(Animal* animal) {          // ✅ 指针传递：保留了多态性
    animal->speak();                        // 动态绑定 → 根据实际对象类型调用
}

class Animal {
public:
    virtual void speak() {                  // 虚函数
        cout << "Animal speaks..." << endl;
    }
};
 
class Cat : public Animal {
public:
    // ❌ 参数列表不同 → 这不是重写（Override），而是隐藏（Hide）！
    void speak(int volume) {                // 签名与基类不匹配
        cout << "Meow at volume " << volume << endl;
    }
};
 
int main() {
    Cat myCat;
    Animal* ptr = &myCat;
    ptr->speak();                           // 调用的依然是 Animal::speak()
    return 0;                               // 因为 Cat 并没有真正"重写"它
}

class Animal {
public:
    virtual void speak() {                  // 声明为 virtual
        cout << "Animal" << endl;
    }
};
 
class Cat : public Animal {
public:
    void speak() {                          // 没写 virtual，但它自动是虚函数
        cout << "Cat" << endl;
    }
};
 
class Kitten : public Cat {
public:
    void speak() {                          // 同样自动是虚函数（从 Animal 一路传递下来）
        cout << "Kitten" << endl;
    }
};
 
int main() {
    Kitten k;
    Animal* p1 = &k;                        // Animal 指针指向 Kitten
    Cat* p2 = &k;                           // Cat 指针指向 Kitten
 
    p1->speak();                            // 输出 "Kitten" ✅ 动态绑定
    p2->speak();                            // 输出 "Kitten" ✅ 动态绑定
    return 0;
}

class Animal {
public:
    virtual Animal* clone() {               // 返回 Animal*
        return new Animal(*this);           // 拷贝自身
    }
    virtual ~Animal() {}                    // 虚析构（良好实践）
};
 
class Cat : public Animal {
public:
    // ✅ 返回 Cat* 而不是 Animal* —— 这是合法的协变返回
    Cat* clone() override {                 // 返回类型是基类返回类型的派生类指针
        return new Cat(*this);              // 拷贝自身
    }
};
 
int main() {
    Cat myCat;
    Animal* pAnimal = &myCat;
    Animal* cloned = pAnimal->clone();      // 动态绑定 → 调用 Cat::clone()，返回的实际是 Cat*
    // cloned 的声明类型是 Animal*，但实际指向的是一个 Cat 对象
    delete cloned;
    return 0;
}

// ptr->speak() 的底层等价操作：
// 1. 通过 ptr 找到对象
// 2. 从对象中读取 vptr（虚表指针）
// 3. 在 vtable 中找到 speak() 对应的条目（假设是第 0 个）
// 4. 调用该条目中存储的函数指针
 
(*(ptr->vptr[0]))(ptr);                    // 伪代码：间接调用

#include <iostream>
#include <vector>
#include <memory>
using namespace std;
 
// 基类：图形（Shape）
class Shape {
public:
    virtual void draw() const {             // 虚函数：绘制图形
        cout << "Drawing a generic shape" << endl;
    }
    virtual double area() const {           // 虚函数：计算面积
        return 0.0;
    }
    virtual ~Shape() = default;             // 虚析构函数（最佳实践）
};
 
// 派生类：圆形
class Circle : public Shape {
private:
    double radius;                          // 半径
public:
    Circle(double r) : radius(r) {}         // 构造函数
 
    void draw() const override {            // 重写 draw
        cout << "Drawing a Circle (r=" << radius << ")" << endl;
    }
    double area() const override {          // 重写 area
        return 3.14159 * radius * radius;   // πr²
    }
};
 
// 派生类：矩形
class Rectangle : public Shape {
private:
    double width, height;                   // 宽和高
public:
    Rectangle(double w, double h)           // 构造函数
        : width(w), height(h) {}
 
    void draw() const override {            // 重写 draw
        cout << "Drawing a Rectangle (" << width << "x" << height << ")" << endl;
    }
    double area() const override {          // 重写 area
        return width * height;              // 宽 × 高
    }
};
 
// 派生类：三角形
class Triangle : public Shape {
private:
    double base, height;                    // 底和高
public:
    Triangle(double b, double h)            // 构造函数
        : base(b), height(h) {}
 
    void draw() const override {            // 重写 draw
        cout << "Drawing a Triangle (b=" << base << ", h=" << height << ")" << endl;
    }
    double area() const override {          // 重写 area
        return 0.5 * base * height;         // ½ × 底 × 高
    }
};
 
// ✅ 这个函数完全不知道具体是什么图形，但它能正确工作！
void renderAll(const vector<unique_ptr<Shape>>& shapes) {
    for (const auto& s : shapes) {          // 遍历所有图形
        s->draw();                          // 动态绑定：调用实际类型的 draw()
        cout << "  Area = " << s->area()    // 动态绑定：调用实际类型的 area()
             << endl;
    }
}
 
int main() {
    vector<unique_ptr<Shape>> canvas;       // 画布：存放各种图形
 
    canvas.push_back(make_unique<Circle>(5.0));         // 添加圆形
    canvas.push_back(make_unique<Rectangle>(4.0, 6.0)); // 添加矩形
    canvas.push_back(make_unique<Triangle>(3.0, 8.0));  // 添加三角形
 
    renderAll(canvas);                      // 渲染所有图形
 
    return 0;
}

class Base {
public:
    Base() {
        speak();                            // ⚠️ 这里调用的永远是 Base::speak()
    }                                       // 即使实际创建的是 Derived 对象
    virtual void speak() {
        cout << "Base::speak()" << endl;
    }
};
 
class Derived : public Base {
public:
    Derived() {}                            // 先执行 Base()，此时 Derived 还未构造完成
    void speak() override {
        cout << "Derived::speak()" << endl;
    }
};
 
int main() {
    Derived d;                              // 输出 "Base::speak()"，不是 "Derived::speak()"
    return 0;
}

class Base {
public:
    virtual void func(int x) {              // 版本 A：接收 int
        cout << "Base::func(int)" << endl;
    }
    virtual void func(double x) {           // 版本 B：接收 double
        cout << "Base::func(double)" << endl;
    }
};
 
class Derived : public Base {
public:
    using Base::func;                       // ✅ 将 Base 的所有 func 重载引入 Derived 作用域
 
    void func(int x) override {             // 只重写 int 版本
        cout << "Derived::func(int)" << endl;
    }
    // func(double) 依然可见，来自 Base
};
 
int main() {
    Derived d;
    d.func(42);                             // 调用 Derived::func(int)
    d.func(3.14);                           // 调用 Base::func(double)  ← 没有 using 就会编译报错
    return 0;
}

#include <iostream>
using namespace std;
 
class A {
public:
    virtual void foo() { cout << "A::foo "; }
    void bar()         { cout << "A::bar "; }
};
 
class B : public A {
public:
    void foo() override { cout << "B::foo "; }
    void bar()          { cout << "B::bar "; }
};
 
int main() {
    B b;
    A* p = &b;
    p->foo();
    p->bar();
    return 0;
}

class Base {
public:
    virtual void func(int x) const { }
};
 
class Derived : public Base {
public:
    void func(int x) { }   // 注意：没有 const
};

class Shape {
public:
    // 纯虚函数：声明末尾 = 0，表示该函数没有默认实现
    // 任何继承 Shape 的派生类，必须重写(override)此函数，否则自身也变成抽象类
    virtual double area() const = 0;
 
    // 纯虚函数同样可以有多个
    virtual void draw() const = 0;
 
    // 普通虚函数（非纯虚），基类可以提供默认实现
    virtual std::string color() const {
        return "none";  // 默认颜色
    }
 
    // 虚析构函数（良好习惯，后续章节详述）
    virtual ~Shape() = default;
};

Shape s;           // ❌ 编译错误！不能实例化抽象类
Shape* p = new Shape();  // ❌ 同样错误！

Shape* p = nullptr;      // ✅ 合法，只是声明指针
Shape& r = someCircle;   // ✅ 合法，引用一个具体的派生类对象

#include <iostream>
#include <cmath>     // M_PI
#include <vector>
#include <memory>    // std::unique_ptr
 
// ============ 抽象基类：Shape ============
// Shape 定义了所有形状必须遵守的"契约"
class Shape {
public:
    // 纯虚函数：计算面积 —— 每种形状的面积公式不同，基类无法给出通用实现
    virtual double area() const = 0;
 
    // 纯虚函数：计算周长 —— 同理，必须由具体形状自己实现
    virtual double perimeter() const = 0;
 
    // 纯虚函数：打印形状信息
    virtual void print() const = 0;
 
    // 虚析构函数：确保通过基类指针 delete 时能正确析构派生类
    virtual ~Shape() = default;
};
 
// ============ 具体派生类：Circle ============
class Circle : public Shape {
private:
    double radius_;  // 圆的半径
 
public:
    // 构造函数：使用初始化列表设置半径
    explicit Circle(double r) : radius_(r) {}
 
    // 重写 area()：圆面积 = π * r²
    double area() const override {
        return M_PI * radius_ * radius_;
    }
 
    // 重写 perimeter()：圆周长 = 2 * π * r
    double perimeter() const override {
        return 2.0 * M_PI * radius_;
    }
 
    // 重写 print()：输出圆的信息
    void print() const override {
        std::cout << "Circle(r=" << radius_
                  << ", area=" << area()
                  << ", perimeter=" << perimeter() << ")" << std::endl;
    }
};
 
// ============ 具体派生类：Rectangle ============
class Rectangle : public Shape {
private:
    double width_;   // 矩形的宽
    double height_;  // 矩形的高
 
public:
    // 构造函数
    Rectangle(double w, double h) : width_(w), height_(h) {}
 
    // 重写 area()：矩形面积 = 宽 × 高
    double area() const override {
        return width_ * height_;
    }
 
    // 重写 perimeter()：矩形周长 = 2 * (宽 + 高)
    double perimeter() const override {
        return 2.0 * (width_ + height_);
    }
 
    // 重写 print()：输出矩形的信息
    void print() const override {
        std::cout << "Rectangle(w=" << width_ << ", h=" << height_
                  << ", area=" << area()
                  << ", perimeter=" << perimeter() << ")" << std::endl;
    }
};

int main() {
    // 使用智能指针管理对象生命周期，基类指针指向派生类对象
    std::vector<std::unique_ptr<Shape>> shapes;
 
    // emplace_back 直接在容器尾部构造元素（避免额外拷贝）
    shapes.emplace_back(std::make_unique<Circle>(5.0));        // 半径为 5 的圆
    shapes.emplace_back(std::make_unique<Rectangle>(3.0, 4.0)); // 3×4 矩形
    shapes.emplace_back(std::make_unique<Circle>(1.0));        // 半径为 1 的圆
 
    // 多态遍历：同一个循环处理所有不同类型的形状
    double totalArea = 0.0;  // 累计总面积
    for (const auto& shape : shapes) {
        shape->print();                // 动态绑定 → 调用各自的 print()
        totalArea += shape->area();    // 动态绑定 → 调用各自的 area()
    }
 
    std::cout << "Total area: " << totalArea << std::endl;
    // 输出:
    // Circle(r=5, area=78.5398, perimeter=31.4159)
    // Rectangle(w=3, h=4, area=12, perimeter=14)
    // Circle(r=1, area=3.14159, perimeter=6.28319)
    // Total area: 93.6814
 
    return 0;  // unique_ptr 自动释放所有对象
}

class Animal {
public:
    // 纯虚函数：声明为 = 0
    virtual void speak() const = 0;
 
    virtual ~Animal() = default;
};
 
// 在类外为纯虚函数提供函数体（注意：不能在类内直接写 = 0 和 {} 并存）
void Animal::speak() const {
    // 这是一个"默认的兜底实现"
    std::cout << "..." << std::endl;  // 动物默认发出沉默的声音
}
 
class Dog : public Animal {
public:
    // 派生类仍然必须重写（= 0 的强制性不变）
    void speak() const override {
        Animal::speak();  // 显式调用基类的纯虚函数实现（用作兜底逻辑）
        std::cout << "Woof!" << std::endl;  // 再追加自己的行为
    }
};

// 第一层：抽象基类
class Shape {
public:
    virtual double area() const = 0;      // 纯虚函数 ①
    virtual double perimeter() const = 0; // 纯虚函数 ②
    virtual ~Shape() = default;
};
 
// 第二层：只重写了 area()，没有重写 perimeter()
// → ClosedShape 仍然是抽象类！
class ClosedShape : public Shape {
public:
    // 重写了纯虚函数 ①
    // 但纯虚函数 ② 未被重写 → 继承为纯虚 → 本类仍然抽象
};
 
// 第三层：补全所有纯虚函数 → 具体类
class Square : public ClosedShape {
private:
    double side_;
 
public:
    explicit Square(double s) : side_(s) {}
 
    // 继承自 Shape 的 area() 已在 ClosedShape 中被重写?
    // 不！ClosedShape 并没有重写 area()（上面的注释写错了，我们修正）
    // 实际上 ClosedShape 也没重写 area()，所以两个都需要在 Square 中重写
 
    double area() const override {        // 重写纯虚函数 ①
        return side_ * side_;
    }
 
    double perimeter() const override {   // 重写纯虚函数 ②
        return 4.0 * side_;
    }
};

// ====== 纯接口类（Pure Interface）======
// 约定：无数据成员，无具体实现，全部纯虚函数
class ISerializable {
public:
    // 序列化：将对象转为字符串
    virtual std::string serialize() const = 0;
 
    // 反序列化：从字符串恢复对象状态
    virtual void deserialize(const std::string& data) = 0;
 
    // 虚析构（纯接口类也必须有）
    virtual ~ISerializable() = default;
};
 
// ====== 抽象类（Abstract Class）======
// 可以有数据成员，可以有部分函数的默认实现
class DatabaseEntity {
protected:
    int id_;                // 数据成员：实体 ID
    std::string tableName_; // 数据成员：对应的数据库表名
 
public:
    // 构造函数：设定表名
    explicit DatabaseEntity(const std::string& table)
        : id_(0), tableName_(table) {}
 
    // 纯虚函数：保存到数据库（具体 SQL 因子类而异）
    virtual bool save() = 0;
 
    // 普通虚函数：提供默认实现
    virtual std::string getTableName() const {
        return tableName_;  // 所有实体共享此逻辑
    }
 
    virtual ~DatabaseEntity() = default;
};

// Config 同时实现了两个"接口"
class Config : public ISerializable, public IPrintable {
public:
    // 必须重写 ISerializable 的所有纯虚函数
    std::string serialize() const override { /* ... */ }
    void deserialize(const std::string& data) override { /* ... */ }
 
    // 必须重写 IPrintable 的所有纯虚函数
    void print(std::ostream& os) const override { /* ... */ }
};

Shape s;                    // ❌ 编译错误
Shape* p = new Shape();     // ❌ 编译错误
std::vector<Shape> vec;     // ⚠️ 声明合法，但一旦尝试 push_back 就会报错

Shape* ptr = nullptr;            // ✅
Shape& ref = myCircle;           // ✅
std::vector<Shape*> vec;         // ✅ 存储指针
std::vector<std::unique_ptr<Shape>> vec2; // ✅ 更推荐智能指针

class Shape {
protected:
    std::string name_;  // 形状名称
 
    // protected 构造函数：不允许外部直接构造，但派生类可以调用
    explicit Shape(const std::string& name) : name_(name) {}
 
public:
    virtual double area() const = 0;
    virtual ~Shape() = default;
 
    // 非纯虚函数：所有形状共享此实现
    std::string getName() const { return name_; }
};
 
class Circle : public Shape {
    double radius_;
public:
    explicit Circle(double r)
        : Shape("Circle")  // 调用基类的 protected 构造函数
        , radius_(r) {}
 
    double area() const override {
        return M_PI * radius_ * radius_;
    }
};

class Shape {
public:
    virtual double area() const = 0;
    virtual ~Shape() = default;
 
    // 静态成员：跟踪创建了多少个 Shape 派生类对象
    static int instanceCount;
 
    // 静态函数：与具体对象无关，可以正常调用
    static void printCount() {
        std::cout << "Total shapes: " << instanceCount << std::endl;
    }
};
 
int Shape::instanceCount = 0;  // 静态成员类外初始化
 
// 调用方式：通过类名直接调用，无需实例化
Shape::printCount();  // ✅ 完全合法

#include <iostream>
#include <fstream>
#include <string>
 
// 抽象基类：定义"数据处理"的算法骨架
class DataProcessor {
public:
    // 模板方法（Template Method）：定义处理流程的骨架
    // 注意：这是一个 **非虚** 的普通函数，派生类不应重写它
    void process(const std::string& source) {
        std::string raw = readData(source);       // 步骤1：读取数据（纯虚）
        std::string parsed = parseData(raw);      // 步骤2：解析数据（纯虚）
        validate(parsed);                         // 步骤3：校验数据（有默认实现）
        saveResult(parsed);                       // 步骤4：保存结果（纯虚）
        std::cout << "Processing complete." << std::endl;
    }
 
    virtual ~DataProcessor() = default;
 
protected:
    // 纯虚函数：子类必须定义自己的读取方式
    virtual std::string readData(const std::string& source) = 0;
 
    // 纯虚函数：子类必须定义自己的解析方式
    virtual std::string parseData(const std::string& raw) = 0;
 
    // 虚函数（非纯虚）：提供默认的校验逻辑，子类可选择性重写
    virtual void validate(const std::string& data) {
        if (data.empty()) {
            throw std::runtime_error("Validation failed: empty data");
        }
        // 默认校验：只检查非空
    }
 
    // 纯虚函数：子类必须定义自己的保存方式
    virtual void saveResult(const std::string& data) = 0;
};
 
// 具体实现：处理 CSV 文件
class CsvProcessor : public DataProcessor {
protected:
    // 重写：从文件系统读取 CSV
    std::string readData(const std::string& source) override {
        std::cout << "Reading CSV from: " << source << std::endl;
        // 实际项目中会使用 std::ifstream 读文件
        return "name,age\nAlice,30\nBob,25";  // 模拟数据
    }
 
    // 重写：按 CSV 格式解析
    std::string parseData(const std::string& raw) override {
        std::cout << "Parsing CSV data..." << std::endl;
        return raw;  // 简化处理
    }
 
    // 重写：保存到数据库
    void saveResult(const std::string& data) override {
        std::cout << "Saving CSV results to database." << std::endl;
    }
};
 
// 具体实现：处理 JSON API
class JsonApiProcessor : public DataProcessor {
protected:
    std::string readData(const std::string& source) override {
        std::cout << "Fetching JSON from API: " << source << std::endl;
        return R"({"users": [{"name": "Alice"}]})";  // 模拟数据
    }
 
    std::string parseData(const std::string& raw) override {
        std::cout << "Parsing JSON data..." << std::endl;
        return raw;
    }
 
    // 重写 validate()：JSON 有更严格的校验需求
    void validate(const std::string& data) override {
        DataProcessor::validate(data);  // 先调用基类的默认校验
        if (data.front() != '{') {      // 追加 JSON 特有的校验
            throw std::runtime_error("Invalid JSON format");
        }
    }
 
    void saveResult(const std::string& data) override {
        std::cout << "Saving JSON results to cache." << std::endl;
    }
};

int main() {
    // 基类指针，指向不同的具体处理器
    std::unique_ptr<DataProcessor> processor;
 
    // 处理 CSV
    processor = std::make_unique<CsvProcessor>();
    processor->process("data/users.csv");   // 调用统一的 process() 骨架
    // 输出:
    // Reading CSV from: data/users.csv
    // Parsing CSV data...
    // Saving CSV results to database.
    // Processing complete.
 
    std::cout << "---" << std::endl;
 
    // 处理 JSON API
    processor = std::make_unique<JsonApiProcessor>();
    processor->process("https://api.example.com/users");
    // 输出:
    // Fetching JSON from API: https://api.example.com/users
    // Parsing JSON data...
    // Saving JSON results to cache.
    // Processing complete.
 
    return 0;
}

class Triangle : public Shape {
public:
    double area() const override { return 0.5 * base_ * height_; }
    // ❌ 忘记重写 perimeter() → Triangle 仍然是抽象类
    // 尝试 Triangle t(3,4); 将编译失败
private:
    double base_, height_;
};

class Base {
public:
    Base() {
        doInit();  // ⚠️ 极其危险！
    }
    virtual void doInit() = 0;
    virtual ~Base() = default;
};

// 内存布局示意（构造过程中）

virtual void func() = 0;       // 纯虚函数：派生类必须重写
virtual void func() = delete;  // ❌ 语法错误！虚函数不能 = delete
void func() = delete;          // 删除函数：彻底禁用，任何人不能调用

#include <iostream>
 
class A {
public:
    virtual void foo() = 0;
    virtual void bar() = 0;
    virtual ~A() = default;
};
 
class B : public A {
public:
    void foo() override { std::cout << "B::foo" << std::endl; }
};
 
class C : public B {
public:
    void bar() override { std::cout << "C::bar" << std::endl; }
};
 
int main() {
    A* p = new C();
    p->foo();
    p->bar();
    delete p;
    return 0;
}

#include <iostream>
#include <cstring>
 
// ========== 基类：不带 virtual 析构 ==========
class Base {
public:
    Base() {
        std::cout << "Base::Base()" << std::endl;       // 基类构造
    }
    ~Base() {  // ⚠️ 注意：这里没有 virtual！
        std::cout << "Base::~Base()" << std::endl;      // 基类析构
    }
};
 
// ========== 派生类：持有堆内存资源 ==========
class Derived : public Base {
private:
    char* data_;                                         // 派生类拥有的堆资源
 
public:
    Derived(const char* str) : Base() {                  // 先构造基类
        data_ = new char[strlen(str) + 1];               // 在堆上分配内存
        strcpy(data_, str);                              // 拷贝字符串内容
        std::cout << "Derived::Derived() -> allocated: "
                  << data_ << std::endl;                 // 派生类构造完成
    }
 
    ~Derived() {                                         // 派生类析构
        std::cout << "Derived::~Derived() -> freeing: "
                  << data_ << std::endl;
        delete[] data_;                                  // 释放堆内存 ⬅️ 关键！
        data_ = nullptr;                                 // 安全置空
    }
};
 
int main() {
    Base* ptr = new Derived("Hello C++");                // 基类指针 → 派生类对象
    // ... 使用 ptr ...
    delete ptr;                                          // ⚠️ 通过基类指针 delete
    return 0;
}

#include <iostream>
#include <cstring>
 
// ========== 基类：带 virtual 析构 ==========
class Base {
public:
    Base() {
        std::cout << "Base::Base()" << std::endl;       // 基类构造
    }
    virtual ~Base() {  // ✅ 加上 virtual！
        std::cout << "Base::~Base()" << std::endl;      // 基类析构
    }
};
 
// ========== 派生类：持有堆内存资源 ==========
class Derived : public Base {
private:
    char* data_;                                         // 堆资源
 
public:
    Derived(const char* str) : Base() {                  // 先构造基类
        data_ = new char[strlen(str) + 1];               // 分配堆内存
        strcpy(data_, str);                              // 拷贝内容
        std::cout << "Derived::Derived() -> allocated: "
                  << data_ << std::endl;
    }
 
    ~Derived() override {                                // override 标记（C++11 推荐）
        std::cout << "Derived::~Derived() -> freeing: "
                  << data_ << std::endl;
        delete[] data_;                                  // ✅ 正确释放资源
        data_ = nullptr;                                 // 安全置空
    }
};
 
int main() {
    Base* ptr = new Derived("Hello C++");                // 基类指针 → 派生类对象
    delete ptr;                                          // ✅ 动态绑定，先调 Derived 析构，再调 Base 析构
    return 0;
}

// ====== Derived 对象在内存中的布局 ======
//
// Derived 对象 (ptr 指向这里)
// ┌──────────────────────────────┐
// │  vptr ─────────────────┐     │  ← 虚表指针，位于对象起始位置
// ├──────────────────────────────┤
// │  Base 的成员数据              │  ← 基类子对象部分
// ├──────────────────────────────┤
// │  data_ (char*)               │  ← 派生类自有成员
// └──────────────────────────────┘
//                          │
//                          ▼
//            Derived 的 vtable
//            ┌───────────────────────────────────┐
//            │ [0] &Derived::~Derived()           │  ← 析构函数槽位 (已覆写)
//            │ [1] 其他虚函数地址...               │
//            └───────────────────────────────────┘
//
// ====== 执行 delete ptr 的调用链 ======
//
//  ptr->vptr  →  vtable[0]  →  Derived::~Derived()
//                                    │
//                                    ▼  (编译器自动链式调用)
//                               Base::~Base()

// ====== 没有 virtual 的轻量类 ======
class Point {
    int x_;  // 4 字节
    int y_;  // 4 字节
};
// sizeof(Point) == 8 字节
 
// ====== 加了 virtual 析构后 ======
class PointV {
    int x_;  // 4 字节
    int y_;  // 4 字节
public:
    virtual ~PointV() = default;
    // 隐含 vptr: 8 字节 (64 位系统)
};
// sizeof(PointV) == 16 字节 (含对齐填充)
// 对象大小翻倍！

class Base {
protected:
    ~Base() = default;  // protected + 非虚
    // 外部代码无法 delete Base*，编译期报错
    // 派生类可以正常析构（因为 protected 对子类可见）
 
public:
    virtual void doWork() = 0;  // 仍可有其他虚函数
};
 
class Derived : public Base {
public:
    ~Derived() = default;       // 合法，可以访问 Base 的 protected 析构
    void doWork() override {
        // 实现...
    }
};
 
int main() {
    // Base* p = new Derived();
    // delete p;                // ❌ 编译错误！Base 的析构函数是 protected
    
    Derived d;                  // ✅ 合法，Derived 的析构是 public
    // 栈对象 d 离开作用域时，Derived::~Derived() 被调用，
    // 然后自动调用 Base::~Base()（在 Derived 内部是可访问的）
    return 0;
}

class A {
public:
    virtual ~A() {                       // ✅ 声明为 virtual
        std::cout << "~A" << std::endl;
    }
};
 
class B : public A {
public:
    ~B() {                               // 自动是 virtual（继承自 A）
        std::cout << "~B" << std::endl;  // 即使没写 virtual 关键字
    }
};
 
class C : public B {
public:
    ~C() override {                      // 自动是 virtual（传播自 A → B → C）
        std::cout << "~C" << std::endl;  // 推荐用 override 明确意图
    }
};
 
int main() {
    A* ptr = new C();   // A* 指向最底层派生类 C
    delete ptr;          // 通过 vtable 动态绑定
    // 输出：~C  ~B  ~A  (逆序析构，完美)
    return 0;
}

// ====== 多层析构链 ======
//
//  delete ptr;   (ptr 类型: A*, 实际指向 C 对象)
//       │
//       ▼  vtable 查找
//  C::~C()       ← 动态绑定找到 C 的析构
//       │
//       ▼  编译器自动插入
//  B::~B()       ← 自动调用直接基类的析构
//       │
//       ▼  编译器自动插入
//  A::~A()       ← 自动调用更上层基类的析构
//       │
//       ▼
//  operator delete(ptr)  ← 释放原始内存

#include <iostream>
#include <memory>
#include <string>
 
// ========== 抽象产品基类 ==========
class Logger {
public:
    virtual void log(const std::string& msg) = 0;  // 纯虚函数：日志接口
    virtual ~Logger() = default;                    // ✅ 虚析构（必须！）
};
 
// ========== 具体产品：控制台日志 ==========
class ConsoleLogger : public Logger {
public:
    void log(const std::string& msg) override {     // 实现日志接口
        std::cout << "[Console] " << msg << std::endl;
    }
    ~ConsoleLogger() override {                     // 虚析构 (自动继承)
        std::cout << "ConsoleLogger destroyed" << std::endl;
    }
};
 
// ========== 具体产品：文件日志 ==========
class FileLogger : public Logger {
private:
    std::string filename_;                          // 模拟的文件名
public:
    FileLogger(const std::string& fname)            // 构造时绑定文件
        : filename_(fname) {
        std::cout << "FileLogger opened: " << filename_ << std::endl;
    }
    void log(const std::string& msg) override {     // 实现日志接口
        std::cout << "[File:" << filename_ << "] " << msg << std::endl;
    }
    ~FileLogger() override {                        // 析构时关闭文件
        std::cout << "FileLogger closed: " << filename_ << std::endl;
    }
};
 
// ========== 工厂函数 ==========
std::unique_ptr<Logger> createLogger(const std::string& type) {
    if (type == "console") {
        return std::make_unique<ConsoleLogger>();    // 返回基类智能指针
    } else if (type == "file") {
        return std::make_unique<FileLogger>("app.log");
    }
    return nullptr;                                  // 未知类型
}
 
int main() {
    // 工厂创建，使用者只知道 Logger 接口
    auto logger = createLogger("file");              // unique_ptr<Logger>
    logger->log("Application started");              // 多态调用
 
    // unique_ptr 析构时，通过 Logger 的虚析构 → FileLogger::~FileLogger()
    // 资源（文件）被正确释放 ✅
    return 0;
}

class Animal {
public:
    virtual void speak() = 0;
    ~Animal() { std::cout << "~Animal\n"; }
};
 
class Dog : public Animal {
    int* bones_;
public:
    Dog() : bones_(new int[100]) {}
    void speak() override { std::cout << "Woof!\n"; }
    ~Dog() { delete[] bones_; std::cout << "~Dog\n"; }
};
 
int main() {
    Animal* ptr = new Dog();
    ptr->speak();
    delete ptr;
}

class Animal {
public:
    virtual void speak() { std::cout << "..." << std::endl; }   // 虚函数
    virtual void eat()   { std::cout << "eating" << std::endl; } // 虚函数
};
 
class Dog : public Animal {
public:
    void speak() override { std::cout << "Woof!" << std::endl; } // 重写 speak
    // eat() 未重写，继承 Animal::eat()
};
 
class Cat : public Animal {
public:
    void speak() override { std::cout << "Meow!" << std::endl; } // 重写 speak
    void eat()   override { std::cout << "cat eating" << std::endl; } // 重写 eat
};
 
void makeItSpeak(Animal* p) {
    p->speak(); // 编译期不知道 p 指向 Dog 还是 Cat，如何正确调用？
}

// Dog 对象的内存布局（假设 64 位系统）
//
// 地址低位 ──────────────────────────────── 地址高位
// ┌────────────┬────────────────────────────┐
// │   vptr     │   其他成员变量...            │
// │  (8 bytes) │                             │
// └─────┬──────┴────────────────────────────┘
//       │
//       │  vptr 指向 Dog 的 vtable
//       ▼
// ┌──────────────────────────────────────────┐
// │          Dog's vtable (只读数据段)         │
// ├──────────────────────────────────────────┤
// │  [0]  ──→  Dog::speak()   的函数地址      │
// │  [1]  ──→  Animal::eat()  的函数地址      │
// └──────────────────────────────────────────┘

#include <iostream>
 
class Empty {};                       // 空类
 
class WithVirtual {                   // 含虚函数的类
public:
    virtual void foo() {}             // 虚函数
};
 
class WithVirtualAndData {            // 含虚函数 + 数据成员
public:
    virtual void foo() {}             // 虚函数
    int x;                            // 4 字节数据成员
};
 
int main() {
    // 空类大小为 1（C++ 保证每个对象有唯一地址）
    std::cout << "Empty:              " << sizeof(Empty) << std::endl;              // 1
 
    // 含虚函数的类：多了一个 vptr（64 位系统上为 8 字节）
    std::cout << "WithVirtual:        " << sizeof(WithVirtual) << std::endl;        // 8
 
    // vptr(8) + int(4) + padding(4) = 16（内存对齐）
    std::cout << "WithVirtualAndData: " << sizeof(WithVirtualAndData) << std::endl; // 16
 
    return 0;
}

// p->speak() 的底层等价操作（伪代码）
 
// 第 1 步：从对象起始地址读取 vptr
void** vtable = *(void***)p;           // p 的前 8 字节就是 vptr
 
// 第 2 步：从 vtable 中取出 speak 对应的 slot（假设 speak 是第 0 个虚函数）
void (*fn)(Animal*) = (void(*)(Animal*))vtable[0];
 
// 第 3 步：通过函数指针调用实际函数，并把 p 作为 this 传入
fn(p);                                 // 相当于调用 Dog::speak(this=p)

#include <iostream>
 
class Base {
public:
    Base() {
        // 此时 vptr 指向 Base 的 vtable
        // 调用虚函数会执行 Base 的版本
        who();   // 调用 Base::who()，而非 Derived::who()
    }
    virtual void who() {
        std::cout << "I am Base" << std::endl;       // 基类版本
    }
    virtual ~Base() = default;                        // 虚析构
};
 
class Derived : public Base {
public:
    Derived() {
        // 此时 vptr 已被更新为指向 Derived 的 vtable
        who();   // 调用 Derived::who()
    }
    void who() override {
        std::cout << "I am Derived" << std::endl;    // 派生类版本
    }
};
 
int main() {
    Derived d;
    // 输出：
    // I am Base        ← Base 构造函数中调用
    // I am Derived     ← Derived 构造函数中调用
    return 0;
}