C++ 面向对象三大特性——多态

已于 2024-02-19 10:59:07 修改
阅读量1.5k 收藏 42
点赞数 42
分类专栏： C++ 文章标签： c++ 开发语言
于 2023-08-18 21:02:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_63943454/article/details/132360192
版权

✅<1>主页：我的代码爱吃辣
📃<2>知识讲解：C++ 继承
☂️<3>开发环境：Visual Studio 2022
💬<4>前言：面向对象三大特性的，封装，继承，多态，今天我们研究研究C++的多态。

目录

一.多态的概念

二.多态的定义及实现

1.多态的构成条件

2. 虚函数

3.虚函数的重写

4. C++11 override 和 final

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

三. 抽象类

1.概念

2.接口继承和实现继承

四.多态的原理

1.虚函数表

2.多态的原理

3. 动态绑定与静态绑定

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

1. 单继承中的虚函数表

2. 多继承中的虚函数表 

一.多态的概念

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

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

再举个栗子： 几年前为了争夺在线支付市场，支付宝年底经常会做诱人的扫红包-支付-给奖励金的
活动。那么大家想想为什么有人扫的红包又大又新鲜8块、10块...，而有人扫的红包都是1毛，5
毛....。其实这背后也是一个多态行为。支付宝首先会分析你的账户数据，比如你是新用户、比如
你没有经常支付宝支付等等，那么你需要被鼓励使用支付宝，那么就你扫码金额 =random()%99；比如你经常使用支付宝支付或者支付宝账户中常年没钱，那么就不需要太鼓励你去使用支付宝，那么就你扫码金额 = random()%1；总结一下：同样是扫码动作，不同的用户扫得到的不一样的红包，这也是一种多态行为。ps：支付宝红包问题纯属瞎编，大家仅供娱乐。

C++中多态演示：

class Person
{
public:
	virtual void  buy_ticket()
	{
		cout << "这是一个成年人---->全价票" << endl;

	}
};

class Student :public Person
{
public:
	virtual void buy_ticket()
	{
		cout << "这是一个学生---->八折票" << endl;
	}
};


int main()
{
	//定义好成人对象和学生对象
	Person p;
	Student s;

	//在去买票之前他们是没有区别的
	Person& person1 = p;
	Person& person2 = s;

	//买票的学生和成人价格不一样
	person1.buy_ticket();
	person2.buy_ticket();
    
    return 0;
}

二.多态的定义及实现

1.多态的构成条件

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

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

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

 没有重写虚函数：

class Person{
public:
	 void  buy_ticket(){cout << "全价票" << endl;}
};

class Student :public Person{
public:
	 void buy_ticket(){cout << "八折票" << endl;}
};

int main()
{
	
	Person p;
	Student s;
	Person& person1 = p;
	Person& person2 = s;
	
	person1.buy_ticket();
	person2.buy_ticket();
	return 0;
}

 

 有虚函数重写，不是通过基类的指针或者引用调用：

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

class Student :public Person{
public:
	 virtual void buy_ticket(){cout << "八折票" << endl;}
};

int main()
{
	Person p;
	Student s;
	
	Person person1 = p;
	Person person2 = s;
	
	person1.buy_ticket();
	person2.buy_ticket();
	return 0;
}

2. 虚函数

虚函数：即被virtual修饰的类成员函数称为虚函数，虚函数就是为多态而出现的。

	//虚函数
    virtual void  buy_ticket()
	{
		cout << "这是一个成年人---->全价票" << endl;
	}

 3.虚函数的重写

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

注意：派生类虚函数与基类虚函数的返回值类型、函数名字、参数列表完全相同，这里要求非常严格，因为重写或者是覆盖，是函数体的重写或者覆盖。

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

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

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

int main()
{
	Person p1;
	Student p2;

	Func(p1);
	Func(p2);

	return 0;
}

虚函数重写的两个例外：

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

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

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

int main()
{
	Person p1;
	Student p2;

	Func(p1);
	Func(p2);

	return 0;
}

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

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

class Person {
public:
	virtual Person* BuyTicket() { cout << "买票-全价" << endl; return nullptr; }
	virtual ~Person() { cout << "~Person()" << endl; }
};
class Student : public Person {
public:
	//virtual void BuyTicket() { cout << "买票-半价" << endl; }
	virtual Student* BuyTicket() { cout << "买票-半价" << endl; return nullptr; }
	~Student() { cout << "~Student()" << endl; }
};

int main()
{
	Person* p = new Person;
	Person* s = new Student;

	delete p;
	delete s;

	return 0;
}

