C++多态

最新推荐文章于 2025-05-15 09:47:54 发布
最新推荐文章于 2025-05-15 09:47:54 发布
阅读量332 收藏 3
点赞数 1
CC 4.0 BY-SA版权
分类专栏： C/C++设计模式 C-C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/andrewgithub/article/details/108816281

多态

C/C++是静态编译语言。
在编译时，编译器自动根据指针的类型判断执行的是一个什么样的对象

  • 在编译此函数的时候，编译器可能不知道指针究竟指向了什么
  • 编译器没有理由报错
  • 于是，编译器认为安全的做法是编译到父类的print函数，因为父类和子类肯定都有相同的print函数
    如下：

#include <iostream>
using namespace std;

class Parent
{
public:
	Parent(int a)
	{
		this->a = a;
		cout<<"Parent a = "<<a<<endl;
	}

	void print() //子类的和父类的函数名字一样
	{
		cout<<"Parent print a ="<<a<<endl;
	}
protected:
private:
	int a ;
};

class Child : public Parent
{
public:
	Child(int b) : Parent(10)
	{
		this->b = b;
		cout<<"Child b"<<b<<endl;
	}
 void print() //virtual 父类写了virtual,子类可写 可不写 
	{
		cout<<"Child print  b:"<<b<<endl;
	}
protected:
private:
	int b;
};

void howToPrint(Parent *base)
{
	base->print(); //一种调用语句 有多种表现形态...
}

void howToPrint2(Parent &base)
{
	base.print();
}
int  main(int argc, char* argv[])
{
	
	Parent	*base = NULL;
	Parent	p1(20);
	Child	c1(30);

	cout << "===================" <<endl;
	base = &p1;
	base->print(); //执行父类的打印函数

	base = &c1;
	base->print(); //执行谁的函数 ?  //面向对象新需求
	cout << "===================" <<endl;

	{
		Parent &base2 = p1;
		base2.print();

		Parent &base3 = c1; //base3是c1 的别名
		base3.print();
	}


	//函数调用
	howToPrint(&p1);
	howToPrint(&c1);

	howToPrint2(p1);
	howToPrint2(c1);



	
	cout<<"hello..."<<endl;

	return 0;
}

事件执行结果


Parent a = 20
Parent a = 10
Child b30
===================
Parent print a =20
Parent print a =10
===================
Parent print a =20
Parent print a =10
Parent print a =20
Parent print a =10
Parent print a =20
Parent print a =10
hello...

从执行结果可以看出，无论指针指向子类对象还是执行父类对象，最终调用的print都是父类的函数

如果有以下需求：
如果父类指针指向父类，调用父类的print函数，指针指向子类，调用子类的print函数

编译器的做法不是我们期望的
根据实际的对象类型来判断重写函数的调用
如果父类指针指向的是父类对象则调用父类中定义的函数
如果父类指针指向的是子类对象则调用子类中定义的重写函数
在这里插入图片描述
解决方案
C++中通过virtual关键字对多态进行支持
使用viertual声明的函数被重写后就可展现多态特性

多态实例：


#include <iostream>
using namespace std;

class Parent
{
public:
	Parent(int a)
	{
		this->a = a;
		cout<<"Parent a = "<<a<<endl;
	}

	virtual void print() //子类的和父类的函数名字一样
	{
		cout<<"Parent print a ="<<a<<endl;
	}
protected:
private:
	int a ;
};

class Child : public Parent
{
public:
	Child(int b) : Parent(10)
	{
		this->b = b;
		cout<<"Child b"<<b<<endl;
	}
 	virtual void print() //virtual 父类写了virtual,子类可写 可不写 
	{
		cout<<"Child print  b:"<<b<<endl;
	}
protected:
private:
	int b;
};

void howToPrint(Parent *base)
{
	base->print(); //一种调用语句 有多种表现形态...
}

