【C++】多态到底难在哪？虚函数表 + 动态绑定，一篇吃透底层逻辑！

//多态
#include<iostream>

using namespace std;


class Person //基类
{
public:
	virtual void BuyTicket()
	{
		cout << "买票全价" << endl;
	}
};

class Student :public Person
{
public:
	virtual void BuyTicket()
	{
		cout << "买票半价" << endl;
	}
};

void Func(Person& ps)
{
	ps.BuyTicket();
}

void test()
{
	Person dh;
	Func(dh);

	Student Daitou;
	Func(Daitou);
}

int main()
{
	
	test();

	return 0;
}

// --- 1. 产品层次结构 ---
class ProductBase {
public:
    virtual void info() { cout << "  -> 通用产品" << endl; }
};

class SpecificProduct : public ProductBase {
public:
    // 可选：重写以展示差异
    void info() { cout << "  -> 特定产品" << endl; } 
};

// --- 2. 工厂层次结构（协变发生在这里）---
class FactoryBase {
public:
    // 【基类承诺】 返回 ProductBase*
    virtual ProductBase* createProduct() const 
    {
        cout << "工厂基类生产:";
        return new ProductBase();
    }
    // 必须有虚析构函数，保证安全，但为了简化，可以省略（实际项目不能省！）
    virtual ~FactoryBase() {}
};

class SpecificFactory : public FactoryBase {
public:
    // 【协变】
    // 派生类重写，返回 ProductBase 的派生类型 SpecificProduct*
    SpecificProduct* createProduct() const  
    {
        cout << "特定工厂生产:";
        return new SpecificProduct();
    }
};

void testCovariance() {
    // 使用基类指针指向派生类工厂
    FactoryBase* factory = new SpecificFactory();

    // 多态调用：
    // 尽管 factory 是基类指针，但它调用了 SpecificFactory 的 createProduct()
    ProductBase* product = factory->createProduct();

    // 验证实际类型
    product->info();

    // 释放内存
    delete product;
    delete factory;
}

int main() {
    testCovariance();
    return 0;
}

// error C3668: “Benz::Drive”: 包含重写说明符“override”的⽅法没有重写任何基类⽅法
//函数名的不同
class Car {
public:
	virtual void Dirve() //D i r v e
	{
	}
};
class Benz :public Car { 
public:
	virtual void Drive() override { cout << "Benz-舒适" << endl; }
	             //D r i v e
};
int main()
{
	return 0;
}

//error C3248: “Car::Drive”: 声明为“final”的函数⽆法被“Benz::Drive”重写
class Car
{
public :
	virtual void Drive() final {}
};
class Benz :public Car
{
public :
	virtual void Drive() { cout << "Benz-舒适" << endl; }
};
int main()
{
	return 0;
}

    // 1. 重载版本 A (无参数)
    void eat() const 
    {
        cout << "Animal: 默认进食方式。" << endl;
    }

    // 2. 重载版本 B (带参数：食物)
    void eat(const string& food) const 
    {
        cout << "Animal: 正在吃 " << food << endl;
    }

    // 3. 重载版本 C (带参数：数量)
    void eat(int amount) const 
    {
        cout << "Animal: 吃了 " << amount << " 份食物。" << endl;
    }
};

int main() 
{
    Animal a;
    a.eat();             // 调用版本 A
    a.eat("肉");         // 调用版本 B
    a.eat(3);            // 调用版本 C
return 0;
}

class Animal {
public:
// 1. 基类虚函数 (必须是虚函数)
        virtual void move() const 
        {
            cout << "Animal: 四肢移动。" << endl;
        }
};

class Bird : public Animal {
public:
// 2. 派生类重写 (签名必须一致)
        void move() const override 
        { // 使用 override 确保是重写
            cout << "Bird: 飞行移动。" << endl;
        }
};

int main() 
{
    Animal* pAnimal = new Bird(); // 基类指针指向派生类对象

    // 多态：通过基类指针调用虚函数
    pAnimal->move(); // 运行时调用 Bird::move()

    delete pAnimal;
    return 0;
}

class Animal {
public:
    // 1. 被隐藏的基类函数 A (无参数)
    void sleep() const 
    {
        cout << "Animal: 睡 8 小时。" << endl;
    }

    // 2. 被隐藏的基类函数 B (带参数)
    void sleep(int hours) const 
    {
        cout << "Animal: 睡 " << hours << " 小时。" << endl;
    }
};

