C++基础梳理 2019.1.15（开闭原则，什么是多态，动态联编和静态联编，重写，编译器如何找函数地址的原理，抽象类和纯虚函数，虚析构和纯虚析构，向上类型转换向下类型转换）

最新推荐文章于 2022-07-11 10:36:25 发布
最新推荐文章于 2022-07-11 10:36:25 发布
阅读量265 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_29996285/article/details/86487576
版权

多态

 

什么是多态？

父类的引用或者指针指向子类对象。

 

C++支持编译时多态（静态多态——即运算符重载和函数重载）和运行时多态（动态多态——即派生类和虚函数）。

静态多态和动态多态的区别

函数地址是早绑定（静态联编）还是晚绑定（动态联编）。

  • 如果函数的调用，在编译节点就可以确定函数的调用地址，并产生代码，就是静态多态（编译时多态），就说地址是早绑定的；
  • 如果函数的调用地址不能编译不能在编译期确定，而需要在运行时才能决定，这就属于晚绑定（动态多态，运行时多态）。

 

静态联编的例子

下面代码中cat继承自animal类，对于函数doSpeak，他声明的参数是animal类型，因此调用doSpeak的时候，即使你传入的参数是cat类型，运行结果也是调用animal类型的speak函数

#include<iostream>
using namespace std;

class Animal {
public:
	void speak() {
		cout << "动物在说话" << endl;
	}
};

class Cat :public Animal {
public:
	void speak() {
		cout << "小猫在说话" << endl;
	}
};

void doSpeak(Animal & animal) //Animal & animal = cat
{
    animal.speak();
}

void test01() {
	Cat cat;
	//如果发生了继承的关系，编译器允许进行类型转换
	//因此函数doSpeak里面的参数要求是Animal类型，传入子类cat类型也不会报错
	doSpeak(cat);
}

原因：

上述代码中，调用doSpeak的时候，会在编译阶段找参数的类型，因此调用的是animal类型的speak。speak函数的地址在编译时期就已经绑定好了——早绑定——静态联编。

如果想调用cat类型的speak，那就需要进行晚绑定，即在运行时确定函数地址，即动态联编

 

动态联编（讲到了重写的概念）

写法——将speak改成虚函数

class Animal {
public:
	virtual void speak() {
		cout << "动物在说话" << endl;
	}

};

修改后的运行结果

 

此时我们看一下animal的大小，执行以下程序获得类animal的大小为4

#include<iostream>
using namespace std;

class Animal {
public:
	virtual void speak() {
		cout << "动物在说话" << endl;
	}
};

class Cat :public Animal {
public:
	void speak() {
		cout << "小猫在说话" << endl;
	}
};

void test02(){
	cout << sizeof(Animal) << endl;
}

原因：

animal内部的结构中有一个指针vfptr（虚函数指针 virtual function pointer），该指针指向了一张虚函数表中的animal::speak的地址。表中结构如下：

 

对于类cat，如果是如下写法：

class Animal {
public:
	virtual void speak() {
		cout << "动物在说话" << endl;
	}
};

class Cat :public Animal {
public:
	
};

则此时cat类的内部结构如下：

首先cat类会把animal类的vfptr指针继承下来，还会把父类的虚函数表继承下来。调用构造函数时，将所有虚函数表指针都指向自己的虚函数表，这个操作我们是看不到的

 

将speak函数写回cat中

class Cat :public Animal {
public:
	void speak() {
		cout << "小猫在说话" << endl;
	}
};

则cat会用这句的speak覆盖掉存储在自己虚表中的父类的speak函数（父类的speak还在）。子类重新写父类中的虚函数speak——重写。重写的返回值、参数个数、类型、参数顺序都相同。

重写并不会改变父类中的东西，只是把子类的虚表中的存有的父类的东西进行了覆盖。

此时cat的内部结构如下：

则此时运行如下代码时，发生了多态，使得父类指针指向子类，调用的是cat里面的speak函数

Animal *animal = new Cat;
animal->speak();

那么父类指针指向子类是怎么实现的？（下面讲解通过函数指针调用cat里面的speak函数）

