【C++多态一点就通】

已于 2024-11-08 10:27:57 修改
阅读量1.2k 收藏 15
点赞数 38
分类专栏： C++学习笔记 文章标签： c++ 开发语言
于 2024-11-07 21:51:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/double__main__/article/details/143516213
版权

【知识预告】

  1. 多态的概念
  2. 多态的定义及实现
  3. 抽象类
  4. 多态的原理
  5. 继承和多态常见的面试问题

1 多态的概念

多态的概念：通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。
举个例子：比如买票这个行为，当普通人买票时，是全价买票；学生买票时，是半价买票；军人买票时是优先买票。

2 多态的定义及实现

2.1 多态的构成条件

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

在继承中要构成多态还有两个条件：
1. 必须通过基类的指针或者引用调用虚函数
2. 被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写

2.2 虚函数

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

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

2.3 虚函数的重写

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

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

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

虚函数重写的两个例外：

  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;
	}
};
  1. 析构函数的重写(基类与派生类析构函数的名字不同)
    如果基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加virtual关键字，都与基类的析构函数构成重写，虽然基类与派生类析构函数名字不同。虽然函数名不相同，看起来违背了重写的规则，其实不然，这里可以理解为编译器对析构函数的名称做了特殊处理，编译后析构函数的名称统一处理成destructor。
class Person 
{
public:
	// 父类virtual不能省略
	virtual Person* BuyTicket()
	//virtual void BuyTicket()
	{ 
		cout << "Person买票-全价" << endl; 

		return nullptr;
	}

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

class Student : public Person 
{
public:
	// 子类virtual可以省略，但是不建议省略
	virtual Student* BuyTicket()
	//virtual void BuyTicket()
	{ 
		cout << "Student买票-半价" << endl;
		return nullptr;
	}

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

// 多态的条件
// 1、虚函数重写
// 2、父类的指针或者引用去调用

// 虚函数重写
// 父子继承关系的两个虚函数，三同（函数名/参数/返回值）
// virtual只能修饰成员
// 三同（函数名/参数/返回值）的例外：
// 协变-->返回值可以不同，但是必须是父子关系的指针或引用
// 派生类重写的函数可以不加virtual（建议都加上）

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

int main()
{
	Person ps;
	Student st;
	Func(ps);  // 买票-全价
	Func(st);  // 买票-半价

	return 0;
}

补充：析构函数先调用子类再调用父类

int main()
{
	// 析构是虚函数，才能正确调用析构函数
	Person* p = new Person;
	delete p;  // ~Person()

	p = new Student;
	delete p;
	// ~Student()
	// ~Person()
	
	return 0;
}

2.4 C++11 override 和 final

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

  1. final：修饰虚函数，表示该虚函数不能再被重写
// final修饰类，不能被继承
// final修饰虚函数，不能被重写
class Car
{
public:
	virtual void Drive() final 
	{}
};

class Benz : public Car
{
public:
	virtual void Drive()   // 报错，final修饰则不能继承
	{ 
		cout << "Benz-舒适" << endl; 
	}
};
  1. override: 检查派生类虚函数是否重写了基类某个虚函数，如果没有重写编译报错。
class Car 
{
public:
	virtual void Drive() 
	{}
};

class Benz :public Car 
{
public:
	// override修饰派生类的虚函数
	// 检查是否完成重写
	virtual void Drive() override 
	{ 
		cout << "Benz-舒适" << endl;
	}
};

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

  1. 重载

    • 两个函数在同一作用域
    • 函数名相同，参数不同（类型、个数、顺序）

  2. 重写（覆盖）

    • 两个函数分别在基类和派生类的作用域
    • 函数名、参数、返回值都必须相同（协变例外）
    • 两个函数必须是虚函数

  3. 重定义（隐藏）

    • 两个函数分别在基类和派生类的作用域
    • 函数名相同
    • 两个基类和派生类的同名函数不构成重写就是重定义

3 抽象类

3.1 概念

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

class Car
{
public:
	// 纯虚函数
	// 1、间接强制派生类去重写
	// 2、抽象类 - 不能实例化出对象
	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;
	}
};

void func(Car* ptr)
{
	ptr->Drive();
}

int main()
{

	//Car c;  // 报错
	Benz b;

	func(new Benz);
	func(new BMW);

	return 0;
}

3.2 接口继承和实现继承

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

4 多态的原理

4.1 虚函数表

// 常考一道笔试题：sizeof(Base)是多少？
class Base
{
public:
	virtual void Func1()
	{
		cout << "Func1()" << endl;
	}

private:
	int _b = 1;
	char _ch1;
};

// 只要是算虚函数大小
// 就要考虑里面会多一个指针（虚函数表指针）
// x86环境，指针大小为4

int main()
{
	cout << sizeof(Base) << endl;  // 12
	Base b;

	return 0;
}

对象中的这个指针我们叫做虚函数表指针(v代表virtual，f代表function)。一个含有虚函数的类中都至少都有一个虚函数表指针，因为虚函数的地址要被放到虚函数表中，虚函数表也简称虚表。

4.2 虚函数存在哪的？虚表存在哪的？