4. 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() {}
};
class Benz :public Car {
public:
	virtual void Drive() override { cout << "Benz-舒适" << endl; }
};

此时基类的函数并不是虚函数，所以派生类中函数没有构成重写，所以此处直接报错。

5. 重载、覆盖(重写)、隐藏(重定义)的对比💊💊💊

三. 抽象类

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;
	}
};
void Test()
{
	Car* pBenz = new Benz;
	pBenz->Drive();
	Car* pBMW = new BMW;
	pBMW->Drive();
}

int main()
{
	Test();
    return 0;
}

2.接口继承和实现继承

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

四.多态的原理

1.虚函数表

这里常考一道笔试题：sizeof(Base)是多少？

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

32位下结果：

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

 针对上面的代码我们做出以下改造：

  • 我们增加一个派生类Derive去继承Base
  • Base再增加一个虚函数Func2和一个普通函数Func3
  • Derive中重写Func1，Func2，定义一个虚函数Func3
class Base
{
public:
	virtual void Func1(){cout << "Base::Func1()" << endl;}
	virtual void Func2(){cout << "Base::Func2()" << endl;}
	virtual void Func3(){cout << "Base::Func3()" << endl;}
private:
	int _b = 1;
};
class Derive : public Base
{
public:
	virtual void Func1(){cout << "Derive::Func1()" << endl;}
	virtual void Func2(){cout << "Derive::Func2()" << endl;}
private:
	int _d = 2;
};

1.派生类对象d中也有一个虚表指针，d对象由两部分构成，一部分是父类继承下来的成员，虚
表指针也就是存在这部分的，另一部分是自己的成员。

2.基类b对象和派生类d对象虚表是不一样的，这里我们发现Func1，Func2完成了重写，所以d的虚表中存的是重写的Derive::Func1和Derive::Func2，所以虚函数的重写也叫作覆盖，覆盖就是指虚表中虚函数的覆盖。重写是语法的叫法，覆盖是原理层的叫法。

3.另外Func3继承下来后是虚函数，所以放进了虚表，如果Derive::Func3没有重写Derive::Func3不会被放进虚表，或者Base::Func3不是虚函数，不会Derive::Func3被重写也不会放进虚表。

4.虚函数表本质是一个存虚函数指针的指针数组，一般情况这个数组最后面放了一个nullptr（仅仅针对VS系类编译器）。

5.总结一下派生类的虚表生成：a.先将基类中的虚表内容拷贝一份到派生类虚表中 b.如果派生
类重写了基类中某个虚函数，用派生类自己的虚函数覆盖虚表中基类的虚函数 c.派生类自己
新增加的虚函数按其在派生类中的声明次序增加到派生类虚表的最后。

这里还有一个童鞋们很容易混淆的问题：虚函数存在哪的？虚表存在哪的？ 答：虚函数存在
虚表，虚表存在对象中。注意上面的回答的错的。但是很多童鞋都是这样深以为然的。注意
虚表存的是虚函数指针，不是虚函数，虚函数和普通函数一样的，都是存在代码段的，只是
他的指针又存到了虚表中。另外对象中存的不是虚表，存的是虚表指针。那么虚表存在哪的
呢？实际我们去验证一下会发现vs下是存在代码段的。

虚表的地址和代码区（常量区）很接近。

2.多态的原理

上面分析了这个半天了那么多态的原理到底是什么？还记得这里Func函数传Person调用的
Person::BuyTicket，传Student调用的是Student::BuyTicket。

1.观察下图的红色箭头我们看到，p是指向mike对象时，p->BuyTicket在mike的虚表中找到虚
函数是Person::BuyTicket。
2. 观察下图的蓝色箭头我们看到，p是指向johnson对象时，p->BuyTicket在johson的虚表中
找到虚函数是Student::BuyTicket。
3. 这样就实现出了不同对象去完成同一行为时，展现出不同的形态。
4. 反过来思考我们要达到多态，有两个条件，一个是虚函数覆盖，一个是对象的指针或引用调
用虚函数。反思一下为什么？因为单纯的使用对象直接接受，不会拷贝虚表。
5. 再通过下面的汇编代码分析，看出满足多态以后的函数调用，不是在编译时确定的，是运行
起来以后到对象的中取找的。不满足多态的函数调用时编译时确认好的。

