目录
1. 多态的概念
2. 多态的定义及实现
2.1多态的构成条件
2.2 虚函数
2.3 虚函数的重写
2.3.1 虚函数重写的两个例外
2.4 C++11 override 和 fifinal
2.5 重载、覆盖(重写)、隐藏(重定义)的对比
2.6 多态示例
3. 抽象类
3.1 概念
3.2 接口继承和实现继承
4. 多态的原理
4.1 虚函数表
4.2 多态原理总结
4.3 动态绑定与静态绑定
5. 单继承和多继承关系中的虚函数表
5.1 单继承中的虚函数表
5.2 多继承中的虚函数表
(1)多态是不同继承关系的类对象,去调用同一函数,产生了不同的行为。
(2)必须通过基类的指针或者引用调用虚函数。
class Person {
public:
virtual void BuyTicket() { cout << "全票" << endl;}
};
class A{};
class B : public A {};
class Person {
public:
virtual A* f() {return new A;}
};
class Student : public Person {
public:
virtual B* f() {return new B;}
};
(2)析构函数的重写(基类与派生类析构函数的名字不同)
class Person {
public:
virtual ~Person() { cout << "~Person()" << endl; }
};
class Student : public Person {
public:
virtual ~Student() { cout << "~Student()" << endl; }
};
// 只有派生类Student的析构函数重写了Person的析构函数,下面的delete对象调用析构函数,才能
// 构成多态,才能保证p1和p2指向的对象正确的调用析构函数。
int main()
{
Person* p1 = new Person;
Person* p2 = new Student;
delete p1;
delete p2;
return 0;
}
class Car
{
public:
virtual void Drive() final {}
};
class Benz :public Car
{
public:
virtual void Drive() {cout << "Benz-舒适" << endl;}
};
class Car{
public:
virtual void Drive(){}
};
class Benz :public Car {
public:
virtual void Drive() override {cout << "Benz-舒适" << endl;}
};
(1)重载:在同一作用域中,函数名相同,参数不同。
(2)重写(覆盖):①两个函数分别在基类和派生类的作用域,返回值、参数、函数名都相同(协变、析构函数的重写例外)。②两个函数必须是虚函数。③重写是语法的叫法,覆盖是原理层的叫法。
(3)重定义(隐藏):①两个函数或者成员变量分别在基类和派生类的作用域。②函数名或者成员变量名相同。③两个基类和派生类的函数,不构成重写就是重定义。
class Person
{
public:
virtual void BuyTicket(void)
{
cout << "全票" << endl;
}
};
class Student : public Person
{
public:
//不带virtual也构成重写,在父类那里继承了虚属性
//构成重写(覆盖)
virtual void BuyTicket(void)
{
cout << "半票" << endl;
}
};
void fun(Person& people)
{
people.BuyTicket();
}
int main()
{
Person A;
Student B;
fun(A);//多态
fun(B);//多态
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 PrintVTable(VFPTR vTable[])
{
// 依次取虚表中的虚函数指针打印并调用。调用就可以看出存的是哪个函数
cout << " 虚表地址>" << vTable << endl;
for (int i = 0; vTable[i] != nullptr; ++i)
{
printf(" 第%d个虚函数地址 :0X%x,->", i, vTable[i]);
VFPTR f = vTable[i];
f();
}
cout << endl;
}
int main()
{
Base b;
Derive d;
// 思路:取出b、d对象的头4bytes,就是虚表的指针,前面我们说了虚函数表本质是一个存虚函数指
//针的指针数组,这个数组最后面放了一个nullptr
// 1.先取b的地址,强转成一个int*的指针
// 2.再解引用取值,就取到了b对象头4bytes的值,这个值就是指向虚表的指针
// 3.再强转成VFPTR*,因为虚表就是一个存VFPTR类型(虚函数指针类型)的数组。
// 4.虚表指针传递给PrintVTable进行打印虚表
// 5.需要说明的是这个打印虚表的代码经常会崩溃,因为编译器有时对虚表的处理不干净,虚表最后面
//没有放nullptr,导致越界,这是编译器的问题。我们只需要点目录栏的 - 生成 - 清理解决方
//案,再编译就好了。
VFPTR * vTableb = (VFPTR*)(*(int*)&b);
PrintVTable(vTableb);
VFPTR* vTabled = (VFPTR*)(*(int*)&d);
PrintVTable(vTabled);
return 0;
}
//多继承中的虚函数表
class Base1 {
public:
virtual void func1() { cout << "Base1::func1" << endl; }
virtual void func2() { cout << "Base1::func2" << endl; }
private:
int b1;
};
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 PrintVTable(VFPTR vTable[])
{
cout << " 虚表地址>" << vTable << endl;
for (int i = 0; vTable[i] != nullptr; ++i)
{
printf(" 第%d个虚函数地址 :0X%x,->", i, vTable[i]);
VFPTR f = vTable[i];
f();
}
cout << endl;
}
//多继承派生类的未重写的虚函数放在第一个继承基类部分的虚函数表中
int main()
{
Derive d;
VFPTR* vTableb1 = (VFPTR*)(*(int*)&d);
PrintVTable(vTableb1);
VFPTR* vTableb2 = (VFPTR*)(*(int*)((char*)&d + sizeof(Base1)));
PrintVTable(vTableb2);
return 0;
}