1、Animal *animal  是一个父类指针，找到了地址指向图中箭头所指的位置。

找到地址之后，做了一个类型的强制转换，以此来设置步长

(int*)animal

之后对改地址进行取 * 操作，从而找到了自己的虚函数表。虚函数表内部也是一个数组，数组的类型也是int*，因此代码变为：

(int)*(int*)animal

对于上侧代码再一次进行取 * 操作即可获得函数地址

*(int)*(int*)animal

由于函数指针可以指向函数的地址，因此可得如下函数指针

((void(*)()) (*(int)*(int*)animal))()//后面跟着的()起调用函数的作用

因此，这两句的作用是相同的。

animal->speak();

((void(*)()) (*(int*)*(int*)animal))();

 

 

练习，如下代码，调用cat类里面的eat函数

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

class Animal {
public:
	virtual void speak() {
		cout << "动物在说话" << endl;
	}

	virtual void eat() {
		cout << "动物在吃饭" << endl;
	}
};

class Cat :public Animal {
public:
	void speak() {
		cout << "小猫在说话" << endl;
	}

	virtual void eat() {
		cout << "小猫在吃鱼" << endl;
	}
};

void test02(){

	//父类指针指向子类对象 多态
	Animal * animal = new Cat;

	//animal->speak();
	// *(int*)*(int*)animal 函数地址
	//((void(*)()) (*(int*)*(int*)animal))();

	//  *((int*)*(int*)animal+1)猫吃鱼的地址

	//((void(*)()) (*((int*)*(int*)animal + 1)))();
}

int main() {
	test02();

	system("pause");
	return EXIT_SUCCESS;
}

 

上侧已经找到了cat的speak的地址

(int*)*(int*)animal

将该指针+1，再对整体取地址，则找到了eat的地址

*((int*)*(int*)animal+1)

通过函数指针即可调用cat类的eat函数

((void(*)()) (*((int*)*(int*)animal + 1)))();

 

 

做一个计算器

 

第一版——每次有新功能，都要修改类中的代码，难以维护和扩展

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

class Calculator{
public:

	void setv1(int v){
		this->val1 = v;
	}

	void setv2(int v){
		this->val2 = v;
	}


	int getResult(string oper){
		if (oper == "+"){
			return val1 + val2;
		}
		else if (oper == "-"){
			return val1 - val2;
		}
	}
private:
	int val1;
	int val2;
};

void test01(){
	Calculator cal;
	cal.setv1(10);
	cal.setv2(10);
	cout << cal.getResult("+") << endl;
	cout << cal.getResult("-") << endl;
}

 

开闭原则

对扩展开放，对修改关闭。

 

第二版——利用多态

//利用多态实现计算器
class abstractCalculator {
public:

	virtual int getResult() { return 0; };

	void setv1(int v) {
		this->val1 = v;
	}

	void setv2(int v) {
		this->val2 = v;
	}

public:
	int val1;
	int val2;
};

//加法计算器
class PlusCalculator :public abstractCalculator{
public:
	virtual int getResult() {
		return val1 + val2;
	};
};

class SubCalculator : public abstractCalculator {
public:
	virtual int getResult() {
		return val1 - val2;
	};
};

class ChengCalculator :public abstractCalculator {
public:
	virtual int getResult() {
		return val1 * val2;
	};

};

void test02() {
	abstractCalculator * abc;
	//加法计算器
	abc = new PlusCalculator;

	abc->setv1(10);
	abc->setv2(20);

	cout << abc->getResult() << endl;

	delete abc;

	abc = new SubCalculator;
	abc->setv1(10);
	abc->setv2(20);
	cout << abc->getResult() << endl;

	delete abc;

	abc = new ChengCalculator;
	abc->setv1(10);
	abc->setv2(20);
	cout << abc->getResult() << endl;

}

 

 

 

抽象类和纯虚函数

上面例子中，父类的这个return 0 ，没有任何意义

virtual int getResult() { return 0; };

因此可以改一下

virtual int getResult()  = 0;