void howToPrint2(Parent &base)
{
	base.print();
}
int  main(int argc, char* argv[])
{
	
	Parent	*base = NULL;
	Parent	p1(20);
	Child	c1(30);

	cout << "===================" <<endl;
	base = &p1;
	base->print(); //执行父类的打印函数

	base = &c1;
	base->print(); //执行谁的函数 ?  //面向对象新需求
	cout << "===================" <<endl;

	{
		Parent &base2 = p1;
		base2.print();

		Parent &base3 = c1; //base3是c1 的别名
		base3.print();
	}


	//函数调用
	howToPrint(&p1);
	howToPrint(&c1);

	howToPrint2(p1);
	howToPrint2(c1);



	
	cout<<"hello..."<<endl;

	return 0;
}

执行结果：

Parent a = 20
Parent a = 10
Child b30
===================
Parent print a =20
Child print  b:30
===================
Parent print a =20
Child print  b:30
Parent print a =20
Child print  b:30
Parent print a =20
Child print  b:30
hello...

从执行结果来看，使用virtual关键字之后，父类指针执行子类对象就调用子类的函数，执行父类的对象就调用父类的函数。

封装
突破了C语言函数的概念
继承
代码复用，，，
多态
多态可以使用未来的代码

多态成立的三个条件：

  1. 要有继承
  2. 要有函数重写
  3. 要有父类指针（父类引用）指向子类对象

多态是设计模式的基础，多态是框架的基础

静态联编和动态联编

  1. 静态联编是指一个程序模块、代码之间互相关联的过程
  2. 静态联编(static binding)，是程序的匹配、连接在编译阶段实现，也称为早期匹配，重载函数使用静态联编
  3. 动态联编是指程序联编推迟到运行时进行，所以称为晚期联编(迟绑定)。switch语句和if语句就是动态联编的例子。
  4. 理论联系实际
  • C++与 C 相同，是静态编译型语言
  • 在编译时，编译器自动根据指针的类型判断指向的是一个什么样的对象；所以编译器认为父类指针指向的是父类对象。
  • 由于程序没有运行，所以不可能知道父类指针指向的具体是父类对象还是子类对象从程序安全的角度，编译器假设父类指针只指向父类对象，因此编译的结果为调用父类的成员函数。这种特性就是静态联编

对多态的理解

多态的实现效果
多态：同样的调用语句有多种不同的表现形态；
多态实现的三个条件
有继承、有 virtual 重写、有父类指针（引用）指向子类对象。
多态的 C++实现
virtual 关键字，告诉编译器这个函数要支持多态；不是根据指针类型判断如何调用；而
是要根据指针所指向的实际对象类型来判断如何调用
多态的理论基础
动态联编 PK 静态联编。根据实际的对象类型来判断重写函数的调用。
多态的重要意义
设计模式的基础 是框架的基石。
实现多态的理论基础
函数指针做函数参数
C 函数指针是 C++至高无上的荣耀。C 函数指针一般有两种用法（正、反）。
多态原理探究
与面试官展开讨论

重写、重载的理解

函数重载
必须在同一个类中进行
子类无法重载父类的函数，父类同名函数将被名称覆盖
重载是在编译期间根据参数类型和个数决定函数调用
函数重写
必须发生于父类与子类之间
并且父类与子类中的函数必须有完全相同的原型
使用 virtual 声明之后能够产生多态(如果不使用 virtual，那叫重定义)
多态是在运行期间根据具体对象的类型决定函数调用

问题：定义一个空的类型，里面没有任何的成员变量或者成员函数，对这个类型进行 sizeof 运算，结果是？

结果是1，因为空类型的实例不包含任何信息，按道理 sizeof 计算之后结果是0，但是在声明任何类型的实例的时候，必须在内存占有一定的空间，否则无法使用这些实例，至于占据多少内存大小，由编译器决定。

继续问：如果在这个类型里添加一个构造函数和析构函数，那么结果又是多少？

