【C++ 多态】—— 礼器九鼎，釉下乾坤，多态中的 “风水寻龙诀“

void print(int x)
{
    std::cout << "int: " << x << std::endl;
}
void print(double x)
{
    std::cout << "double: " << x << std::endl;
}
void print(const char *s)
{
    std::cout << "const char *: " << s << std::endl;
}

int main()
{
    print(10);      // 调用 print(int)
    print(3.14);    // 调用 print(double)
    print("Hello"); // 调用 print(const char*)
}

int: 10
double: 3.14
const char *: Hello

class Complex
{
private:
    double real;
    double imag;
public:
    Complex(double r = 0, double i = 0) : real(r), imag(i) {}
    // 重载 + 运算符
    Complex operator+(const Complex &other)
    {
        return Complex(real + other.real, imag + other.imag);
    }
    void print()
    {
        std::cout << real << " + " << imag << "i" << std::endl;
    }
};

int main()
{
    // 运算符重载调用
    Complex c1(1, 2);
    Complex c2(3, 4);
    Complex c3 = c1 + c2;
    std::cout << "Complex addition: ";
    c3.print();
}

Complex addition: 4 + 6i

template <typename T>
T Max(T a, T b)
{
    return (a > b) ? a : b;
}

int main()
{
    std::cout << Max(3, 5) << std::endl;      // 生成 int 版本
    std::cout << Max(2.7, 3.14) << std::endl; // 生成 double 版本
    return 0;
}

5
3.14

template <typename T>
class Stack
{
public:
    void push(const T &item) { _elements.push_back(item); }
    T pop() {}
private:
    std::vector<T> _elements;
};

int main()
{
    Stack<int> int_Stack;    // 存储整数的栈
    Stack<string> str_Stack; // 存储字符串的栈
    return 0;
}

int add(int a, int b);          // 函数A
double add(double a, double b); // 函数B
int main()
{
    add(3, 5);     // 编译时直接绑定到函数A
    add(3.0, 5.0); // 编译时直接绑定到函数B
    return 0;
}

template <typename T>
T Max(T a, T b) { return (a > b) ? a : b; }

int main()
{
    Max(3, 5.0); // 编译出错：T 同时推导为 int 和 double，类型不一致
    return 0;
}

std::vector<int> v;
v.push_back("Hello,World"); // 编译错误：参数类型不匹配

// 模板函数
template <typename T>
T square(T x) { return x * x; }

int main()
{
    square(5);    // 生成 int square(int x) { return x*x; }
    square(3.14); // 生成 double square(double x) { return x*x; }
    return 0;
}

template <typename T>
class Wrapper
{
    T data; /*...*/
};

int main()
{
    Wrapper<int> w1;    // 生成 int 特化版本
    Wrapper<double> w2; // 生成 double 特化版本
    return 0;
}

class Animal
{
public:
    virtual void speak()
    { // 使用 virtual 关键字
        std::cout << "Animal sound\n";
    }
};

class Dog : public Animal
{
public:
    void speak() override
    { // 使用 override 明确重写（C++11）
        std::cout << "Woof!\n";
    }
};

int main()
{
    Animal *animal = new Dog();
    animal->speak(); // 输出 "Woof!"（调用 Dog 的实现）
    delete animal;
    return 0;
}

Woof!

class Base {
public:
    virtual void func(int) {}
};
class Derived : public Base {
public:
    void func(double) {} // 参数类型不一致，未覆盖基类 func(int)
};

class Derived : public Base {
public:
    void func(int) override {} // 使用 override 强制编译器检查覆盖
};

class Base {
public:
    void func() {} // 非虚函数
};
class Derived : public Base {
public:
    void func() {} // 隐藏基类函数，无法多态调用
};

class Car
{
public:
    virtual void Drive() final {}
};
class Benz : public Car
{
public:
    virtual void Drive()
    {
        std::cout << "Benz" << std::endl;// 编译出错,无法重写final修饰的虚函数
    } 
};

class A
{
public:
    virtual void func(int val = 1) { std::cout << "A->" << val << std::endl; }
    virtual void test() { func(); }
};
class B : public A
{
public:
    void func(int val = 0) { std::cout << "B->" << val << std::endl; }
};
int main(int argc, char *argv[])
{
    B *p = new B;
    p->test();
    return 0;
}

virtual 返回类型 函数名(参数) = 0;  // 纯虚函数

// 抽象基类（包含纯虚函数）
class Animal
{
public:
    virtual void sound() const = 0; // 纯虚函数
    virtual ~Animal() {}            // 虚析构函数（重要！）
};

// 派生类必须实现 sound()
class Dog : public Animal
{
public:
    void sound() const override
    { // 重写纯虚函数
        std::cout << "Woof!" << std::endl;
    }
};

