【C++】多态

风继续吹TT

已于 2022-05-19 21:16:39 修改

阅读量1.8k

点赞数 29

分类专栏： C++ 文章标签： c++ 开发语言后端多态

于 2022-04-13 10:41:02 首次发布

本文链接：https://blog.csdn.net/Edward_Asia/article/details/124141196

版权

C++ 专栏收录该内容

19 篇文章 13 订阅

订阅专栏

2.5.1 协变(基类与派生类虚函数返回值类型不同) (了解)

2.5.2 析构函数的重写(基类与派生类析构函数的名字不同)

2.6. 子类继承父类虚函数会继承虚函数的属性

2.7. final 和 override(C++11)

2.7.1 final

2.7.2 override

2.8. 重载、重定义(隐藏)、重写(重定义)对比

1. 什么是多态

我的理解是：不同的对象完成某个相同的行为，会产生不同的状态。

多态分为编译时多态和运行时多态。

编译时多态(静态)：例如函数重载，看起来是调用同一个函数，却有不同的行为

运行时多态(动态)：父类的指针或引用去调用函数，传递不同的对象，会调用不同的函数

例如：

去商场购物，有些商场根据以往消费情况将会员分为普通会员、黄金会员、钻石会员...不同的会员在消费时可以使用不同的折扣对商品打折。

2. 多态的定义

2.1. 多态构成条件

在继承中要构成多态的两个条件：

必须通过基类的指针或者引用调用虚函数

被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写

2.2. 虚函数

虚函数：即被virtual修饰的类成员函数称为虚函数(只能是类的非静态成员函数) 。

class ordinary_member
{
public:
	virtual void discount() // 虚函数
	{
		cout << "不打折" << endl;
	}
};

2.3. 虚函数的重写

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

例如：

class ordinary_member
{
public:
	virtual void discount()
	{
		cout << "不打折" << endl;
	}
};

class gold_member:public ordinary_member
{
public:
	virtual void discount() // 虚函数重写：函数名、返回值、参数列表完全相同(三同)
	{                     
		cout << "打八折" << endl;
	}
};

注意：这里子类中的discount函数不是重定义(隐藏)，而是重写。

2.4. 多态的使用

class ordinary_member
{
public:
	virtual void discount()
	{
		cout << "不打折" << endl;
	}
};

class gold_member:public ordinary_member
{
public:
	virtual void discount()
	{
		cout << "打八折" << endl;
	}
};

//构成多态，传的哪个类型的对象，就调用这个对象的虚函数(跟对象有关)
void test(ordinary_member& member)
{
	member.discount(); // 多态
}

// 不构成多态，只会调用member类型的函数(跟类型有关)
//void test(ordinary_member member) // 如果用父类的对象接受，不构成多态
//{                                 // 换言之，在这个函数中，只要不构成多态，discount函数只会调用父类的
//	member.discount();
//}

int main()
{
	ordinary_member o;
	gold_member g;

	test(o);f
	test(g); // test函数用父类对象的引用或指针接收，传子类对象会切片
	return 0;
}

2.5. 虚函数重写的两个例外

2.5.1 协变(基类与派生类虚函数返回值类型不同) (了解)

派生类重写基类虚函数时，与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指针或者引用，派生类虚函数返回派生类对象的指针或者引用时，称为协变。

class A
{
public:
	virtual A* fun()
	{
		return new A;
	}
};
class B:public A
{
public:
	virtual B* fun()
	{
		return new B;
	}
};

2.5.2 析构函数的重写(基类与派生类析构函数的名字不同)

如果基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加virtual关键字，都与基类的析构函数构成重写。

虽然函数名不相同，看起来违背了重写的规则，其实不是，这里可以理解为编译器对析构函数的名称做了特殊处理，编译后析构函数的名称统一处理成destructor。

比如：vector的析构函数

思考：为什么析构函数需要多态？

如果用将一个动态申请子类对象赋值给一个父类指针，那么调用析构函数时，应该调用谁的析构函数？

