C++ 多态

目录

一、多态的定义及实现

1、多态的构成条件

2、虚函数

3、虚函数的重写

两个例外：

4、例题

[5、C++11 override 和 final](#5、C++11 override 和 final)

6、重载、覆盖(重写)、隐藏(重定义)的对比

[二. 抽象类](#二. 抽象类)

1、概念

2、接口继承和实现继承

三、多态的原理

1、虚函数表(虚表)

2、打印虚表

3、多继承中的虚函数表

4、动态绑定与静态绑定

四、例题

---

一、多态的定义及实现

1、多态的构成条件

多态是在不同继承关系的类对象，去调用同一函数，产生了不同的行为。

比如Student继承了 Person。Person对象买票全价，Student对象买票半价。

那么在继承中要构成多态还有两个条件：
1、虚函数的重写 -- 三同(函数名、参数、返回值类型)
-- 例外(协变)：返回值可以不同，必须是父子关系指针或者引用
-- 例外：子类虚函数可以不加virtual
2、父类指针或者引用去调用

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

class Student : public Person
{
public:
	// 重写/覆盖
	virtual void BuyTicket() { cout << "买票-半价" << endl; }
};

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

int main()
{
	Person ps;
	Student st;

	Func(ps);
	Func(st);

	return 0;
}

2、虚函数

虚函数：即被virtual修饰的类成员函数称为虚函数

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

3、虚函数的重写

虚函数的重写(覆盖)：派生类中有一个跟基类完全相同的虚函数(即派生类虚函数与基类虚函数的返回值类型、函数名字、参数列表完全相同)，称子类的虚函数重写了基类的虚函数。

接下来我们看看满足和不满足多态的两种情况：

1、满足多态 -- 看指向的对象的类型，调用这个类型的成员函数

class Person {
public:
	virtual void BuyTicket() { cout << "买票-全价" << endl; }
};
class Student : public Person {
public:
	virtual void BuyTicket() { cout << "买票-半价" << endl; }
};
void Func(Person& p)
{
	p.BuyTicket();
}
int main()
{
	Person ps;
	Student st;
	Func(ps);
	Func(st);
	return 0;
}

2、不满足多态 -- 看调用者的类型，调用这个类型的成员函数

class Person {
public:
	void BuyTicket() { cout << "买票-全价" << endl; }
};
class Student :public Person {
public:
	virtual void BuyTicket() { cout << "买票-半价" << endl; }
};
void Func(Person& p)
{
	p.BuyTicket();
}

int main()
{
	Person ps;
	Student st;

	Func(ps);
	Func(st);
	return 0;
}

注意：在重写基类虚函数时，派生类的虚函数在不加virtual关键字时，虽然也可以构成重写(因为继承后基类的虚函数被继承下来了在派生类依旧保持虚函数属性),但是该种写法不是很规范，不建议这样使用。 （重写=接口继承+重写继承父类这个函数的实现）

class Person {
public:
	virtual void BuyTicket() { cout << "买票-全价" << endl; }
};
class Student : public Person {
public:
	void BuyTicket() { cout << "买票-半价" << endl; }
};
void Func(Person& p)
{
	p.BuyTicket();
}
int main()
{
	Person ps;
	Student st;
	Func(ps);
	Func(st);
	return 0;
}

父类的析构函数加virtual，子类不加也够成多态。

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

	virtual ~Person()
	{
		cout << "~Person()" << endl;
	}
};

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

	~Student()
	{
		cout << "~Student()" << endl;
	}
};


void Func(Person* p)
{
	p->BuyTicket();
	delete p;
}

int main()
{
	Func(new Person);
	Func(new Student);

	return 0;
}

两个例外：

1. 协变(基类与派生类虚函数返回值类型不同)

• 协变返回值可以不同，必须是父子关系指针或者引用
• 派生类重写基类虚函数时，与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指针或者引用，派生类虚函数返回派生类对象的指针或者引用时，称为协变。

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. 析构函数的重写(基类与派生类析构函数的名字不同
   如果基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加virtual关键字，都与基类的析构函数构成重写，虽然基类与派生类析构函数名字不同，看起来违背了重写的规则，其实不然，这里可以理解为编译器对析构函数的名称做了特殊处理，编译后析构函数的名称统一处理成destructor。

class Person {
public:
	virtual ~Person() { cout << "~Person()" << endl; }
};
class Student : public Person {
public:
	virtual ~Student() { cout << "~Student()" << endl; }
};
int main()
{
	Person* p1 = new Person;
	Person* p2 = new Student;
	delete p1;
	delete p2;
	return 0;
}

4、例题

下面程序的输出结果是什么呢

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;
}