改完这一句之后，两种代码的运行结果是一样的，那么他改变了什么？

  • 如果父类中有了纯虚函数，那么子类继承父类就必须实现所有的纯虚函数，否则子类也是抽象类。
  • 如果子类中有了纯虚函数，那么父类就无法实例化对象了。
  • 一个类有了纯虚函数，则这个类叫抽象类——抽象类无法实例化对象
  • 纯虚函数不需要做实现，但是在虚表中会为其保留一个位置，但是这个位置不放地址。

 

 

 

虚析构和纯虚析构

 

虚析构

 

观察下面代码

#include "pch.h"
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

class Animal
{
public:

	virtual void speak()
	{
		cout << "动物在说话" << endl;
	}

	 ~Animal();
};

class Cat :public Animal
{
public:
	Cat(const char * name)
	{
		this->m_Name = new char[strlen(name) + 1];
		strcpy(this->m_Name, name);
	}

	virtual void speak()
	{
		cout << "小猫在说话" << endl;
	}

	~Cat()
	{
		cout << "Cat的析构调用" << endl;
		if (this->m_Name != NULL)
		{
			delete[] this->m_Name;
			this->m_Name = NULL;
		}
	}

	char * m_Name;

};


void test01()
{
	Animal * animal = new Cat("TOM");
	animal->speak();

	delete animal;

}


int main() {

	test01();

	system("pause");
	return EXIT_SUCCESS;
}

小猫的析构函数并没有被调用。因为普通的析构不会调用子类的析构函数。

原因：

基类指针指向了派生类对象，而基类中的析构函数却是非virtual的，之前讲过，虚函数是动态绑定的基础。现在析构函数不是virtual的，因此不会发生动态绑定，而是静态绑定，指针的静态类型为基类指针，因此在delete时候只会调用基类的析构函数，而不会调用派生类的析构函数。

因此需要将析构函数改写成虚析构函数。

#include "pch.h"
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

class Animal
{
public:

	virtual void speak()
	{
		cout << "动物在说话" << endl;
	}

	//普通析构 是不会调用子类的析构的，所以可能会导致释放不干净
	//利用虚析构来解决这个问题
	virtual ~Animal()
	{
		cout << "Animal的析构调用" << endl;
	}

};


class Cat :public Animal
{
public:
	Cat(const char * name)
	{
		this->m_Name = new char[strlen(name) + 1];
		strcpy(this->m_Name, name);
	}

	virtual void speak()
	{
		cout << "小猫在说话" << endl;
	}

	~Cat()
	{
		cout << "Cat的析构调用" << endl;
		if (this->m_Name != NULL)
		{
			delete[] this->m_Name;
			this->m_Name = NULL;
		}
	}

	char * m_Name;

};


void test01()
{
	Animal * animal = new Cat("TOM");
	animal->speak();

	delete animal;

}


int main() {

	test01();

	system("pause");
	return EXIT_SUCCESS;
}

 

 

纯虚析构

virtual ~Animal() = 0;
  • 纯虚析构 ，需要声明 还需要实现 类内声明，类外实现
  • 如果函数中出现了 纯虚析构函数，那么这个类也算抽象类
  • 抽象类 不可实例化对象

 

虚析构不影响实例化，纯虚析构不可实例化。

 

 

 

向上类型转换向下类型转换

 

没有多态的情况下

下面的代码就不安全（animal是cat的父类）：

new Animal，申请的空间如下图中左侧，cat类型的指针寻址能力如下图中的右侧：

因此上侧的指针类型转换是不安全的。所谓的安全不安全指的是指针的寻址范围。

new一个animal指针，其寻址范围就是animal类的区域。如果强转成cat类，cat类的范围会更大，容易操作到不是自己的内容。

 

总结：

  • 基类转派生类不安全——向下转换——指针寻址范围会超过申请的空间
  • 派生类转基类安全——向上转换——指针寻址范围不会超过申请的空间

 

 

发生多态的情况

如果发生多态，就总是安全的。

对于下侧代码：

Animal *animal = new Cat;
Cat *cat = (Cat*)animal;

我们 new 了一个cat那么大的空间，而指针的寻址范围是animal那么大的，因此指针不会操作不属于自己的空间，因此是安全的。