class Dog : public Animal {
public:
    // 3. 隐藏者：函数名相同，但参数列表不同！
    void sleep(const string& position) const 
    {
        cout << "Dog: 趴着睡。" << endl;
    }
};

int main() 
{
    Dog d;

    // d.sleep();        // 编译错误！基类的无参版本被隐藏了。
    // d.sleep(5);       // 编译错误！基类的带参版本也被隐藏了。

    // 只能调用自己的版本：
    d.sleep("窝里");  // 输出: Dog: 趴着睡。

    // 必须使用作用域解析符来调用被隐藏的基类函数：
    d.Animal::sleep(); // 输出: Animal: 睡 8 小时。
}

// --- 抽象类（只定义接口）---
class BaseInterface {
public:
    // 纯虚函数：强制派生类必须实现此功能
    virtual void mustImplement() const = 0;

    // 必须要有虚析构函数
    virtual ~BaseInterface() {}
};

// --- 派生类（提供实现）---
class ConcreteDerived : public BaseInterface {
public:
    // 实现了纯虚函数，因此可以被实例化
    void mustImplement() const override 
    {
        cout << "实现完成！" << endl;
    }
};



int main() 
{
   // BaseInterface bi; // 编译错误：抽象类不能实例化

   // 必须通过指针或引用使用，实现多态
    BaseInterface* obj = new ConcreteDerived();

    obj->mustImplement();

    delete obj;
    return 0;
}

class A
{
public:
	virtual void func() { cout << "func()" << endl; }

	virtual void func1() { cout << "func1()" << endl; }

	void func2() { cout << "func2()" << endl; }
private:
	int _a;
};


class B : public A
{
public:
	virtual void func() { cout << "Bfunc()" << endl; }
private:
	int _b;
};

int main()
{
	A a;
	B b;
	return 0;
}

class Daitou
{
public:
	virtual void func() { cout << "wobushidaitou!"; }

};

int main()
{
	int a = 0;
	cout << "a是普通变量，存储在栈上" << endl;
	cout << "栈的地址为：" << &a << endl;
	int* ptr = new int;
	cout << "ptr是动态开辟的指针，存储在堆上" << endl;
	cout << "堆的地址为：" << ptr << endl;
	static int b = 0;
	cout << "b是静态变量，存储在数据段（静态区）" << endl;
	cout << "数据段的地址为：" << &b << endl;
	const char* str = "daitou";
	cout << "str是常量字符串，常量区" << endl;
	cout << "代码段的地址为：" << (void*)str << endl;
	Daitou d;
	cout << "a是普通变量，存储在栈上" << endl;
	cout << "虚表的地址为：" << (void*)*((int*)&d) << endl;

	return 0;
}

class Person
{
public:
	virtual void BuyTicket()
	{
		cout << "买票全价" << endl;
	}
};

class Student :public Person
{
public:
	virtual void BuyTicket()
	{
		cout << "买票半价" << endl;
	}
};

void func(Person& ps)
{
	ps.BuyTicket();
}

int main()
{
	Person ps;
	Student st;

	func(ps);
	func(st);

	return 0;
}

#include <iostream>
using namespace std;

class Base {
public:
    virtual void show() {
        cout << "Base::show()" << endl;
    }
    int base_data = 10;
};

class Derived : public Base {
public:
    virtual void show() override {
        cout << "Derived::show()" << endl;
    }
    int derived_data = 20;
};

int main() {
    Derived derived_obj;
    
    // 情况1：基类指针指向派生类对象 - 多态正常工作
    Base* base_ptr = &derived_obj;
    cout << "基类指针调用: ";
    base_ptr->show();  // 输出: Derived::show()
    
    // 情况2：基类引用指向派生类对象 - 多态正常工作  
    Base& base_ref = derived_obj;
    cout << "基类引用调用: ";
    base_ref.show();   // 输出: Derived::show()
    
    // 情况3：对象切片 - 多态失效！
    Base base_obj = derived_obj;  // 对象切片发生
    cout << "基类对象调用: ";
    base_obj.show();   // 输出: Base::show() ← 不是我们期望的派生类版本！
    
    // 验证切片效果
    cout << "base_data: " << base_obj.base_data << endl;  // 正常复制
    // cout << base_obj.derived_data << endl;  // 错误！派生类数据被切掉了
    
    return 0;
}