如果调用父类的析构函数，那么子类的成员不能被析构，所以这里析构函数应该存在多态，去调用子类的析构。

(普通对象会正确调用)

若析构函数不构成多态：

class ordinary_member
{
public:
	virtual void discount()
	{
		cout << "不打折" << endl;
	}

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

class gold_member :public ordinary_member
{
public:
	virtual void discount()
	{
		cout << "打八折" << endl;
	}

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

int main()
{
	
	ordinary_member* o1 = new ordinary_member;
	ordinary_member* o2 = new gold_member;
	delete o1;
	delete o2; // 调用父类析构函数
	return 0;
}

那么这里都会调用父类的析构函数，子类自己成员不会被析构！

如析构函数构成多态：

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

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

int main()
{
	ordinary_member* o1 = new ordinary_member;
	ordinary_member* o2 = new gold_member;
    // 析构 + operator delete()
	delete o1; // o1->destructor()
	delete o2; // o2->destructor() 析构时会调用子类的析构函数
	return 0;
}

o1指针指向父类，调用父类的析构函数；o2指针指向子类，调用子类的析构函数！

所以动态申请的子类对象赋值父类指针管理，需要析构函数是虚函数。

2.6. 子类继承父类虚函数会继承虚函数的属性

虚函数的重写允许父子类两个都是虚函数，或者父类是虚函数，满足重写就构成多态(建议都写)

也就是说子类在继承父类虚函数时会将虚函数的属性也继承下来，包括virtual、访问限定符

(子类重写的虚函数可以不加virtual本质是因为析构函数，防止项目中忘记加virtual导致内存泄漏；而因为析构函数本身特性，只要父类析构函数前加了virtual，就和子类析构函数构成重写)

class ordinary_member
{
public:
	virtual void discount()
	{
		cout << "不打折" << endl;
	}
};

class gold_member :public ordinary_member
{
private：// 子类访问限定符为私有，但这个虚函数构成多态，也能被外界访问(这里的private不能限制这个虚函数)
	void discount() // 不写virtual 也构成多态
	{
		cout << "打八折" << endl;
	}
};

void test(ordinary_member& member)
{
	member.discount(); // 子类私有成员构成多态时，可以在外面用多态调用该函数
}

int main()
{
	ordinary_member o;
	gold_member g;
	test(o);
	test(g);
	return 0;
}

2.7. final 和 override(C++11)

2.7.1 final

被final修饰的类，不能被继承

class A
{
private:
	A()    // 将父类的构造函数设为私有，子类无法调用父类的构造函数，就可以使父类不能被继承(间接限制)
		:_a(0)
	{}
protected:
	int _a;
};

class B :public A{};

class C final {}; // 类后面加了final，表示这个类不能被继承(直接限制)
class D:public C {};
int main()
{
	B b; // 编译报错
	return 0;
}

被final修饰的虚函数，不能被重写

class A
{
public:
	virtual void Print() final // final修饰虚函数，该虚函数不能被重写
	{
		cout << "A::Print()" << endl;
	}
};

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

2.7.2 override

检查派生类虚函数是否重写了基类某个虚函数，如果没有重写编译报错。（放在子类重写虚函数的后面）

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

class B:public A
{
public:
	virtual void Print() override // 虚函数没有完成重写，会编译报错
	{
		cout << "B::Print()" << endl;
	}
};

2.8. 重载、重定义(隐藏)、重写(重定义)对比

3.抽象类

3.1. 什么是抽象类

在虚函数的后面写上 =0 ，则这个函数为纯虚函数。

包含纯虚函数的类叫做抽象类（也叫接口类），抽象类不能实例化出对象。

派生类继承后也不能实例化出对象，只有重写纯虚函数，派生类才能实例化出对象。

纯虚函数规范了派生类必须重写，另外纯虚函数更体现出了接口继承。

例如：

class member // 抽象类,不能用这个类实例化出对象
{
public:
	virtual void discount() = 0; // 纯虚函数，只声明，不用实现因为实现了没用，不会调用父类的纯虚函数
};

class ordinary_member :public member
{
public:
	virtual void discount()
	{
		cout << "不打折" << endl;
	}
};

class gold_member :public member
{
public:
	virtual void discount()
	{
		cout << "打八折" << endl;
	}
};

class diamond_member :public member
{
	virtual void discount()
	{
		cout << "打六折" << endl;
	}
};

int main()
{
	member* gm = new gold_member;
	member* dm = new diamond_member;
	gm->discount();
	dm->discount();
    delete om;
    delete gm;
    delete dm;
	return 0;
}

3.2. 接口继承和实现继承

普通函数的继承是一种实现继承，派生类继承了基类函数，可以使用函数，继承的是函数的实现。

虚函数的继承是一种接口继承，派生类继承的是基类虚函数的接口，目的是为了重写，达成多态，继承的是接口。

所以如果不实现多态，不要把函数定义成虚函数。

例如上面的会员类，一个单纯的会员类是抽象的东西(必要区分会员类型)，因为不知道到底是普通会员还是黄金会员或者钻石会员，而每个会员所独有的折扣(特性)是必须要存在的，为了不让子类缺少这部分，子类就必须重写纯虚函数才能实例化出对象。

4. 多态原理(★)

4.1虚函数表

下面这个类的对象大小是多少？

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

private:
	int _a;
};

int main()
{
	A aa;
	cout << sizeof(aa) << endl;
	return 0;
}

在监视窗口中可以看到，aa对象中多了一个__vfptr成员，这其实是一个指向虚函数表的指针，而虚函数表是一个函数指针数组，里面放的是虚函数的地址。

再往下看：

class ordinary_member
{
public:
	virtual void discount()
	{
		cout << "不打折" << endl;
	}
protected:
	int _a;
};

class gold_member :public ordinary_member
{
public:
	virtual void discount() 
	{
		cout << "打八折" << endl;
	}
protected:
	int _b;
};

void consumption(ordinary_member* member)
{
	member->discount();
}

int main()
{
	ordinary_member om;
	gold_member gm;
	consumption(&om);
	consumption(&gm);
	return 0;
}

根据上面的代码，调用监视窗口查看，对象中的内容：

虚函数的地址都会被放进虚函数表中，不管有没有被重写！但编译器进行了处理，导致看不见。

同类型的虚表指针是一样的！(虚表在内存中只会被存一份)

