C++多态

夢に向かって進む

已于 2024-03-02 23:39:16 修改

阅读量491

点赞数

分类专栏： C++ 文章标签： c++

于 2023-08-11 01:24:59 首次发布

本文链接：https://blog.youkuaiyun.com/qq_66483104/article/details/132222711

版权

C++ 专栏收录该内容

19 篇文章

订阅专栏

2.4 C++11 override 和 final

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

1.多态的概念

1.1概念

多态的概念：通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。

举个栗子：比如买票这个行为，当普通人买票时，是全价买票；学生买票时，是半价买票；军人买票时是优先买票。

2.多态的定义及实现

2.1多态的构成条件

多态是在不同继承关系的类对象，去调用同一函数，产生了不同的行为。比如Student继承了Person。Person对象买票全价，Student对象买票半价。

那么在继承中要构成多态还有两个条件：

1. 必须通过基类的指针或者引用调用虚函数
2. 被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写

2.2虚函数

在C++编程语言中，虚函数是一种特殊的成员函数，它可以在派生类中被重写（override）。当类被继承时，派生类可以根据需要重新定义虚函数的行为。虚函数使得程序能够在运行时动态地决定调用哪个类的函数实现，这一特性被称为多态。

使用virtual关键字声明虚函数时，C++编译器会为该函数添加一些额外的功能，如生成一个虚函数表（vtable），并在派生类对象中更新指向该表的指针。当调用虚函数时，程序会查找相应的vtable以确定应该调用哪个函数版本。

为了使派生类中的函数覆盖基类中的虚函数，派生类中的函数必须声明为virtual，并且在派生类对象中调用基类的虚函数时，也需要使用作用域解析操作符(::)指定基类名称，以避免调用派生类中同名的函数。

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

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

注：在C++中，派生类中对基类虚函数的重写（override）不需要显式地加上virtual关键字。当派生类中的函数与基类中的虚函数具有相同的名称和参数列表时，该派生类函数自动被视为重写基类虚函数。

例如：

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

class Derived : public Base 
{
public:
    void show() override 
    { // 重写基类的虚函数
        std::cout << "Derived show" << std::endl;
    }
};

在这个例子中，Derived 类的 show 函数不需要显式声明为virtual。只要使用了override关键字，编译器就会确保该函数正确地重写了基类中的虚函数。如果没有使用override关键字，编译器将检查函数签名是否匹配，如果匹配，也会视为重写了虚函数，但不会给出明确的语义提示。

值得注意的是，在某些情况下，你可能需要在派生类中保留虚函数的虚性，比如当你想要在派生类中进一步重写虚函数或者你想要在派生类中添加一个新的虚函数时，这时就需要显式地使用virtual关键字。

意思就是派生类被其他类继承时，如果想要重写派生类的show函数时，就可以在派生类的show函数前加上virtual关键字。

但是，通常情况下，这是不必要的，因为在C++中，一旦一个函数在基类中被声明为虚函数，所有从该基类继承的类都会自动继承这个虚函数，并且可以在任何派生类中进行重写，无论中间的派生类是否显式声明了virtual。

然而，如果您想要在派生类中添加新的虚函数，或者在派生类中改变已有的虚函数的虚性（例如，将一个非虚函数变为虚函数），那么您需要在派生类中显式地声明virtual。这样做可以允许进一步的派生类对这些新增加或改变虚性的函数进行重写。

例如：

class Base {
public:
    virtual void show() { /* ... */ }
};

class Middle : public Base {
public:
    // Base::show 在这里仍然是虚函数
    virtual void show() override { /* ... */ }
};

class Derived : public Middle {
public:
    // Base::show 在所有的派生类中都是虚函数
    void show() override { /* ... */ }
};

class NewDerived : public Derived {
public:
    // 可以添加新的虚函数
    virtual void newShow() override { /* ... */ }
};