还是1，因为我们调用构造函数和析构函数，只需要知道函数的地址即可，而这些函数的地址只和类型相关，和类型的实例无关，编译器不会为这两个函数在实例内添加任何额外的信息。

继续问：如果把析构函数变为虚函数呢？结果是多少？

c++编译器发现了类型里有虚函数，，就会为这个类型生成一个虚函数表，并在该类型的每一个实例中添加一个指向虚函数表的指针，在32位机器，指针类型大小是4字节，结果是4，64位机器中，指针大小是8字节，结果是8。

C++多态实现原理

当类中声明虚函数时，编译器会在类中生成一个虚函数表
虚函数表是一个存储类成员函数指针的数据结构
虚函数表是由编译器自动生成与维护的
virtual 成员函数会被编译器放入虚函数表中
存在虚函数时，每个对象中都有一个指向虚函数表的指针(vptr 指针)

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
虚函数的效率要低很多。
说明 2：
出于效率考虑，没有必要将所有成员函数都声明为虚函数

证明VPTR函数的存在


#include <iostream>
using namespace std;

class Test
{
private:
	/* data */
public:
	Test
(/* args */);
	~Test
();
};

Test::Test(/* args */)
{
}

Test::~Test()
{
}


class Parent1
{
public:
	Parent1(int a=0)
	{
		this->a = a;
	}

	void print() 
	{
		cout<<"parent"<<endl;
	}
private:
	int a;
};

class Parent2
{
public:
	Parent2(int a=0)
	{
		this->a = a;
	}

	virtual void print()  
	{
		cout<<"parent"<<endl;
	}
private:
	int a;
};

int main(int argc, char*argv[])
{
	printf("sizeof(Parent):%zd sizeof(Parent2):%zd \n", sizeof(Parent1), sizeof(Parent2));
	cout<<"hello..."<<endl;
	cout << sizeof(Test) << endl;
	
	return 0;
}

函数输出：

sizeof(Parent):4 sizeof(Parent2):16 
hello...
1

可以看出，没有任何成员变量的类大小为1，有单个int成员变量的类大小为4，但是增加虚函数之后大小就变为了16

构造函数中能调用虚函数，实现多态吗

1）对象中的 VPTR 指针什么时候被初始化？
对象在创建的时,由编译器对 VPTR 指针进行初始化
只有当对象的构造完全结束后 VPTR 的指向才最终确定
父类对象的 VPTR 指向父类虚函数表
子类对象的 VPTR 指向子类虚函数表
在这里插入图片描述

参考：[C++编译器多态实现原理](https://www.cnblogs.com/kubixues
heng/p/4353907.html)