	ordinary_member om1;
	ordinary_member om2;
	ordinary_member om3;

ps：在vs下一般认为虚函数表放在常量区。

4.2. 多态的实现原理

为什么需要使用父类的指针或引用才能调用多态？

例如上面这段代码，我们将consumption函数的参数改为父类的对象：

void consumption(ordinary_member member)
{
	member.discount();
}

int main()
{
	ordinary_member om;
	gold_member gm;
	consumption(om);
	consumption(gm);
	return 0;
}

我们会发现，无论是传父类对象还是子类对象，都会调用父类中的discount函数。

这是因为传子类对象过去后，父类对象member会对子类进行切片，而站在父类的角度它只会调用父类中的成员函数，不会调用子类。

也就是说子类传过去后，member对象会将子类中的父类成员进行拷贝，而__vfptr(虚表指针)不会被拷贝，还是会使用父类的虚表指针。因为父类中的虚表是不能被改变的，所以__vfptr也不能改变。(如果改变了，使用父类实例化对象时就会使用子类的虚表)

所以父类的对象调用重写函数不会形成多态！

再来看看传指针和引用的情况：

父类对象：

子类对象：

传指针或引用就可以构成多态，是因

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

为使用父类对象的指针或引用接收后，不会改变对象本身的性质，传父类就会使用父类的原地址或原空间，传子类就使用子类中继承父类的那部分成员(相当于这里的父类对象是子类中父类那一部分的别名)。(也就是说这里不会存在拷贝行为，还是在原对象的空间中操作)

多态的原理：基类的指针或引用，只指向谁就去谁的虚函数表中找对应位置的虚函数调用

4.3. 多态的静态与动态

静态绑定又称为前期绑定(早绑定)，在程序编译期间确定了程序的行为，也称为静态多态，比如：函数重载

动态绑定又称后期绑定(晚绑定)，是在程序运行期间，根据具体拿到的类型确定程序的具体行为，调用具体的函数，也称为动态多态

class ordinary_member
{
public:
	virtual void discount()
	{
		cout << "不打折" << endl;
	}
protected:
	int _a;
};

class gold_member :public ordinary_member
{
public:
	virtual void discount() 
	{
		cout << "打八折" << endl;
	}
	void fun()
	{
		cout << "gold_member::fun()" << endl;
	}
protected:
	int _b;
};
int main()
{

	gold_member *gm = new gold_member;
	gm->discount();
	gm->fun();
	return 0;
}

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

5.1. 单继承的虚函数表

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