• 在这段代码中，类A和类B之间存在继承关系。类A中有两个成员函数：func和test。func函数有一个默认参数val，默认值为1。test函数调用了func函数。
• 类B继承自类A，并且重写了func函数。在类B中，func函数也有一个默认参数val，默认值为0。
• 在main函数中，创建了一个指向类B对象的指针p，然后调用了p->test()。
• 由于test函数在类A中被声明为虚函数，因此在运行时会根据实际对象的类型(*this)来确定调用的函数。在这里，p指向的是类B的对象，所以调用的是类B中的test函数。
• 在类B的test函数中，调用了func函数，但没有提供参数。由于func函数在类B中被重写，因此会调用类B中的func函数。
• 然而，由于默认参数的值是在编译时确定的，而不是在运行时确定的，所以在调用func函数时，默认参数的值是根据函数声明的类型来确定的。在这里，函数声明的类型是类A中的func函数，所以默认参数的值为1。
• 因此，当调用p->test()时，输出的结果是"B->1"。

test()函数在类B中调用，输出结果是什么呢？

class A
{
public:
	virtual void func(int val = 1) { std::cout << "A->" << val << std::endl; }
};

class B : public A
{
public:
	void func(int val = 0) { std::cout << "B->" << val << std::endl; }
	virtual void test() { func(); }
};

int main(int argc, char* argv[])
{
	B* p = new B;
	p->test();
	return 0;
}

这里没有通过基类的指针或引用调用test()函数，是通过类B的指针p的this指针来调用test函数。

5、C++11 override 和 final

从上面可以看出，C++对函数重写的要求比较严格，但是有些情况下由于疏忽，可能会导致函数
名字母次序写反而无法构成重载，而这种错误在编译期间是不会报出的，只有在程序运行时没有
得到预期结果才来debug会得不偿失，因此：C++11提供了override和final两个关键字，可以帮
助用户检测是否写。

1. final：修饰虚函数，表示该虚函数不能再被重写

class Car
{
public:
	virtual void Drive() final {}
};
class Benz :public Car
{
public:
	virtual void Drive() { cout << "Benz-舒适" << endl; }
};

2. override: 检查派生类虚函数是否重写了基类某个虚函数，如果没有重写编译报错。

class Car {
public:
	void Drive() { cout << "Benz-速度快" << endl; }
};
class Benz :public Car {
public:
	virtual void Drive() override { cout << "Benz-舒适" << endl; }
};
int main()
{
	Car p;
	p.Drive();
	Benz q;
	q.Drive();

	return 0;
}

6、重载、覆盖(重写)、隐藏(重定义)的对比

二. 抽象类

1、概念

在虚函数的后面写上=0 ，则这个函数为纯虚函数。包含纯虚函数的类叫做抽象类（也叫接口类），抽象类不能实例化出对象。派生类继承后也不能实例化出对象，只有重写纯虚函数，派生类才能实例化出对象。纯虚函数规范了派生类必须重写，另外纯虚函数更体现出了接口继承。

class Car
{
public:
	// 纯虚函数  -- 抽象类 -- 不能实例化出对象
	virtual void Drive() = 0;
};

int main()
{
	Car car;
	return 0;
}

2、接口继承和实现继承

• 普通函数的继承是一种实现继承，派生类继承了基类函数，可以使用函数，继承的是函数的实现。
• 虚函数的继承是一种接口继承，派生类继承的是基类虚函数的接口，目的是为了重写，达成多态，继承的是接口。所以如果不实现多态，不要把函数定义成虚函数。

三、多态的原理

1、虚函数表(虚表)

class Base
{
public:
	virtual void Func1()
	{
		cout << "Func1()" << endl;
	}
private:
	int _b = 1;
};

通过观察测试我们发现b对象是8bytes，除了_b成员，还多一个__vfptr放在对象的前面(注意有些
平台可能会放到对象的最后面，这个跟平台有关)，对象中的这个指针我们叫做虚函数表指针(v代
表virtual，f代表function)。一个含有虚函数的类中都至少都有一个虚函数表指针，因为虚函数
的地址要被放到虚函数表中，虚函数表也简称虚表（函数指针数组）。

接下来观察下面代码：