C++-多态性
可可西里
02-25 492
多态性是面向对象程序设计语言的又一重要特性，是指不同对象接收到同一消息时会产生不同的行为。继承处理的是类与类之间的层次关系，多态则是处理类的层次结构之间以及同一个类内部同名函数的关系。简单说，多态就是在同一个类或继承体系结构的基类与派生类中，用同名函数来实现不同的功能。1、静态绑定和动态绑定多态（Polymorphism）就是指不同对象收到相同消息时会执行不同的操作。也就是用一个相同名称定义许多不同
C++多态详解
lim6ere的博客
03-29 1255
我们知道C++语言的三大特性（封装，继承，多态）在之前的文章中我们已经学习了封装和继承，在这篇文章中我们将会学习到有关多态的相关问题。这两个关键字是c++11新增的🌟重载：同一作用域中，函数名相同，函数参数不同的函数🌟 重定义（隐藏）：父类和子类两个不同的作用域，只要父类和子类的函数名相同就可以。🌟重写（覆盖）：两个函数分别在子类和父类的作用域，两个函数必须是虚函数，这两个函数函数名，参数，返回值相同（有例外，特殊考虑）。🌟如果子类和父类中既满足重写又满足隐藏，重写优先。
《C++》13 C++ 多态
学编程找莫离，莫离老师更懂你！
03-30 613
C++ 多态多态按字面的意思就是多种形态。当类之间存在层次结构，并且类之间是通过继承关联时，就会用到多态。C++ 多态意味着调用成员函数时，会根据调用函数的对象的类型来执行不同的函数。下面的实例中，基类 Shape 被派生为两个类，如下所示：#include <iostream> using namespace std;class Shape { protected: int w
C++篇——多态
最新发布
aaaaa_shen的博客
05-15 1713
C++，多态
c++多态性
小Tian的博客
05-30 655
多态性包括:*重载--包含多态*强制--强制多态*虚函数--抽象多态*模板--参数多态*编译时多态:静态多态*运行时多态:动态多态一.虚函数虚函数是c++实现动态多态性的机制,通过虚函数可以使基类和派生类的同名函数具有不同的功能.函数的覆盖在派生类中可以对基类中的成员进行覆盖(重定义)注意在派生类中对虚函数进行重定义时,要保证名称,参数,返回值与基类的虚函数一致.举个栗子:class Elemen...
C++的多态性
卖火柴的小男孩
11-20 472
多态性多态性的定义：只允许不同类的对象对同一消息作出相应反应，即同一消息可以根据发送对象的不同而采用的行为方式。这里的发送消息就是函数调用。 多态性分为：编译期多态（静态多态）和运行时多态（动态动态）。编译时多态编译期多态，正如其名，就是在编译期确定的一种多态性。这个在C++中主要体现在函数模板，这里需要注意的是函数重载和多态无关。// 例1：函数模板体现出编译期多态 #include <io
C++多态Demo
05-01
这个“C++多态Demo”示例中，我们看到长方形和三角形作为形状（Shape）类的派生类，体现了面向对象编程中的继承和多态概念。 首先，让我们来理解一下基础的面向对象概念： 1. **类（Class）**: 类是创建对象的蓝图...
【C++】一文看懂 C++ 多态：动态与静态多态的全面剖析
2403_86785171的博客
08-27 1757
多态来源于希腊语，意为“多种形态”。在编程中，多态性指的是在相同的接口下，不同的数据类型可以表现出不同的行为。编译时多态和运行时多态。编译时多态通过函数重载和运算符重载实现，允许在编译阶段确定具体的函数调用。运行时多态通过虚函数和继承实现，允许在运行时根据对象的实际类型确定具体的函数调用。多态性极大地提高了代码的灵活性和可维护性，是面向对象编程中不可或缺的组成部分。
C++多态：静态多态vs动态多态
ye_yumo的博客
02-12 923
多态（Polymorphism）作为面向对象编程的三大核心特性之一，是构建灵活、可扩展软件系统的关键所在。在C++中，多态的实现主要分为静态多态（Static Polymorphism）和动态多态（Dynamic Polymorphism）两种形式，它们以不同的方式实现了"一个接口，多种实现"的核心思想。在这一篇博客里我有详细介绍（
C++多态性
qq_45297613的博客
01-10 513
c++多态性包含运行时多态和编译时多态。函数重载、函数重写、模板、虚函数使c++具备多态性。
c++的多态性
qu1993的博客
03-05 210
OOP的核心思想是多态性（polymorphism）。多态性这个词源自希腊语，其含义是“多种形式”。我们把具有继承关系的多个类型称为多态类型，因为我们能使用这些类型的“多种形式”而无须在意他们的差异。引用或指针的静态类型与动态类型不同这一事实正是C++语言支持多态性的根本所在。 当我们使用基类的引用或指针调用基类中定义的一个函数时，我们并不知道该函数真正作用的对象是什么类型，因为它可能是一个基类...
c++多态
03-08
C++多态允许通过基类接口来操作派生类对象，使得程序具有更大的灵活性和扩展性。下面给出两个示例以展示这种特性： 利用`virtual`关键字声明虚函数支持动态绑定[^2] ```cpp #include using namespace std; class...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Achilles.Wang

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值