在上面的代码中，只有newShow()是在Derived类中新增的虚函数，它需要在声明时指定virtual，因为它是Derived类的新增功能。其他虚函数show()无论在哪一层派生类中，都不需要再次声明为virtual，因为它们是从基类继承来的。

2.3虚函数的重写

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

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

class Student : public Person 
{
public:
	virtual void BuyTicket() const { cout << "买票-半价" << endl; }
	/*注意：在重写基类虚函数时，派生类的虚函数在不加virtual关键字时，虽然也可以构成重写(因
	为继承后基类的虚函数被继承下来了在派生类依旧保持虚函数属性，重写本质是重写你的实现方法),但是该种写法不是很规范，不建议
	这样使用，建议都加上virtual*/
	/*void BuyTicket() { cout << "买票-半价" << endl; }*/
};

//多态条件
//1. 必须通过基类的指针或者引用调用虚函数
//2. 被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写

//多态，不同对象传递过去，调用不同对象，多态调用看的指向的对象或者引用的对象
//普通对象，看当前类型
void Func(const Person& p)
{
	p.BuyTicket();
}

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

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

	Person p;
	Student s;

	Func(&p);
	Func(&s);

	return 0;
}

虚函数重写的两个例外：

1. 协变(基类与派生类虚函数返回值类型不同)
派生类重写基类虚函数时，与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指针或者引用，派生类虚函数返回派生类对象的指针或者引用时，称为协变。(返回值可以不同，但是要求返回值必须是父子关系指针和引用，且要么父和子都是引用或者是指针，并且父是父，子是子)

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

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

class Student : public Person {
public:
	virtual ~Student() 
	{ 
		cout << "~Student()" << endl; 
		delete[] ptr;
	}
	
protected:
	int* ptr = new int[10];
};

//析构函数可以是虚函数吗？为什么需要是虚函数
//析构函数加virtual，是不是 虚函数重写？
//是，因为类的析构函数都被处理成destructor这个统一的名字
//那为什么要让他们构成重写呢？
//因为下面的场景

int main()
{
	Person* p1 = new Person;
	delete p1;

	p1 = new Student;
	delete p1; //会转为：p->destructor() + operator delete(p);
	//这里为我们期望p->destructor()是一个多态调用，而不是普通调用

	return 0;
}

2.4 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; }
	//virtual void Drive(int) { cout << "Benz-舒适" << endl; }//构成隐藏
};

//如果设计不想被继承的类，如何设计？
//方法1：基类构造函数私有  C++98
//方法2：基类加一个final  C++11

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

//override 帮助派生类检查是否完成重写，如果没有会报错
class Car {
public:
	virtual void Drive() {}
};
class Benz :public Car {
public:
	virtual void Drive() override { cout << "Benz-舒适" << endl; }
};

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

3.抽象类

3.1概念

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

//纯虚函数：间接强制派生类重写虚函数
class Car
{
public:
	virtual void Drive() = 0;
};

class Benz :public Car
{
public:
	virtual void Drive()//重写虚函数
	{
		cout << "Benz-舒适" << endl;
	}
};

class BMW :public Car
{
public:
	virtual void Drive()//重写虚函数
	{
		cout << "BMW-操控" << endl;
	}
};

int main()
{
	//虽然纯虚函数类不能实例化出对象，但是可以定义指针类型和引用类型
	Car* pBenz = new Benz;
	pBenz->Drive();
	Car* pBMW = new BMW;
	pBMW->Drive();

	return 0;
}

3.2 接口继承和实现继承

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

4.多态的原理

4.1虚函数表和多态的原理