class Base
{
public:
	virtual void Func1()
	{
		cout << "Base::Func1()" << endl;
	}
	virtual void Func2()
	{
		cout << "Base::Func2()" << endl;
	}
	void Func3()
	{
		cout << "Base::Func3()" << endl;
	}
private:
	int _b = 1;
};
class Derive : public Base
{
public:
	virtual void Func1()
	{
cout << "Derive::Func1()" << endl;
 }
private:
	int _d = 2;
};
int main()
{
	Base b;
	Derive d;
	return 0;
}

通过观察和测试，我们发现了以下几点问题：

1. 派生类对象d中也有一个虚表指针，d对象由两部分构成，一部分是父类继承下来的成员，虚 表指针也就是存在部分的另一部分是自己的成员。
2. 基类b对象和派生类d对象虚表是不一样的，这里我们发现Func1完成了重写，所以d的虚表 中存的是重写的Derive::Func1，所以虚函数的重写也叫作覆盖，覆盖就是指虚表中虚函数 的覆盖。重写是语法的叫法，覆盖是原理层的叫法。
3. 另外，基类中的Func2被继承下来后仍然是虚函数，所以它也被放入了派生类的虚表中。Func3也继承下来了，但是不是虚函数，所以不会放进虚表。
4. 虚函数表本质是一个存虚函数指针的指针数组，通常在数组的最后放置一个nullptr指针（vs系列编译器有，g++没有）。
5. 总结一下派生类的虚表生成过程： a. 首先将基类中的虚表内容拷贝一份到派生类的虚表中。 b. 如果派生类重写了基类中的某个虚函数，就用派生类自己的虚函数地址覆盖虚表中基类的虚函数地址。 c. 派生类自己新增加的虚函数按照在派生类中的声明顺序增加到派生类虚表的最后。
6. 需要注意的是，虚函数本身是存在代码段中的，而虚表存储的是虚函数指针。对象中存储的是虚表指针，而不是虚表本身。那么虚表存在哪的呢？实际我们去验证一下会发现vs下是存在代码段的。

同类型对象共用一个虚表 ：

int main()
{
	Base b1;
	Base b2;
	Base b3;
	Derive d;
	return 0;
}

2、多态的原理
这里Func函数传Person调用的 Person::BuyTicket，传Student调用的是Student::BuyTicket：

class Person {
public:
	virtual void BuyTicket() { cout << "买票-全价" << endl; }
};
class Student : public Person {
public:
	virtual void BuyTicket() { cout << "买票-半价" << endl; }
};
void Func(Person& p)
{
	p.BuyTicket();
}
int main()
{
	Person Mike;
	Func(Mike);
	Student Johnson;
	Func(Johnson);
	return 0;
}

1、通过上面的代码和监视窗口p是指向mike对象时，p->BuyTicket在mike的虚表中找到虚
函数是Person::BuyTicket。
2、p是指向johnson对象时，p->BuyTicket在johson的虚表中 找到虚函数是Student::BuyTicket。
3、多态是面向对象编程中的一个重要概念，它允许不同类型的对象通过相同的接口来实现不同的行为。在C++中，多态性通过虚函数和对象的指针或引用来实现。

• 在上述代码中，有一个基类Person和一个派生类Student。基类中定义了一个虚函数BuyTicket，派生类中重写了该虚函数。
• 在Func函数中，参数是基类Person的引用。当我们通过基类的引用调用Func函数时，可以传递基类对象或派生类对象。在函数内部，通过引用调用对象的虚函数BuyTicket。
• 在main函数中，创建了一个基类对象Mike和一个派生类对象Johnson。然后分别将它们作为参数传递给Func函数。
• 当Func函数中的参数是基类引用时，根据对象的实际类型，会调用相应的虚函数。对于Mike对象，调用的是基类Person中的BuyTicket函数；对于Johnson对象，调用的是派生类Student中重写的BuyTicket函数。

4、这就是多态的实现原理。通过虚函数的覆盖和对象的指针或引用调用虚函数，实现了在运行时根据对象的实际类型来确定调用的函数。

5、在汇编代码中，可以看到函数调用并不是在编译时确定的，而是在运行时通过对象的虚表来查找相应的虚函数。这就是多态的特性，使得不同对象在执行相同行为时展现出不同的形态。

6、总结一下，多态的实现需要满足两个条件：虚函数的覆盖和对象的指针或引用调用虚函数。通过这种方式，可以实现不同对象在执行相同行为时表现出不同的形态。

2、打印虚表

class Base
{
public:
	Base()
		:_b(10)
	{
		++_b;
	}

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

	virtual void Func2()
	{
		cout << "Base::Func2()" << endl;
	}

	void Func3()
	{
		cout << "Base::Func3()" << endl;
	}

private:
	int _b = 1;
};

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

	virtual void Func4()
	{
		cout << "Derive::Func4()" << endl;
	}