class Cat : public Animal
{
public:
    void sound() const override
    { // 重写纯虚函数
        std::cout << "Meow!" << std::endl;
    }
};

class Animal
{
public:
    virtual void sound() const = 0;
};
// 纯虚函数的默认实现（罕见用法）必须实在类外实现的！
void Animal::sound() const
{
    std::cout << "Default animal sound" << std::endl;
}
class Dog : public Animal
{
public:
    void sound() const override
    {
        Animal::sound(); // 调用基类的默认实现
        std::cout << "Woof!" << std::endl;
    }
};

class Base
{ // 基类（无虚析构函数）
public:
    ~Base()
    {
        std::cout << "Base destructor\n";
    }
};

class Derived : public Base
{ // 派生类（持有动态资源）
public:
    int *data;
    Derived()
    {
        data = new int[100]; // 动态分配内存
    }
    ~Derived()
    {
        delete[] data; // 释放内存
        std::cout << "Derived destructor\n";
    }
};

int main()
{
    Base *obj = new Derived(); // 基类指针指向派生类对象
    delete obj;                // 仅调用了Base基类的析构函数
    return 0;
}

Base destructor

class Base
{
public:
    virtual ~Base()
    { // 声明为虚析构函数
        std::cout << "Base destroyed\n";
    }
};

class Derived : public Base
{
public:
    ~Derived() override
    { // 重写虚析构函数
        std::cout << "Derived destroyed\n";
    }
};

int main()
{
    Base *obj = new Derived();
    delete obj; // 正确调用Derived和Base的析构函数
    return 0;
}

Derived destroyed
Base destroyed

// 基类
class Fruit {
public:
    virtual Fruit* clone() const {   // 虚函数，返回Fruit*(基类指针)
        return new Fruit(*this);
    }
    virtual ~Fruit() {}
};

// 派生类
class Apple : public Fruit {
public:
    Apple* clone() const override {  // 协变：返回Apple*(派生类指针)
        return new Apple(*this);
    }
    
    void sayName() const {
        std::cout << "I am an Apple!" << std::endl;
    }
};

int main() {
    Fruit* fruit = new Apple();      // 基类指针指向派生类对象
    Fruit* cloned = fruit->clone();  // 调用派生类的clone()

    // 验证协变特性
    if (Apple* apple = dynamic_cast<Apple*>(cloned)) {
        apple->sayName();  // 成功调用Apple特有方法
    } else {
        std::cout << "Cloning failed!" << std::endl;
    }

    delete fruit;
    delete cloned;
    return 0;
}

I am an Apple!

class Calculator {
public:
    // 重载示例
    int add(int a, int b) { return a + b; }
    double add(double a, double b) { return a + b; }  // 参数类型不同
    int add(int a, int b, int c) { return a + b + c; } // 参数数量不同
};

class Base {
public:
    void func() { std::cout << "Base::func()\n"; }
    void func(int) { std::cout << "Base::func(int)\n"; }  // 重载版本
};

class Derived : public Base {
public:
    // 隐藏基类的所有 func 函数（包括重载）
    void func() { std::cout << "Derived::func()\n"; }
};

int main() {
    Derived d;
    d.func();     // 正确：调用 Derived::func()
    // d.func(1); // 错误！Base::func(int) 被隐藏
    d.Base::func(1); // 正确：显式调用基类函数
    return 0;
}

class Base
{
public:
    virtual void Func1()
    {
        std::cout << "Func1()" << std::endl;
    }

protected:
    int _b = 1;
    char _ch = 'x';
};
int main()
{
    Base b;
    std::cout << sizeof(b) << std::endl;
    return 0;
}

class Base {
public:
    virtual void func1() {}
    virtual void func2() {}
    int data;
};

+----------------+
| vptr           | --> 指向Base的虚函数表
| int data       |  
+----------------+

Base的vtable：
+----------------+
| &Base::func1   |  
| &Base::func2   |  
+----------------+

class Derived : public Base {
public:
    void func1() override {}  // 重写基类的func1
    virtual void func3() {}   // 新增虚函数
};

+----------------+
| &Derived::func1|  // 重写基类func1
| &Base::func2    |  // 未重写，保留基类func2
| &Derived::func3|  // 新增虚函数
+----------------+

class Base1 { virtual void f1(); };
class Base2 { virtual void f2(); };
class Derived : public Base1, public Base2 {
    void f1() override {}
    void f2() override {}
};

+----------------+
| Base1的vptr     | --> [&Derived::f1]
| Base1成员变量   |
| Base2的vptr     | --> [&Derived::f2]
| Base2成员变量   |
| Derived成员变量 |
+----------------+