void Func(Person* p)
{
	p->BuyTicket();
}
int main()
{
	Person mike;
	Func(&mike);
	mike.BuyTicket();

	return 0;
}
// 以下汇编代码中跟你这个问题不相关的都被去掉了
void Func(Person* p)
{
	    ...
		p->BuyTicket();
	    // p中存的是mike对象的指针，将p移动到eax中
	    001940DE  mov     eax, dword ptr[p]
		// [eax]就是取eax值指向的内容，这里相当于把mike对象头4个字节(虚表指针)移动到了edx
		001940E1  mov     edx, dword ptr[eax]
		// [edx]就是取edx值指向的内容，这里相当于把虚表中的头4字节存的虚函数指针移动到了eax
		00B823EE  mov     eax, dword ptr[edx]
		// call eax中存虚函数的指针。这里可以看出满足多态的调用，不是在编译时确定的，是运行起来
		以后到对象的中取找的。
		001940EA  call     eax
		00头1940EC  cmp     esi, esp
}
int main()
{
	    ...
		// 首先BuyTicket虽然是虚函数，但是mike是对象，不满足多态的条件，所以这里是普通函数的调
		用转换成地址时，是在编译时已经从符号表确认了函数的地址，直接call 地址
		mike.BuyTicket();
	    00195182  lea     ecx, [mike]
		00195185  call     Person::BuyTicket(01914F6h)
		...
}

3. 动态绑定与静态绑定

  1. 静态绑定又称为前期绑定(早绑定)，在程序编译期间确定了程序的行为，也称为静态多态，比如：函数重载。
  2. 动态绑定又称后期绑定(晚绑定)，是在程序运行期间，根据具体拿到的类型确定程序的具体行为，调用具体的函数，也称为动态多态。
  3. 本小节之前(5.2小节)买票的汇编代码很好的解释了什么是静态(编译器)绑定和动态(运行时)绑定。

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

1. 单继承中的虚函数表

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

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

这里大家仔细就会发现在派生类的虚表怎么没有Func4呢？这里是编译器的监视窗口故意隐藏了这
两个函数，也可以认为是他的一个小bug。那么我们如何查看d的虚表呢？下面我们使用代码打印
出虚表中的函数。

typedef void (*VFunc)();
void Print_VFTable(VFunc table[])
{
	int i = 0;
	//虚函数表本质是一个存虚函数指针的指针数组，
	//一般情况这个数组最后面放了一个nullptr（仅仅针对VS系类编译器）。
	while (table[i])
	{
		printf("[%d]:%p--->", i+1, table[i]);
		table[i]();
		i++;
	}
}
int main()
{
	Base b;
	Derive d;
    //取出Derive对象的前四个字节，强转成VFunc*，即函数二级指针类型
	Print_VFTable((VFunc*)(*((int*)(&d))));
	
	return 0;
}

 不难看出这里应证了我们的猜想，Derive::Func4()只是被监视窗口隐藏了。

2. 多继承中的虚函数表

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(*VFPTR) ();
void PrintVTable(VFPTR vTable[])
{
	cout << " 虚表地址>" << vTable << endl;
	for (int i = 0; vTable[i] != nullptr; ++i)
	{
		printf(" 第%d个虚函数地址 :0X%x,->", i, vTable[i]);
		VFPTR f = vTable[i];
		f();
	}
	cout << endl;
}
int main()
{
	Derive d;
	VFPTR* vTableb1 = (VFPTR*)(*(int*)&d);
	PrintVTable(vTableb1);
	VFPTR* vTableb2 = (VFPTR*)(*(int*)((char*)&d + sizeof(Base1)));
	PrintVTable(vTableb2);
	return 0;
}

注意一个现象：

 

b2->func1();

程序在执行这句的时候，汇编多次call，和jmp，说明编译器堆底层进行了了多次封装，其中封装的原因是：

 

 ecx 寄存器存储的是this指针，所以这次封装的并且sub - 8，是为了修正this指针。

我的代码爱吃辣
关注
  • 42
    点赞
  • 踩
  • 42
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 44
    评论