private:
	int _d = 2;
};

typedef void(*VF_PTR)();
void PrintVFTable(VF_PTR table[])
{
	for (int i = 0; table[i] != nullptr; i++) {
		printf("[%d]:%p->", i, table[i]);
		VF_PTR f = table[i];
		f();
	}
}

int main()
{
	Base b;
	Derive d;
	//32位
	//PrintVFTable((VF_PTR*)*(int*)&b);
	//PrintVFTable((VF_PTR*)*(int*)&d);

	//64位
	//PrintVFTable((VF_PTR*)*(long long*)&b);
	//PrintVFTable((VF_PTR*)*(long long*)&d);

	//32位/64位均可
	PrintVFTable(*(VF_PTR**)&b);
	PrintVFTable(*(VF_PTR**)&d);

	return 0;
}

• PrintVFTable(*(VF_PTR**)&b)这行代码是在调用PrintVFTable函数，并将b对象的地址转换为指向虚函数表的指针，然后将该指针作为参数传递给PrintVFTable函数。
• 在这段代码中，PrintVFTable函数用于打印虚函数表的内容。它接受一个指向虚函数表的指针数组作为参数，并遍历数组中的每个元素，打印出函数指针的地址，并调用对应的函数。
• *(VF_PTR**)&b这个表达式的含义是将b对象的地址转换为指向虚函数表的指针。首先，&b获取b对象的地址，然后通过(VF_PTR*)将其转换为指向VF_PTR类型的指针，最后再通过*解引用操作符获取指针所指向的虚函数表的地址。
• 通过这样的转换，我们可以将b对象的地址作为参数传递给PrintVFTable函数，以便打印出Base类的虚函数表的内容。
• 注释部分是根据不同的编译环境选择不同的转换方式，因为在32位和64位系统中，指针的大小不同。

64位环境下输出：

对象中虚表指针什么时候初始化的？ -- 构造函数的初始化列表

接下来跳转到构造函数

构造函数结束，虚表指针初始化完成，

虚表存储在哪？---常量区 （数据段**）**

int main()
{
	Base b;
	Derive d;

	int x = 0;
	static int y = 0;
	int* z = new int;
	const char* p = "xxxxxxxxxxxxxxxxxx";

	printf("栈对象：%p\n", &x);
	printf("堆对象：%p\n", z);
	printf("静态区对象：%p\n", &y);
	printf("常量区对象：%p\n", p);
	printf("b对象虚表：%p\n", *((int*)&b));
	printf("d对象虚表：%p\n", *((int*)&d));
	return 0;
}

3、多继承中的虚函数表

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(*VF_PTR)();
//void PrintVFTable(VF_PTR table[])
void PrintVFTable(VF_PTR* table)
{
	for (int i = 0; table[i] != nullptr; i++) {
		printf("[%d]:%p->", i, table[i]);
		VF_PTR f = table[i];
		f();
	}
}

int main()
{
	Derive d;
	PrintVFTable((VF_PTR*)(*(int*)&d));
	//PrintVFTable((VF_PTR*)(*(int*)((char*)&d+sizeof(Base1))));
	Base2* ptr2 = &d;
	PrintVFTable((VF_PTR*)(*(int*)(ptr2)));

	return 0;
}

在C++中，每个具有虚函数的类都有一个虚函数表（vtable），但是这个表是类级别的，而不是对象级别的。也就是说，所有同一类型的对象共享同一个虚函数表，而不是每个对象都有自己的虚函数表。

• 在上面的代码中，Derive类继承自Base1和Base2，并且覆盖了Base1和Base2的func1函数。因此，Derive类的虚函数表将包含指向Derive::func1、Base1::func2、Base2::func1、Base2::func2和Derive::func3的指针。
• 当创建一个Derive对象d时，d的内存布局中将包含两个虚函数表指针（vptr），一个指Base1的虚函数表，一个指向Base2的虚函数表。这是因为Derive类从两个基类继承，每个基类都有自己的虚函数表。
• 在上面的代码中，通过将d的地址转换为int指针，然后解引用它来获取虚函数表的地址。这实际上获取的是d的第一个虚函数表指针，也就是指向Base1的虚函数表的指针。如果想获取d的第二个虚函数表指针，也就是指向Base2的虚函数表的指针，需要将d的地址加上Base1的大小，或者使用Base2指针指向d的地址进行切片，切出d中Base2的部分，然后再进行转换和解引用。