class Base {
public:
    void nonVirtualFunc() { std::cout << "Base\n"; }
};

class Derived : public Base {
public:
    void nonVirtualFunc() { std::cout << "Derived\n"; }
};

int main() {
    Base* obj = new Derived();
    obj->nonVirtualFunc();  // 输出 "Base"（静态绑定）
    delete obj;
    return 0;
}

void func() { /* ... */ }
func();  // 静态绑定

template <typename T>
void templateFunc(T t) { /* ... */ }

templateFunc(42);  // 编译时生成针对int的版本

class Base {
public:
    virtual void virtualFunc() { std::cout << "Base\n"; }
};

class Derived : public Base {
public:
    void virtualFunc() override { std::cout << "Derived\n"; }
};

int main() {
    Base* obj = new Derived();
    obj->virtualFunc();  // 输出 "Derived"（动态绑定）
    delete obj;
    return 0;
}

class Base {
public:
    virtual ~Base() {}  // 虚析构函数
};

class Derived : public Base {
public:
    ~Derived() override { /* 释放派生类资源 */ }
};

Base* obj = new Derived();
delete obj;  // 动态调用~Derived()

class A
{
public:
    virtual void func(int val = 1) { std::cout << "A->" << val << std::endl; }
    virtual void test() { func(); }
};
class B : public A
{
public:
    void func(int val = 0) { std::cout << "B->" << val << std::endl; }
};
int main(int argc, char *argv[])
{
    B *p = new B;
    p->test();
    return 0;
}

p->test() → A::test() → func()（动态绑定到B::func()，但默认参数来自A的声明）

class Base
{
public:
    virtual void func1() { cout << "Base::func1" << endl; }
    virtual void func2() { cout << "Base::func2" << endl; }
    void func5() { cout << "Base::func5" << endl; }

protected:
    int a = 1;
};
class Derive : public Base
{
public:
    // 重写基类的func1
    virtual void func1() { cout << "Derive::func1" << endl; }
    virtual void func3() { cout << "Derive::func1" << endl; }
    void func4() { cout << "Derive::func4" << endl; }

protected:
    int b = 2;
};
int main()
{
    int i = 0;
    static int j = 1;
    int *p1 = new int;
    const char *p2 = "xxxxxxxx";
    printf("栈:%p\n", &i);
    printf("静态区:%p\n", &j);
    printf("堆:%p\n", p1);
    printf("常量区:%p\n", p2);
    Base b;
    Derive d;
    Base *p3 = &b;
    Derive *p4 = &d;
    printf("Person虚表地址:%p\n", *(int *)p3);
    printf("Student虚表地址:%p\n", *(int *)p4);
    printf("虚函数地址:%p\n", &Base::func1);
    printf("普通函数地址:%p\n", &Base::func5);
    return 0;
}

栈:010FF954
静态区:0071D000
堆:0126D740
常量区:0071ABA4
Person虚表地址:0071AB44
Student虚表地址:0071AB84
虚函数地址:00711488
普通函数地址:007114BF

+----------------------------------------------------------------+
|                      多态实现流程总结                          |
+----------------------------------------------------------------+
|                                                                |
| 1. 定义基类虚函数                                              |
|    - 基类中声明虚函数: virtual void func();                    |
|                                                                |
| 2. 派生类重写虚函数                                            |
|    - 派生类中 override: void func() override;                  |
|                                                                |
| 3. 编译器生成虚函数表（vtable）                                |
|    +---------------------------+                               |
|    | 基类 vtable               |                               |
|    | - &Base::func             |                               |
|    +---------------------------+                               |
|    | 派生类 vtable             |                               |
|    | - &Derived::func          | (重写后替换基类地址)          |
|    +---------------------------+                               |
|                                                                |
| 4. 对象内存布局                                                |
|    +---------------------------+                               |
|    | vptr                      | --> 指向 vtable               |
|    | 基类成员变量              |                               |
|    | 派生类成员变量            |                               |
|    +---------------------------+                               |
|    (vptr 在对象内存首部，占 4/8 字节)                         |
|                                                                |
| 5. 动态绑定过程（运行时）                                      |
|    +----------------------------------------------------------+|
|    | 通过基类指针调用虚函数: obj->func();                      ||
|    |                                                          ||
|    | a. 访问 obj 的 vptr                                      ||
|    | b. 通过 vptr 找到 vtable                                 ||
|    | c. 查表调用实际函数地址 &Derived::func                   ||
|    +----------------------------------------------------------+|
|                                                                |
| 6. 虚析构函数保障                                              |
|    - 基类声明虚析构函数: virtual ~Base()                       |
|    - 派生类析构函数自动重写                                    |
|    - delete 基类指针时，触发完整析构链                         |
|                                                                |
+----------------------------------------------------------------+