一篇文章带你了解C++多态的实现原理

目录

• 虚函数和多态
• 多态的作用
• 多态的一个例子
• 构造函数和析构函数中存在多态吗？
• 多态的实现原理

• 虚函数表

class Base 
{
    virtual int Fun() ; // 虚函数
};
int Base::Fun() // virtual 字段不用在函数体时定义
{ }

#include <iostream>
using namespace std;
class Animal
{
public:
	virtual void speak()
	{
		cout << "动物在说话" << endl;
	}
};
class Cat: public Animal
{
public:
	void speak()
	{
		cout << "猫在叫" << endl;
	}
};
void test01()
{
	Cat cat;
	Animal* p = &cat;//Animal *p=new Cat
	p->speak();//用哪个虚函数取决于 p 指向哪种类型的对象
}
int main()
{
	test01();
}

#include <iostream>
using namespace std;
class Animal
{
public:
	virtual void speak()
	{
		cout << "动物在说话" << endl;
	}
};
class Cat: public Animal
{
public:
	void speak()
	{
		cout << "猫在叫" << endl;
	}
};
void test01()
{
	Cat cat;
	Animal& p = cat;
	p.speak();
}
int main()
{
	test01();
}

class Base 
{
public:
    void fun1() 
    { 
        fun2(); 
    }
    virtual void fun2()  // 虚函数
    { 
        cout << "Base::fun2()" << endl; 
    }
};
class Derived : public Base 
{
public:
    virtual void fun2()  // 虚函数
    { 
        cout << "Derived:fun2()" << endl; 
    }
};
int main() 
{
    Derived d;
    Base * pBase = & d;
    pBase->fun1();
    return 0;
}

class Base 
{
public:
    void fun1() 
    { 
        this->fun2();  // this是基类指针，fun2是虚函数，所以是多态
    }
}

#include <iostream>
using namespace std;
// 基类
class CFather
{
public:
    virtual void hello() // 虚函数
    {
        cout << "hello from father" << endl;
    }
    virtual void bye() // 虚函数
    {
        cout << "bye from father" << endl;
    }
};
// 派生类
class CSon : public CFather
{
public:
    CSon() // 构造函数
    {
        hello();
    }
    ~CSon()  // 析构函数
    {
        bye();
    }
    virtual void hello() // 虚函数
    {
        cout << "hello from son" << endl;
    }
};
int main()
{
    CSon son;
    CFather* pfather;
    pfather = &son;
    pfather->hello(); //多态
    return 0;
}

class A 
{
public:
    int i;
    virtual void Print() { } // 虚函数
};
class B
{
public:
    int n;
    void Print() { } 
};
int main() 
{
    cout << sizeof(A) << ","<< sizeof(B);
    return 0;
}

// 基类
class Base 
{
public:
    int i;
    virtual void Print() { } // 虚函数
};
// 派生类
class Derived : public Base
{
public:
    int n;
    virtual void Print() { } // 虚函数
};

// 基类
class A 
{
public: 
    A()  // 构造函数
    {
        cout << "construct A" << endl;
    }
    ~A() // 析构函数
    {
        cout << "Destructor A" << endl;
    }
};
// 派生类
class B : public A 
{
public: 
    B()  // 构造函数
    {
        cout << "construct B" << endl;
    }
    ~B()// 析构函数
    {
        cout << "Destructor B" << endl;
    }
};
int main() 
{
    A *pa = new B();
    delete pa;
    return 0;
}

// 基类
class A 
{
public: 
    A()  
    {
        cout << "construct A" << endl;
    }
    virtual ~A() // 虚析构函数
    {
        cout << "Destructor A" << endl;
    }
};

class A 
{
public:
    virtual void Print( ) = 0 ; //纯虚函数
private: 
    int a;
};

A a;         // 错，A 是抽象类，不能创建对象
A * pa ;     // ok,可以定义抽象类的指针和引用
pa = new A ; // 错误, A 是抽象类，不能创建对象