//基类
class Base
{
public:
	virtual void func1() { cout << "Base::func1()" << endl; }
	virtual void func2() { cout << "Base::func2()" << endl; }
private:
	int _a;
};
//派生类
class Derive : public Base
{
public:
	virtual void func1() { cout << "Derive::func1()" << endl; }
	virtual void func3() { cout << "Derive::func3()" << endl; }
	virtual void func4() { cout << "Derive::func4()" << endl; }
private:
	int _b;
};

typedef void(*VFPTR)(); //虚函数指针类型重命名
//打印虚表地址及其内容
void PrintVFT(VFPTR* ptr)
{
	printf("虚表地址:%p\n", ptr);
	for (int i = 0; ptr[i] != nullptr; i++)
	{
		printf("ptr[%d]:%p-->", i, ptr[i]); //打印虚表当中的虚函数地址
		ptr[i](); //使用虚函数地址调用虚函数
	}
	printf("\n");
}
int main()
{
	Base b;
	PrintVFT((VFPTR*)(*(int*)&b)); //打印基类对象b的虚表地址及其内容
	Derive d;
	PrintVFT((VFPTR*)(*(int*)&d)); //打印派生类对象d的虚表地址及其内容
	return 0;
}

//基类1
class Base1
{
public:
	virtual void func1() { cout << "Base1::func1()" << endl; }
	virtual void func2() { cout << "Base1::func2()" << endl; }
private:
	int _b1;
};
//基类2
class Base2
{
public:
	virtual void func1() { cout << "Base2::func1()" << endl; }
	virtual void func2() { cout << "Base2::func2()" << endl; }
private:
	int _b2;
};
//多继承派生类
class Derive : public Base1, public Base2
{
public:
	virtual void func1() { cout << "Derive::func1()" << endl; }
	virtual void func3() { cout << "Derive::func3()" << endl; }
private:
	int _d1;
};

typedef void(*VFPTR)(); //虚函数指针类型重命名
//打印虚表地址及其内容
void PrintVFT(VFPTR* ptr)
{
	printf("虚表地址:%p\n", ptr);
	for (int i = 0; ptr[i] != nullptr; i++)
	{
		printf("ptr[%d]:%p-->", i, ptr[i]); //打印虚表当中的虚函数地址
		ptr[i](); //使用虚函数地址调用虚函数
	}
	printf("\n");
}
int main()
{
	Base1 b1;
	Base2 b2;
	PrintVFT((VFPTR*)(*(int*)&b1)); //打印基类对象b1的虚表地址及其内容
	PrintVFT((VFPTR*)(*(int*)&b2)); //打印基类对象b2的虚表地址及其内容
	Derive d;
	PrintVFT((VFPTR*)(*(int*)&d)); //打印派生类对象d的第一个虚表地址及其内容
	PrintVFT((VFPTR*)(*(int*)((char*)&d + sizeof(Base1)))); //打印派生类对象d的第二个虚表地址及其内容
	return 0;
}

#include <iostream>
using namespace std;
class A
{
public:
    A(char* s) { cout << s << endl; }
    ~A() {};
};
class B : virtual public A
{
public:
    B(char* s1, char* s2)
        :A(s1)
    {
        cout << s2 << endl;
    }
};
class C : virtual public A
{
public:
    C(char* s1, char* s2)
        :A(s1)
    {
        cout << s2 << endl;
    }
};
class D : public B, public C
{
public:
    D(char* s1, char* s2, char* s3, char* s4)
        :B(s1, s2)
        , C(s1, s3)
        , A(s1)
    {
        cout << s4 << endl;
    }
};
int main()
{
    D* p = new D("class A", "class B", "class C", "class D");
    delete p;
    return 0;
}

class Base1
{
public:
    int _b1;
};
class Base2
{
public:
    int _b2;
};
class Derive : public Base1, public Base2
{
public:
    int _d;
};
int main()
{
    Derive d;
    Base1* p1 = &d;
    Base2* p2 = &d;
    Derive* p3 = &d;
    return 0;
}

#include <iostream>
using namespace std;
class A
{
public:
    virtual void func(int val = 1)
    {
        cout << "A->" << val << endl;
    }
    virtual void test()
    {
        func();
    }
};
class B : public A
{
public:
    void func(int val = 0)
    {
        cout << "B->" << val << endl;
    }
};
int main()
{
    B* p = new B;
    p->test();
    return 0;
}