哪怕把animal指针强转成cat类型，我们申请的空间就已经有cat那么大了，因此不用担心指针操作不属于自己的空间。

王小闹儿
关注
专栏目录
C++中的静态联编和动态联编详解
程序猿老樊的博客
11-30 578
1.什么是联编？ 联编是指一个计算机程序自身彼此关联的过程,在这个联编过程中,需要确定程序中的操作调用(函数调用)与执行该操作(函数)的代码段之间的映射关系;按照联编所进行的阶段不同,可分为静态联编和动态联编。 例如A类中有fun这个函数， B类中也有fun这个函数，现在我在类外的main函数里面调用fun 函数。那么main函数就是函数调用，调用fun函数，而A...
14.C++ 多态——虚函数，多态的实现方式重载（静态多态），重写（动态多态）和重定义，一个函数能否成为虚函数
strive for the best 的博客
09-13 1060
引入 当类之间存在层次结构，并且类之间是通过继承关联时，就会用到多态。 先看一个示例： 下面的实例中，基类 Shape 被派生为两个类，如下所示： #include <iostream> using namespace std; class Shape { protected: int width, height; public: Shape( int a=0, int b=0) { width = a; h
c与c++中一些类型的转化总结（持续更新）
No detail can be too detailed
07-10 899
一般写小代码时，常常是c和c++不分的，但是有时会遇到类型转换的问题，比如输入 string ，然而处理函数的参数是char*型，之间需要转换。收集一下网上资料，总结一下。因为还没有时间去研究stl源码，暂时先用着吧。 一、string转char* 1、std::string::c_str Returns a pointer to an array that contains a null-t
C++多态的基本语法与原理剖析
m0_51955470的博客
01-27 195
多态分为两类 1.静态多态：函数重载和运算符重载属于静态多态，复用函数名 2.动态多态：派生类和虚函数实现运行时多态 静态多态和动态多态区别： 1.静态多态的函数地址早绑定，编译阶段确定函数地址 2.多态多态的函数地址晚绑定，运行阶段确定函数地址 首先让我们看这段代码： #include <iostream> using namespace std; class Animal { public: void speak() { cout << "动物在说话" <&l
C++多态：静态多态（函数地址早绑定），动态多态（函数地址晚绑定）虚函数表，虚析构函数重写。
qq_51004011的博客
07-11 1884
只要类中存在修函数或纯虚函数，那么类内就会自动生成一个虚函数表指针，指向一张虚函数表，在这个虚函数表中，存放着类内所有虚函数的地址。当这个类被它的子类继承时，子类也会继承这个虚函数表指针，与虚函数表，（注意两张虚函数表不是同一张表，可以理解为复制了一张虚函数表交给子类的虚函数标配指针。） 现在只要子类中对父类的虚函数和纯虚函数进行函数重写，那么子类中重写后的函数地址就会将原来的函数地址覆盖掉。这样就实现了动态的多态。.........
C++动态多态之动态绑定机制的细节分析
liuyf_666的博客
05-14 642
C++动态多态之动态绑定机制的细节分析前言正文总结 前言 最近在研究关于多态特性的知识，众所周知，动态绑定（或称动态联编）(•́⌄•́๑)૭✧是动态多态的实现基础，而实现动态绑定的重要基础是虚函数，正是有了动态绑定机制，使得基类指针作为一个接口同时能调用派生类和基类中的函数，即所谓的一个接口，多种实现，本文不会全面讲述动态多态的实现细节，而是着重于分析动态绑定的底层机制，如有不妥之处，欢迎指正。 ...
C++的静态联编和动态联编
09-02
根据联编的时间点，可以分为静态联编和动态联编。 静态联编，也称为早期联编，发生在程序的编译和链接阶段。在编译期间，编译器就能确定函数调用的具体实现，从而建立起调用与实现之间的直接关联。这意味着，当一个...
动态联编和静态联编、以及多态
A_ns_wer_的博客
03-12 2079
动态联编和静态联编 动态联编和静态联编的存在是为了支持C++的多态性。 静态联编：编译器在编译期就把对象与其在申明时采用的类型绑定起来，就确定函数的调用地址 class A { } class B:public A { } class D:public A { } void test() { D* d=new D;//静态联编会把d绑定在D*类型上，因为D*是d的声明类型 B* b=d;//静态联编会把b绑定在B*类型上 } 动态联编：编译器在运行期才把对象与其最后一个指向的类型
详解C++ 多态的两种形式（静态、动态）
09-07
总之，C++的多态性提供了强大的设计工具，静态多态通过编译期的决策提供效率和灵活性，而动态多态则通过运行时的动态绑定实现更高级别的抽象和代码复用。理解并熟练运用这两种多态形式，对于编写高效、可维护的C++...
深入理解向上和向下造型
Aboutdream的博客
03-28 4928
向上造型：父类引用指向子类对象向下造型：子类引用指向父类对象public class test { public static void main(String[] args) { Aoo aoo=new Boo();//向上造型自动类型转换 Boo o1=(Boo)aoo;//引用aoo所指向的对象，强转为Boo类型 Inter1 o2=o1;//引用o1所指向的对象 if(a...
27．编写一个Animal类，具有属性：种类；具有功能：吃、睡。定义其子类Fish 和Dog，定义主类E，在其main方法中分别创建其对象并测试对象的特性。...
热门推荐
weixin_30851867的博客
09-22 1万+
///Animal类 package d922A; public class Animal { private String kind; public String getKind() { System.out.println(kind); return kind; } public void setKind(String kind) { this.kin...
C++ 从函数或方法返回动态内存(函数指针与指针函数)
Chroniccandy的博客
10-17 1295
动态内存的另一个常见用途是让函数申请并返回一个指向内存块的指针,也就是从函数返回内存(掌握这个机器是很重要的,尤其是当你打算使用由别人编写的库文件的时候)。如果不知道这个技巧,就只能让函数返回一个简单的标量值,如整型,浮点型或字符型。换句话说,它既不能返回一个以上的值,也不能返回数组值之类比较复杂的数据结构。 ...
C++入门学习：多态的概念及其原理
Fizz_沫烨的博客
03-21 164
多态的目标：一种调用语句有多种不同的表现形态根据实际的对象类型来判断重写函数的调用如果父类指针指向的是父类对象则调用父类中定义的函数如果父类指针指向的是子类对象则调用子类中定义的重写函数实现的手段：通过虚函数来实现（下面会具体介绍）虚函数：在函数声明的没钱加virtual 关键字，该函数就变为虚函数。（内联函数、静态函数、构造函数不能是虚函数）多态实现的条件：1、要有继承2、要有虚函数重写3、用基...
强制类型转换(int)、(int&)和(int*)的区别
明天你好
11-09 3776
(int)x 强制类型转换，是将浮点数x为参数构造整数（即float转换为int） (int &amp;)y 则是告诉编译器将y看成int对待（内存里的数据不做任何转换),所以(int &amp;)x值为1071 644 672。 至于(int*)的话，我就不多说啦，就是强制转换成整型指针，一般人们容易混淆的是(int)和(int&amp;)这两个。 补充：浮点数0.0是比较特殊的，它并不按照...
C++学习笔记（十四）多态原理与虚函数
ArrowYL的博客
03-23 262
构造的顺序：沿着类的继承路径网上最顶层的父类，从最顶层的父类依次往下开始构造析构的顺序：从当前类开始沿着类的继承路径网上查找父类，依次析构，直到最顶层父类为止#include &lt;iostream&gt;using namespace std;class Animal{public: virtual void eat() { cout &lt;&lt; "动物吃饭" &lt;&lt; end...
虚析构函数的实现原理
fruit的博客
10-14 5211
虚析构函数的理论前提是执行完子类的析构函数，那么父类的虚构函数必然会被执行。那么当用delete释放一个父类指针所实例化的子类对象时，如果没有定义析构函数，那么将只会调用父类的析构函数，而不会调用子类的虚构函数，导致内存的泄漏。Class Shape { public: virtual Shape(); ~Shape(); private: int m_ir; };Class
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值