多继承派生类的未重写的虚函数放在第一个继承基类部分的虚函数表中。

• 如果Derive类只从Base1或Base2单继承，那么Derive类会有自己的虚函数表。这个虚函数表会包含Derive类自己定义或覆盖的虚函数，以及从基类继承的所有虚函数。
• 例如，如果Derive类只从Base1继承，那么Derive类的虚函数表会包含func1()和func2()，因为这两个函数在Base1类中被声明为虚函数。如果Derive类覆盖了这些函数，那么虚函数表中对应的条目会被更新为指向Derive类的函数版本。

4、动态绑定与静态绑定

1. 静态绑定又称为前期绑定(早绑定)，在程序编译期间确定了程序的行为 ，也称为静态多态， 比如：函数重载
2. 动态绑定又称后期绑定(晚绑定)，是在程序运行期间，根据具体拿到的类型确定程序的具体 行为，调用具体的函数，也称为动态多态。

四、例题

下面说法正确的是()

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;
}

A ：p1 == p2 == p3 B：p1 < p2 < p3 C：p1 == p3 != p2 D： p1 != p2 != p3

答：C

下面程序的输出结果（）

#include <iostream>

class A {
public:
    A() : m_iVal(0) { test(); }
    virtual void func() { std::cout << m_iVal << ' '; }
    void test() { func(); }
public:
    int m_iVal;
};

class B : public A {
public:
    B() { test(); }
    virtual void func() {
        ++m_iVal;
        std::cout << m_iVal << ' ';
    }
};

int main(int argc, char* argv[]) {
    A* p = new B;
    p->test();
    delete p;
    return 0;
}

这是一个关于C++中的继承和虚函数的例子。在这个例子中，我们有两个类，A和B，其中B是A的子类。这两个类都有一个名为func的函数，但在B中，这个函数被重写了。同时，这两个类都有一个名为test的函数，它调用了func函数。在类A的构造函数中，调用了test函数。

现在，让我们逐步解析这个程序的执行过程：

1. 在main函数中，我们创建了一个指向B类对象的A类指针p。这是通过new B实现的。

2. 创建B类对象时，首先会调用其基类A的构造函数。在A的构造函数中，m_iVal被初始化为0，然后调用test函数。

3. test函数调用func函数。这里需要注意的是，虽然此时正在创建B类对象，但是因为在A的构造函数中调用的func，所以此时的func是A类的func，而不是B类的func。因此，此时输出的是0。

4. A类的构造函数执行完毕后，开始执行B类的构造函数。在B类的构造函数中，也调用了test函数。

5. 但是此时，因为B类对象已经创建完毕，所以调用的func是B类的func。在B类的func中，m_iVal被增加1，然后输出。因此，此时输出的是1。

6. B类的构造函数执行完毕后，回到main函数。在main函数中，通过A类指针p调用test函数。

7. 因为p实际指向的是B类对象，所以此时调用的func是B类的func。因此，m_iVal再次被增加1，然后输出。此时输出的是2。

8. 最后，删除p指向的对象，并返回0。

所以，这个程序的输出应该是 "0 1 2 "。

下面程序的输出结果（）

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


class B : public A
{
private:
    virtual void f()
    {
        cout << "B::f()" << endl;
    }
};

int main() {
    A* pa = (A*)new B;

    pa->f();
}

这是一个关于C++中的继承、虚函数和访问控制的例子。在这个例子中，我们有两个类，A和B，其中B是A的子类。这两个类都有一个名为f的函数，但在B中，这个函数被重写了。同时，B类中的f函数被声明为私有的。

现在，让我们逐步解析这个程序的执行过程：

1. 在main函数中，我们创建了一个指向B类对象的A类指针pa。这是通过new B实现的。

2. 然后，我们通过A类指针pa调用f函数。在C++中，如果一个函数被声明为虚函数，那么在通过指针或引用调用这个函数时，会根据指针或引用实际指向的对象类型来决定调用哪个函数。这就是所谓的动态绑定或运行时多态。

3. 在你的代码中，虽然pa是一个A类指针，但它实际指向的是一个B类对象。所以，pa->f()实际上调用的是B类的f函数。

4. 但是，B类的f函数被声明为私有的，这意味着它不能被类的外部访问，包括其子类和父类。所以，尽管pa实际指向的是一个B类对象，但是在main函数中，我们无法通过pa调用B类的f函数。这将导致编译错误。

所以，这个程序在编译时会报错，因为试图访问一个私有成员函数。如果你想让这个程序能够正确运行，你需要将B类的f函数声明为公有的或保护的。