  1. 虚函数和普通函数一样，都存在代码段，同时把虚函数地址存了一份到虚函数表。
  2. VS编译器下，虚表存在代码段。

虚函数的地址一定会被放进类的虚函数表吗？是的

知识补充：堆、栈、静态区、代码段

内存区域作用存储内容生命周期特点
堆动态分配动态分配数据手动管理灵活但管理复杂，容易产生碎片
栈临时存储局部变量、函数参数、返回地址自动管理存取速度快，但空间有限
静态区持久存储全局变量、静态变量、常量字符串程序开始到结束内存占用固定，生命周期长
代码段存储代码编译后的机器指令程序开始到结束只读，通常是共享的
int main()
{
	static int a = 0;
	int b = 0;
	int* p1 = new int;
	const char* p2 = "hello world";

	printf("静态区：%p\n", &a);    // 静态区：0004C45C
	printf("栈：%p\n", &b);        // 栈：0053FAA4
	printf("堆：%p\n", &p1);       // 堆：0053FA98
	printf("代码段：%p\n", &p2);   // 代码段：0053FA8C

	return 0;
}

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

5.1 概念查考

  1. 下面哪种面向对象的方法可以让你变得富有( )
    A: 继承
    B: 封装
    C: 多态
    D: 抽象

  2. ( )是面向对象程序设计语言中的一种机制。这种机制实现了方法的定义与具体的对象无关，而对方法的调用则可以关联于具体的对象。
    A: 继承
    B: 模板
    C: 对象的自身引用
    D: 动态绑定

  3. 面向对象设计中的继承和组合，下面说法错误的是？（）
    A：继承允许我们覆盖重写父类的实现细节，父类的实现对于子类是可见的，是一种静态复用，也称为白盒复用
    B：组合的对象不需要关心各自的实现细节，之间的关系是在运行时候才确定的，是一种动态复用，也称为黑盒复用
    C：优先使用继承，而不是组合，是面向对象设计的第二原则
    D：继承可以使子类能自动继承父类的接口，但在设计模式中认为这是一种破坏了父类的封
    装性的表现

  4. 以下关于纯虚函数的说法,正确的是( )
    A：声明纯虚函数的类不能实例化对象
    B：声明纯虚函数的类是虚基类
    C：子类必须实现基类的纯虚函数
    D：纯虚函数必须是空函数

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

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

  1. 假设A类中有虚函数，B继承自A，B重写A中的虚函数，也没有定义任何虚函数，则（ ）
    A：A类对象的前4个字节存储虚表地址，B类对象前4个字节不是虚表地址
    B：A类对象和B类对象前4个字节存储的都是虚基表的地址
    C：A类对象和B类对象前4个字节存储的虚表地址相同
    D：A类和B类虚表中虚函数个数相同，但A类和B类使用的不是同一张虚表

  2. 下面程序输出结果是什么? （）
    提示：经典题目，virtual解决二义性和冗余的问题

#include<iostream>
using namespace std;

class A {
public:
	A(const char* s)
	{ 
		cout << s << endl;
	}

	~A() 
	{}
};

class B :virtual public A
{
public:
	B(const char* s1, const char* s2)
	:A(s1) 
	{ 
		cout << s2 << endl;
	}
};

class C :virtual public A
{
public:
	C(const char* s1, const char* s2)
	:A(s1) 
	{ 
		cout << s2 << endl;
	}
};

class D : public B, public C
{
public:
	D(const char* s1, const char* s2, const char* s3, const 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;
}

 //初始化列表的顺序是跟着声明的顺序走
 //类里面的初始化列表跟着继承的顺序走
 //谁先被继承，谁先初始化

A：class A class B class C class D
B：class D class B class C class A
C：class D class C class B class A
D：class A class C class B class D

  1. 多继承中指针偏移问题？下面说法正确的是( )
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

  1. 以下程序输出结果是什么（）
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();    //  B->1
	// p->func();   // 不构成多态，因为不是父类指针或者引用去调用，B->0

	return 0;
}

A: A->0
B: B->1
C: A->1
D: B->0
E: 编译出错
F: 以上都不正确

虚函数的重写：是重写函数的实现，继承父类的接口。

5.2 问答题

静态的多态：函数重载
动态的多态：首先，必须使用父类的指针或者引用去调用虚函数，其次，虚函数要完成重写。

  1. inline函数可以是虚函数吗？
    答：可以，不过编译器就忽略inline属性，这个函数就不再是inline，因为虚函数要放到虚函数表中去。

  2. 静态成员可以是虚函数吗？
    答：不能，因为静态成员函数没有this指针，使用类型::成员函数的调用方式无法访问虚函数表，所以静态成员函数无法放进虚函数表。

  3. 构造函数可以是虚函数吗？
    答：不能，因为对象中的虚函数表指针是在构造函数初始化列表阶段才初始化的。

  4. 析构函数可以是虚函数吗？什么场景下析构函数是虚函数？
    答：可以，并且最好把基类的析构函数定义成虚函数。

  5. 对象访问普通函数快还是虚函数更快？
    答：首先如果是普通对象，是一样快的。如果是指针对象或者是引用对象，则调用的普通函数快，因为构成多态，运行时调用虚函数需要到虚函数表中去查找。

  6. 虚函数表是在什么阶段生成的，存在哪的？
    答：虚函数表是在编译阶段就生成的，一般情况下存在代码段(常量区)的。

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

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值