// 这里常考一道笔试题：sizeof(Base)是多少？
class Base
{
public:
	virtual void Func1()
	{
		cout << "Base::Func1()" << endl;
	}
	virtual void Func2()
	{
		cout << "Base::Func2()" << 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;
	printf("%d\n", sizeof(b));

	return 0;
}

通过观察测试我们发现b对象是8bytes，除了_b成员，通过监视观察还多一个__vfptr放在对象的前面(注意有些平台可能会放到对象的最后面，这个跟平台有关)，对象中的这个指针我们叫做虚函数表指针(v代表virtual，f代表function)。一个含有虚函数的类中都至少都有一个虚函数表指针，虚函数表指针指向的是虚函数表的地址，虚函数表里面存储着虚函数的地址，因为虚函数的地址要被放到虚函数表中，虚函数表也简称虚表(虚表本质是一个函数指针数组)。那么派生类中这个表放了些什么呢？我们接着往下分析：

// 针对上面的代码我们做出以下改造
// 1.我们增加一个派生类Derive去继承Base
// 2.Derive中重写Func1
// 3.Base再增加一个虚函数Func2和一个普通函数Func3
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;

	//不符合多态调用时，编译时就确定地址
	b.Func1();//不符合时直接看调用者的类型，然后到这个类里面去寻找这个函数的地址进行调用

	//符合多态时，运行时到指向对象的虚函数表中找到调用函数的地址
	Base* ptr = &b;
	ptr->Func1();

	return 0;
}

通过观察和测试，我们发现了以下几点问题：
1. 派生类对象d中也有一个虚表指针，d对象由两部分构成，一部分是自己的成员，一部分是父类继承下来的成员，并且继承下来的虚表指针指向的地址中储存着基类的虚函数地址和被重写的Derive虚函数地址。
2. 基类b对象和派生类d对象虚表是不一样的(同类型的对象共用一个虚表)，这里我们发现Func1完成了重写，所以d的虚表中存的是重写的Derive::Func1，所以虚函数的重写也叫作覆盖，覆盖就是指虚表中虚函数的覆盖(指的是继承了基类的虚表，重写了Derive::Func1，覆盖了继承下来的Base::Func1)。重写是语法的叫法，覆盖是原理层的叫法。
3. 另外Func2继承下来后是虚函数，所以放进了虚表，Func3也继承下来了，但是不是虚函数，所以不会放进虚表。
4. 虚函数表本质是一个存储虚函数指针(地址)的指针数组，一般情况这个数组最后面放了一个nullptr。
5. 总结一下派生类的虚表生成：

a.先将基类中的虚表内容拷贝一份到派生类虚表中

b.如果派生类重写了基类中某个虚函数，用派生类自己的虚函数覆盖虚表中基类的虚函数

c.派生类自己新增加的虚函数按其在派生类中的声明次序增加到派生类虚表的最后。
6. 这里还有一个很容易混淆的问题：虚函数存在哪的？虚表存在哪的？答：虚函数存在虚表，虚表存在对象中。注意上面的回答是错的。但是很多人都是这样深以为然的。注意，虚表是存在虚函数指针里，不是虚函数，虚函数和普通函数一样的，都是存在代码段的，只是他的指针(虚函数的地址)又存到了虚表中。另外对象中存的不是虚表，存的是虚表指针，只是虚表指针指向了虚表的地址。那么虚表存在哪的呢？实际我们去验证一下会发现vs下是存在代码段的。

4.2动态绑定与静态绑定

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

"绑定"指的是将函数调用与函数体关联起来的过程。当我们调用一个函数时，编译器需要确定应该调用哪个函数体来执行该函数的操作。绑定的目的就是找到与函数调用匹配的函数体。

静态绑定是在编译期进行的绑定。在静态绑定中，编译器根据函数的声明类型决定应该调用哪个函数体。这种绑定方式是通过比较函数调用中的函数名称、参数数量和参数类型与函数声明中的信息来确定的。

动态绑定是在运行时进行的绑定。在动态绑定中，通过对象的实际类型来确定应该调用哪个函数体。这种绑定方式是通过使用虚函数及虚函数表来实现的。在动态绑定中，基类指针或引用可以指向派生类对象，并在运行时调用派生类对象的函数。

绑定的目的是在函数调用时将正确的函数体与该调用关联起来。静态绑定在编译期确定绑定关系，因此在运行时速度较快。动态绑定在运行时根据对象的实际类型动态确定绑定关系，实现了多态性，但会稍微降低一些性能。选择绑定方式取决于我们在代码中所需的行为和语义。