专栏目录
面向对象三大特性之一——多态详解
weixin_59371851的博客
07-23 1741
哈喽，小伙伴们大家好。上一章我们一起学习了继承，今天我们继续来学习面向对象三大特性中的最后一个特性——多态。事不宜迟，快拿起小本本，跟我一起开始吧。一、多态的概念多态，顾名思义，也就是多种状态。通俗点说就是不同的对象去干同一件事情时会产生不同的状态。以买火车票为例，普通人买票就要付全款，学生买票就可以出半价，军人虽然不能优惠但是可以优先买票。放到我们程序中就是不同继承关系的类对象去调用同一个函数，会产生不同的状态。在了解多态的构成条件前，我们先来了解一个概念，虚函数。在同一个作用域。......
c++面向对象之多态
qq_32328985的博客
03-18 318
多态的基本概念 多态是c++面向对象三大特性之一 多态分为两类： 静态多态：函数重载和运算符重载，复用函数名 动态多态：派生类和虚函数实现运行时多态 静态多态和动态多态区别： 静态多态的函数地址早绑定 - 编译阶段确定函数地址 动态多态的函数地址晚绑定 - 运行阶段确定函数地址 动态多态满足条件 有继承关系 子类重写父类的虚函数 函数重写的概念：函数返回值、函数名、函数的参数列表完全相...
C++面向对象三大特性之---多态
最新发布
m0_74910646的博客
05-07 838
多态是在不同继承关系的类对象，去调用同一函数，产生了不同的行为。比如Student继承了 Person。Person对象买票全价，Student对象买票半价。必须通过基类的指针或者引用调用虚函数被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写在虚函数的后面写上=0，则这个函数为纯虚函数。包含纯虚函数的类叫做抽象类（也叫接口类），抽象类不能实例化出对象。派生类继承后也不能实例化出对象，只有重写纯虚函数，派生类才能实例化出对象。
C++： 面向对象之多态
e.g.:
04-06 919
指向基类的指针 类继承的一个关键特性是，指向派生类的指针与指向基类的指针是类型兼容的。 多态是利用这个简单但功能强大且通用的特性的艺术。 // pointers to base class #include <iostream> using namespace std; class Polygon { protected: int width, height; public: void set_values (int a, int b) { width=a;
C++面向对象-多态
DannieG的博客
05-11 170
多态 同一名称，不同的功能实现方式。 多态的实现主要分为静态多态和动态多态，静态多态主要是重载，在编译的时候就已经确定；动态多态是用虚函数机制实现的，在运行期间动态绑定。虚函数是运行时多态的基础。 ​ ​ 多态就是不同继承类的对象，对同一消息做出不同的响应（函数重写，不同继承类的对象的函数实现不一样） ​ 多态是通过虚函数实现的，虚函数的地址保存在虚函数表中，虚函数表的地址保存在含有虚函数的类的实例对象的内存空间中，对象里存着对应虚函数表的地址。 ​ 基类的指针指向或绑定到派生类的对象，调
C++面向对象——多态
Wuhao9_的博客
04-14 883
多态分为两类： 静态多态: 函数重载 和 运算符重载 属于静态多态，复用函数名 动态多态: 派生类和虚函数实现运行时多态 静态多态和动态多态区别： 静态多态的函数地址早绑定 - 编译阶段确定函数地址 动态多态的函数地址晚绑定 - 运行阶段确定函数地址 多态的语法： 在类内成员函数前面加上virtual关键字，变成虚函数，那么编译器在编译的时候就不能确定函数调用了。 注意：写虚函数（非纯虚函数）时，一定要写函数内容，否则会出现 “无法解析外部符号“的错误！ 多态的前提条件： 两个类或多个存在继
c++ 面向对象 -- 多态
m0_37940804的博客
04-21 250
目录 多态基本概念 多态内部原理 多态的优点 纯虚函数和抽象类 虚析构和纯虚析构 多态基本概念 多态是c++面向对象三大特性之一 多态分为两类： a. 静态多态：函数重载和运算符重载属于静态多态，复用函数名 b. 动态多态：派生类和虚函数运行时的多态 静态多态和动态多态的区别： a. 静态多态的函数地址早绑定 --编译阶段确定函数地址 b.动态多态的函数地址晚绑定 --运行阶段确定函数地址 动态多态的满足条件： a.有继承关系 ...
面向对象三大特性_面向对象_
09-28
面向对象的三大特性是封装、继承和多态，它们是理解OOP的关键。 **封装** 是面向对象的基础，它意味着将数据（属性）和操作这些数据的方法（函数）绑定在同一个单元——对象中。这样可以隐藏对象内部的实现细节，只...
面向对象三大特性的意义讲解
08-26
面向对象编程是现代软件开发中广泛采用的一种编程范式，其核心特性包括封装、继承和多态。这些特性赋予了程序更高的灵活性、可维护性和可扩展性。 首先，我们来看看封装。封装是面向对象编程的基础，它将数据和操作...
Visual C++ 面向对象编程教程——王育坚
01-20
《Visual C++ 面向对象编程教程——王育坚》是一本专为学习MFC（Microsoft Foundation Classes）和面向对象编程技术而设计的教学资料。该教程以幻灯片的形式呈现，结合实例与详细的讲解，使得学习过程更为直观且易于...
cPP.rar_C++面向对象
09-21
在C++中，面向对象编程主要包括三大概念：封装、继承和多态。 **封装**是面向对象编程的基础，它指的是将数据和操作数据的方法绑定在一起，作为一个相互依赖的整体——对象。在C++中，我们通过定义类（class）来...
C++面向对象程序设计实验报告（计算器）
01-16
实验旨在深化对C++面向对象编程的理解，包括类的设计、对象的创建与使用、封装、继承、多态等核心概念。报告详细涵盖了从需求分析到代码实现的全过程，提供了70多页的详细内容，包括设计思路、算法描述、代码解释...
C++面向对象特性——多态
CLZHIT的博客
12-27 738
多态性（ polymorphism ）是面向对象设计语言的基本特征之一。仅仅是将数据和函数捆绑在一起，进行类的封装，使用一些简单的继承，还不能算是真正应用了面向对象的设计思想。多态性是面向对象的精髓。多态性可以简单地概括为“一个接口，多种方法”。通常是指对于同一个消息、同一种调用，在不同的场合，不同的情况下，执行不同的行为。虚函数就是在基类中被声明为virtual，并在一个或多个派生类中被重新定义的成员函数。// 类内部 class 类名 {virtual 返回类型 函数名(参数表) {
C++面向对象特性之多态
qq_44272681的博客
11-05 592
一种对象为了接口重用而呈现的多重形态 静态多态有模板重载，根据不同的参数调用函数体不同，这是在编译是就确定的 动态多态有父子类中的虚函数，父类的指针或者引用调用的虚函数如果进行了重写则会调用子类的虚函数，这是通过动态连联编运行时确定的静态绑定和动态绑定 绑定体现了函数调用和函数本身代码的关联，也就是产生调用时如何找到提供调用的方法入口： 静态绑定：程序编译过程中把函数调用与执行调用所需的代码相关联，这种绑定发生在编译期，程序未运行就已确定，也称为前期绑定。 动态绑定：执行期间判断所引用对象的实际类型来
C++特性之多态
薛家骏的博客
09-13 396
C++的三大特性：封装、继承、多态。其中封装可以使得代码模块化；继承可以扩展原有的代码；多态则是为了接口重用。且设计模式都是基于C++的多态为前提的。 概念： 多态 多态性是允许将父对象设置成为和一个或者更多的它的子对象相等的技术。赋值之后，父对象就可以根据当前赋值给他的子对象的特性以不同的方式运作。 简单说：就是允许子类类型的指针赋值给父类类型的指针（一种接口，根据子类对象的不同...
C++多态特性及原理
fjhugjkdsd的博客
08-03 207
多态是面向对象三大特性之一。它是指在同一操作作用于不同的对象时，可以有不同的解释，并产生不同的执行结果。多态提高了代码的维护性(继承保证)，提高了代码的扩展性(多态保证)。
C++面向对象（五）：多态
米之炼金术师的博客
05-23 114
C++面向对象（十二）：多态 文章目录C++面向对象（十二）：多态多态的要素父类指针、子类指针虚表虚析构函数纯虚函数 多态是面向对象非常重要的一个特性 同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果 在运行时，可以识别出真正的对象类型，调用对应子类中的函数 多态的要素 子类重写父类的成员函数（override） 父类指针指向子类对象 利用父类指针调用重写的成员函数 父类指针、子类指针 class Person { public: int m_age; }; class Stude
【C++自学笔记】详细解读——C++面向对象之多态
C/C++菜鸟养成记
08-18 262
一、多态的定义及实现 多态：通俗来说，就是多种形态，具体点就是完成某个行为，当不同的对象去完成时会产生出不同的状态； 1、多态的构成条件 多态是在不同继承关系的类对象，去调用同一个函数，产生了不同的行为。 在继承中构成多态还有两个条件： 必须通过基类的指针或者引用调用虚函数； 被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写。 2、虚函数(被关键字 virtual 修饰的类...
【C++】面向对象---多态(万字详解)
Lin5200000的博客
01-18 2613
C++多态详解，让你深入理解多态
c++面向对象程序设计完整ppt课件.ppt
11-16
"C++面向对象程序设计完整ppt课件" C++是一种强大的、支持面向对象编程的高级编程语言，它起源于C语言，并在其基础上添加了类和其他面向对象特性。本课件主要涵盖了C++编程的基础知识，旨在帮助学习者理解C++的基本...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 44
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

我的代码爱吃辣

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

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

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

打赏作者

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

抵扣说明：

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

余额充值