	virtual void fun2()
	{
		cout << "A::fun2()" << endl;
	}
};

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

	virtual void fun4()
	{
		cout << "B::fun5()" << endl;
	}
};

int main()
{
	A a;
	B b;
	return 0;
}

观察下图中的监视窗口中发现看不见fun3和fun4。这里是前面说的，编译器的监视窗口故意隐藏了这两个函数。

通过查看内存，是可以知道他们的存在于虚函数表的：

5.2. 多继承的虚函数表(了解)

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

	virtual void fun2()
	{
		cout << "A::fun2()" << endl;
	}
};

class B 
{
public:
	virtual void fun3()
	{
		cout << "B::fun3()" << endl;
	}

	virtual void fun4()
	{
		cout << "b::fun4()" << endl;
	}
};

class C :public A, public B 
{
	virtual void fun1()
	{
		cout << "C::fun1()" << endl;
	}

	virtual void fun5()
	{
		cout << "C::fun5()" << endl;
	}
};
int main()
{
	C c;
	return 0;
}

多继承的子类中存在两张虚表，且子类中未重写的虚函数放在第一张虚表中。

6. 总结

1.什么是多态

不同类型的对象完成某个相同的行为，会产生不同的结果。

2.inline函数可以是虚函数吗？

可以

调用时，如果不构成多态，这个函数保持inline属性；如果构成多态，这个函数就没有inline属性，因为调用是到对象的虚函数表中找到虚函数地址，实现调用，无法使用inline属性

3.静态成员函数可以是虚函数吗？

不能

静态成员函数没有this指针，不能访问到虚函数表指针，而且可以通过 类型::静态成员函数 的方式调用，无法访问虚表

4.构造函数可以是虚函数吗？

不能

虚函数表指针是在初始化列表阶段初始化的，如果构造函数是虚函数，这时还没有虚函数表指针，访问不到虚函数表

5.析构函数可以是虚函数吗？

可以

出现这种情况时需要使析构函数是虚函数

Parent* ptr = new child;(动态申请的子类对象，用父类指针接收时)

6.对象访问普通函数快还是虚函数更快？

如果不构成多态，都是编译器确定调用函数的地址，一样快。

如果构成多态，虚函数调用实在运行时，去虚表中确定函数地址，普通函数编译时直接确定地址，普通函数更快。

7.以下程序输出结果是什么（）

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

风继续吹TT

关注

29
点赞
踩
23

收藏

觉得还不错? 一键收藏
打赏
12
评论
【C++】多态

1. 什么是多态我的理解是：不同的对象完成某个相同的行为，会产生不同的状态。多态分为编译时多态和运行时多态。编译时多态(静态)：例如函数重载，看起来是调用同一个函数，却有不同的行为运行时多态(动态)：父类的指针或引用去调用函数，传递不同的对象，会调用不同的函数例如：去商场购物，有些商场根据以往消费情况将会员分为普通会员、黄金会员、钻石会员...不同的会员在消费时可以使用不同的折扣对商品打折。2. 多态的定义2.1. 多态构成条件在继承中要构成多态的两个条件：
复制链接

扫一扫