5.单继承和多继承关系的虚函数表

需要注意的是在单继承和多继承关系中，下面我们去关注的是派生类对象的虚表模型，因为基类的虚表模型前面我们已经看过了，没什么需要特别研究的。

5.1单继承中的虚函数表

typedef void(*FUNC_PTR)();
//类型是void(*)() -- 函数指针类型，定义了一个名为 FUNC_PTR 的函数指针类型，也就是给这个类型取给名字

//打印函数指针数组
void PrintVFT(FUNC_PTR* table)//类型是void(*)() * ，FUNC_PTR是它的类型名
{
    // 依次取虚表中的虚函数指针打印并调用。调用就可以看出存的是哪个函数
    //指针(地址)都是四个字节或者八个字节，size_t也是4个字节
	for (size_t i = 0; table[i] != nullptr; i++)//停止条件是因为虚函数表后面会放一个nullptr
	{
		printf("[%d]:%p->", i, table[i]);

		FUNC_PTR f = table[i];
		f();//进行函数调用
	}
	printf("\n");
}

class Base1 
{
public:
	virtual void func1() { cout << "Base1::func1" << endl; }
	virtual void func2() { cout << "Base1::func2" << endl; }
private:
	int b1 = 1;
};
class Base2 : public Base1
{
public:
	virtual void func1() { cout << "Base2::func1" << endl; }
	virtual void func3() { cout << "Base2::func3" << endl; }
private:
	int b2 = 1;
};
int main()
{
	Base1 B1;
	Base2 B2;

    // 思路：取出B1、B2对象的头4bytes，就是虚表的指针，因为通过vs编译器观察模型，
    // 可以看到__vfptr指针放在最一个对象的最前面，所以我们只需要取出前几个字节即可。
    // 前面我们说了虚函数表本质是一个存虚函数指针的指针数组，这个数组最后面放了一个nullptr
	// 1.先取B1的地址，强转成一个int*的指针
	// 2.再解引用取值，就取到了B1对象头4bytes的值，这个值就是指向虚表的指针
	// 3.再强转成FUNC_PTR*，因为虚表就是一个存FUNC_PTR*类型(虚函数指针类型)的数组。
	// 4.虚表指针传递给PrintVFT进行打印虚表
	// 5.需要说明的是这个打印虚表的代码经常会崩溃，因为编译器有时对虚表的处理不干净，虚表最
	//后面没有放nullptr，导致越界，这是编译器的问题。我们只需要点目录栏的 - 生成 - 清理解决方案，再
	//编译就好了。
	int vft1 = *((int*)&B1);
	PrintVFT((FUNC_PTR*)vft1);

	int vft2 = *((int*)&B2);
	PrintVFT((FUNC_PTR*)vft2);

	return 0;
}

观察监视窗口中我们发现在虚表中看不见func3。这里是编译器的监视窗口故意隐藏了这个函数，也可以认为是他的一个小bug。那么我们如何查看它在虚表的位置呢？下面我们使用代码打印出虚表中的函数

5.2多继承中的虚函数表

typedef void(*FUNC_PTR)();//类型是void(*)()，FUNC_PTR是它的类型名

//打印函数指针数组
void PrintVFT(FUNC_PTR* table)//类型是void(*)() * ，FUNC_PTR是它的类型名
{
	for (size_t i = 0; table[i] != nullptr; i++)//指针(地址)都是四个字节或者八个字节
	{
		printf("[%d]:%p->", i, table[i]);

		FUNC_PTR f = table[i];
		f();
	}
	printf("\n");
}

class Base1 {
public:
	virtual void func1() { cout << "Base1::func1" << endl; }
	virtual void func2() { cout << "Base1::func2" << endl; }
private:
	int b1 = 1;
};

class Base2 {
public:
	virtual void func1() { cout << "Base2::func1" << endl; }
	virtual void func2() { cout << "Base2::func2" << endl; }
private:
	int b2 = 2;
};

class Derive : public Base1, public Base2 {
public:
	virtual void func1() { cout << "Derive::func1" << endl; }
	virtual void func3() { cout << "Derive::func3" << endl; }
private:
	int d1 = 3;
};

int main()
{
	Derive d;

	cout << sizeof(d) << endl;//20

	//求第一张虚表的位置
	int vft1 = *((int*)&d);
	PrintVFT((FUNC_PTR*)vft1);

	//求第二张虚表的位置
	//方法1
	//int vft2 = *((int*)((char*)&d + sizeof(Base1)));
	//PrintVFT((FUNC_PTR*)vft2);
	//方法2
	Base2* ptr = &d;
	int vtf3 = *((int*)ptr);
	PrintVFT((FUNC_PTR*)vtf3);

	Base1* ptr1 = &d;
	ptr1->func1();

	Base2* ptr2 = &d;
	ptr2->func1();
    
	return 0;
}

5.3菱形继承、菱形虚拟继承

实际中我们不建议设计出菱形继承及菱形虚拟继承，一方面太复杂容易出问题，另一方面这样的模型，访问基类成员有一定得性能损耗。所以菱形继承、菱形虚拟继承我们的虚表我们就不看了，一般我们也不需要研究清楚，因为实际中很少用。

6.继承和多态常见的面试问题

概念查考

1. 下面哪种面向对象的方法可以让你变得富有( A )
A: 继承 B: 封装 C: 多态 D: 抽象
2. ( D )是面向对象程序设计语言中的一种机制。这种机制实现了方法的定义与具体的对象无关，而对方法的调用则可以关联于具体的对象。
A: 继承 B: 模板 C: 对象的自身引用(如递归、自我复制或者构建复杂的数据结构，比如树或链表) D: 动态绑定
3. 面向对象设计中的继承和组合，下面说法错误的是？（ C (实际上，优先考虑组合而不是继承，是面向对象设计的常见建议，因为组合可以提供更高的灵活性和更低的耦合度)）
A：继承允许我们覆盖重写父类的实现细节，父类的实现对于子类是可见的，是一种静态复用，也称为白盒复用
B：组合的对象不需要关心各自的实现细节，之间的关系是在运行时候才确定的，是一种动态复用，也称为黑盒复用
C：优先使用继承，而不是组合，是面向对象设计的第二原则
D：继承可以使子类能自动继承父类的接口，但在设计模式中认为这是一种破坏了父类的封装性的表现
4. 以下关于纯虚函数的说法,正确的是( A )

A：声明纯虚函数的类不能实例化对象 B：声明纯虚函数的类是虚基类
C：子类必须实现基类的纯虚函数 D：纯虚函数必须是空函数
5. 关于虚函数的描述正确的是( B )
A：派生类的虚函数与基类的虚函数具有不同的参数个数和类型 B：内联函数不能是虚函数
C：派生类必须重新定义基类的虚函数 D：虚函数可以是一个static型的函数

6. 关于虚表说法正确的是（ D ）
A：一个类只能有一张虚表
B：基类中有虚函数，如果子类中没有重写基类的虚函数，此时子类与基类共用同一张虚表
C：虚表是在运行期间动态生成的
D：同一个类的不同对象共享该类的虚表

因为一个类可能有多张虚表，只是同类对象共享该类的虚表；基类中有虚函数，如果子类中没有重写基类的虚函数，此时子类与基类虚表中的地址一样，但是虚表的指针是不同的；虚表是在编译期间就已经确定好了。
7. 假设A类中有虚函数，B继承自A，B重写A中的虚函数，也没有定义任何虚函数，则（ D ）
A：A类对象的前4个字节存储虚表地址，B类对象前4个字节不是虚表地址
B：A类对象和B类对象前4个字节存储的都是虚基表的地址
C：A类对象和B类对象前4个字节存储的虚表地址相同
D：A类和B类虚表中虚函数个数相同，但A类和B类使用的不是同一张虚表