C++17 --- 多态性、虚函数、多态的条件、联编（捆绑，绑定）

已于 2023-03-01 21:09:15 修改
阅读量769 收藏 1
点赞数 1
分类专栏： C++学习笔记 笔记 文章标签： c++ 开发语言
于 2022-11-25 17:44:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kyrie_sakura/article/details/128005951
版权
本文深入探讨了面向对象编程中的多态性，包括编译时和运行时多态的区别，以及如何通过虚函数实现运行时的多态。文章还详细解释了虚函数的工作原理，如虚表、虚指针和动态联编，展示了不同类层次中虚函数的调用机制，并讨论了多继承情况下虚函数的内存布局。最后，阐述了多态的条件以及静态联编和动态联编的概念。
摘要由CSDN通过智能技术生成

一、多态性

1、多态

多态性是面向对象程序设计的关键技术之一。 若程序设计语言不支持多态性，不能称为面向对象的语言。

多态性(polymorphism) 多态性是考虑在不同层次的类中，以及在同一类中，同名的成员函数之间的关系问题。

函数的重载，运算符的重载，属于编译时的多态性。

以类的虚成员函数为基础的运行时的多态性，是面向对象程序设计的标志性特征。体现了 类推和比喻的思想方法。

多态的四种形态：

重载多态 -- 函数重载、运算符重载
包含多态 -- virtual 函数
参数多态 -- 模板
强制多态 -- 强制类型装换：static_cast , const_cast ,....

2、编译时的多态和运行时的多态

在这里插入图片描述

3、编译时多态，早期绑定

int max(int a,int b){ return a > b ? a : b;}

char Max(char a,char b){ return a > b ? a : b;}

double Max(double a，double b) { return a > b ? a : b; }

int main()
{
	int x = Max(12, 23) ;
	char ch = Max('c', 'b');
	double dx = Max(12.23， 34.45);
	return 0 ;
}

机器代码，编译链接时的函数名称：
在这里插入图片描述

4、运行时的多态

1）运行时多态的设计思想：

对于相关的类型，确定它们之间的一些共同特征，(属性和方法) , 将共同特征被转移到基类中，然后在基类中，把这些共同的函数或方法声明为公有的虚函数接口。然后使用派生类继承基类，并且在派生类中重写这些虚函数，以完成具体的功能。这种设计使得共性很清楚，避免了代码重复，将来容易增强功能，并易于长期维护。

客户端的代码(操作函数)通过基类的弓|用或指针来指向这些派生类型对象，对虚函数的调用会自动绑定到派生类对象上重写的虚函数。

2）虚函数的定义:

虚函数是一个类的成员函数，定义格式如下:

virtual 返回类型 函数名(参数表) ;

关键字 virtual 指明该成员函数为虚函数。只能将类的成员函数定义为虚函数。当某一个类的成员函数被定义为虚函数，则由该类派生出来的所有派生类中，该函数始终保持虚函数的特征。

3）示例:运行时的多态性，晚绑定。

4）总结：

运行时的多态：共有继承 + 虚函数 + （指针或引用调用虚函数）。

二、虚函数

1、虚表

如果一个类包含了虚函数，不管有多少个虚函数，则增加了一个指针的大小。
有了一个虚指针 – VPtr ，vptr 指向一个虚表（vtable）,虚表里面存储本类中虚函数的入口地址。

对于代码：

class A
{
public:
	virtual void fa(){cout << "A::fa" << endl;}
	virtual void fb(){cout << "A::fb" << endl;}
	virtual void fc(){cout << "A::fc" << endl;}
};

void main()
{
	A a;
}

在这里插入图片描述
在这里插入图片描述

2、虚表的大小

不论有多少个虚函数，只要有，就多一个指针的大小。

示例代码：

class A
{
public:
};

class B
{
public:
	void ffn(){}
};

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

class C2
{
public:
	virtual void fa(){cout << "A::fa" << endl;}
	virtual void fb(){cout << "A::fb" << endl;}
};
class C3
{
public:
	virtual void fa(){cout << "A::fa" << endl;}
	virtual void fb(){cout << "A::fb" << endl;}
	virtual void fc(){cout << "A::fc" << endl;}
};

void main()
{
	cout << sizeof(A) << endl;// 其为1
	cout << sizeof(B) << endl;// 也为1
	cout << sizeof(C1) << endl;//4
	cout << sizeof(C2) << endl;//4
	cout << sizeof(C3) << endl;//4
}

运行结果：

在这里插入图片描述

3、通过数组名加下标读取到虚表内的函数

	A a;
	typedef void (*FUN)(); //定义了一个函数指针
	FUN pf = NULL; //pf是函数指针类型，为指向返回值为void,里面没有参数的一类函数
	pf = (FUN)*( (int *)*(int *)( (int *)(&d) + n ) + m ); //pf指向类a内虚表所指向的第一个函数函数名,n、m为自己给的值，+n表示第几张虚表，+m表示虚表内的第几个函数
	pf();

4、 一个类的虚表

class A
{
public:
	virtual void fa(){cout << "A::fa" << endl;}
	virtual void fb(){cout << "A::fb" << endl;}
	virtual void fc(){cout << "A::fc" << endl;}
};

void main()
{
	A a;
	typedef void (*FUN)(); //定义了一个函数指针
	FUN pf = NULL; //pf是函数指针类型，为指向返回值为void,里面没有参数的一类函数
	pf = (FUN)*(int *)(*(int *)(&a)); //pf指向类a内虚表所指向的第一个函数函数名
	pf();
	pf = (FUN)*((int *)(*(int *)(&a)) + 1);
	pf();
	pf = (FUN)*((int *)(*(int *)(&a)) + 2);
	pf();
}

运行结果：

在这里插入图片描述

在这里插入图片描述

5、一个类继承另一个类的虚表

同名同参的虚函数，会进行重写/覆盖

class A
{
public:
	virtual void fa(){cout << "A::fa" << endl;}
	virtual void ga(){cout << "A::ga" << endl;}
	virtual void ha(){cout << "A::ha" << endl;}
};

class B:public A//B内有6个虚函数
{
public:
	virtual void fb(){cout << "B::fb" << endl;}
	virtual void gb(){cout << "B::gb" << endl;}
	virtual void hb(){cout << "B::hb" << endl;}
};

class C:public A//C内有5个虚函数
{
public:
	virtual void fa(){cout << "C::fc" << endl;}//同名同参的虚函数，会进行重写/覆盖
	virtual void gc(){cout << "C::gc" << endl;}
	virtual void hc(){cout << "C::hc" << endl;}
};

void main()
{
	cout << sizeof(A) << endl;//4
	cout << sizeof(B) << endl;//4
	cout << sizeof(C) << endl;//4
	cout<<endl;

	B b;
	typedef void(*FUN)();
	FUN pf = NULL;
	pf = (FUN)*(int *)(*(int *)(&b));
	pf();
	pf = (FUN)*((int *)(*(int *)(&b)) + 1);
	pf();
	pf = (FUN)*((int *)(*(int *)(&b)) + 2);
	pf();
	pf = (FUN)*((int *)(*(int *)(&b)) + 3);
	pf();
	pf = (FUN)*((int *)(*(int *)(&b)) + 4);
	pf();
	pf = (FUN)*((int *)(*(int *)(&b)) + 5);
	pf();
	cout<<endl;

	C c;
	pf = (FUN)*(int *)(*(int *)(&c));
	pf();
	pf = (FUN)*((int *)(*(int *)(&c)) + 1);
	pf();
	pf = (FUN)*((int *)(*(int *)(&c)) + 2);
	pf();
	pf = (FUN)*((int *)(*(int *)(&c)) + 3);
	pf();
	pf = (FUN)*((int *)(*(int *)(&c)) + 4);
	pf();
}

运行结果：
在这里插入图片描述

三个类中虚表的内存布局：

在这里插入图片描述

6、一个类继承多个基类的虚函数

多继承 – 一个类继承多个类
基类有几个，就有几个虚表
将函数挂到第一个继承的类虚表内

对于多继承，在子类的对象中，每个父类都有自己的虚表，将最终与类的虚函数放在第一个父类的虚表中，这样做解决了不同的父类类型的指针指向比较清晰
如果在子类中重写了多个父类的同名同参虚函数，那么在虚表中同样做了修改

1）没有覆盖的情况

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

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

class C
{
public:
	virtual void fc(){cout << "C::fc" << endl;}
	virtual void hc(){cout << "C::hc" << endl;}
};

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

int main()
{
	cout << sizeof(D) << endl ;//大小为12
	D d;

	typedef void(*FUN)();
	FUN pf = NULL;
	pf = (FUN)*(int *)( *(int *)(&d));
	pf();
	pf = (FUN)*((int *)( *(int *)(&d)) + 1 );
	pf();
	pf = (FUN)*((int *)( *(int *)(&d)) + 2 );
	pf();
	pf = (FUN)*((int *)( *(int *)(&d)) + 3 );
	pf();

	cout<<endl;

	pf = (FUN)*((int *)*(int *)((int *)(&d) + 1 ));
	pf();
	pf = (FUN)*( (int *)*(int *)( (int *)(&d) + 1 ) + 1 );
	pf();

	cout<<endl;

	pf = (FUN)*( (int *)*(int *)( (int *)(&d) + 2 ));
	pf();
	pf = (FUN)*( (int *)*(int *)( (int *)(&d) + 2 ) + 1 );
	pf();
}

运行结果：

在这里插入图片描述

四个类的虚表内存布局

在这里插入图片描述

2）存在覆盖的情况

class A
{
public:
	virtual void ff(){cout << "A::fa" << endl;}//
	virtual void ha(){cout << "A::ha" << endl;}
};

class B
{
public:
	virtual void ff(){cout << "B::fb" << endl;}//
	virtual void hb(){cout << "B::hb" << endl;}
};

class C
{
public:
	virtual void ff(){cout << "C::fc" << endl;}//
	virtual void hc(){cout << "C::hc" << endl;}
};

class D:public A,public B,public C
{
public:
	virtual void ff(){cout << "D::ff" << endl;}//
	virtual void hd(){cout << "D::hd" << endl;}
};

int main()
{
	cout << sizeof(D) << endl ;//大小为12
	D d;

	typedef void(*FUN)();
	FUN pf = NULL;
	pf = (FUN)*(int *)( *(int *)(&d));//A::fa
	pf();
	pf = (FUN)*((int *)( *(int *)(&d)) + 1 );
	pf();
	pf = (FUN)*((int *)( *(int *)(&d)) + 2 );
	pf();
	/*pf = (FUN)*((int *)( *(int *)(&d)) + 3 );
	pf();*/

	cout<<endl;

	pf = (FUN)*((int *)*(int *)((int *)(&d) + 1 ));
	pf();
	pf = (FUN)*( (int *)*(int *)( (int *)(&d) + 1 ) + 1 );
	pf();

	cout<<endl;

	pf = (FUN)*( (int *)*(int *)( (int *)(&d) + 2 ));
	pf();
	pf = (FUN)*( (int *)*(int *)( (int *)(&d) + 2 ) + 1 );
	pf();
}

运行结果：
在这里插入图片描述

四个类的内存布局

在这里插入图片描述

三、多态的条件

1、覆盖（重写）：

1、最少两个类，必须是父子关系；
2、同名同参虚函数，基类写了virtual，子类可以不写，他会将virtual继承下来

2、多态的条件：

1、满足覆盖
2、基类的指针或者引用指向基类对象或者派生类对象

四、联编（捆绑，绑定） – 函数调用 和 函数体联系的过程

联编是指计算机程序彼此关联的过程，是把一个标识符名和一个存储地址联系在一起的过程，也就是把函数的调用和函数的入口地址相结合的过程。

早捆绑/联编 – 在编译时
晚捆绑 – 在运行时

1、静态联编（static binding)早期绑定：

静态联编是指在编译和链接阶段，就将函数实现和函数调用关联起来。

C语言中，所有的联编都是静态联编，并且任何一种编译器都支持静态联编。
C++语言中，函数重载和函数模板也是静态联编。
C++语言中，使用对象名加点"."成员选择运算符，去调用对象虚函数，则被调用的虚函数是在编译和链接时确定。(称为静态联编)。

代码示例：

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

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

void test(A aa)
{
	aa.fn();
}

void main()
{
	A a;
	B b;
	C c;
	a.fn();//编译时就知道这是a的fn(),为静态联编
	b.fn();//编译时就知道这是b的fn()
	c.fn();
	cout<<endl;

	test(a);
	test(b);//编译时就已经确定，test内的fn()是类a内的fn(),在编译时就已经捆绑，为静态联编
	test(c);
	
}

在这里插入图片描述

2、动态联编(dynamic binding)亦称滞后联编(late binding)或晚期绑定：

动态联编是指在程序执行的时候才将函数实现和函数调用关联起来。
C++语言中，使用类类型的引用或指针调用虚函数（成员选择符">")，则程序在运行时选择虚函数的过程，称为动态联编。

代码示例：
产生多态

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

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

void test2(A &aa)//引用，传本身
{
	aa.fn();
}

void test3(A *p)//指针
{
	p->fn();
}


void main()
{
	A a;
	B b;
	C c;
	a.fn();//编译时就知道这是a的fn(),为静态联编
	b.fn();//编译时就知道这是b的fn()
	c.fn();
	cout<<endl;

	test2(a);//在程序执行时，才知道到调用谁的fn(),在程序执行时才将函数实现和函数调用关联起来，为动态联编，也称其为多态
	test2(b);
	test2(c);
	cout<<endl;
	
	test3(&a);//在程序执行时，才知道到调用谁的fn(),在程序执行时才将函数实现和函数调用关联起来，为动态联编
	test3(&b);
	test3(&c);
}

在这里插入图片描述

3、不加虚函数，不会产生多态

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


void test(A aa)
{
	aa.fn();
}

void test2(A &aa)//引用，传本身
{
	aa.fn();
}

void test3(A *p)//指针
{
	p->fn();
}

void main()
{
	A a;
	B b;
	a.fn();//编译时就知道这是a的fn(),为静态联编
	b.fn();//编译时就知道这是b的fn()
	cout<<endl;

	test(a);
	test(b);//编译时就已经确定，test内的fn()是类a内的fn(),在编译时就已经捆绑，为静态联编
	cout<<endl;
	
	test2(a);//在程序执行时，才知道到调用谁的fn(),在程序执行时才将函数实现和函数调用关联起来，为动态联编，也称其为多态
	test2(b);
	cout<<endl;
	
	test3(&a);//在程序执行时，才知道到调用谁的fn(),在程序执行时才将函数实现和函数调用关联起来，为动态联编
	test3(&b);
	
}
kyrie_sakura
关注
专栏目录
C++ ：多态（类型转换及问题、虚函数、C++如何实现动态绑定、多态成立的条件、抽象基类和纯虚函数、虚析构函数）
陈宸的博客
11-01 599
多态是面向对象程序设计语言中数据抽象和继承之外的第三个基本特征。 目录 一、类型转换及问题 1.2 问题解决思路 1.3 问题解决方案(虚函数,vitual function) 二、C++如何实现动态绑定 三、多态成立的条件 四、抽象基类和纯虚函数(pure virtual function) 五、虚析构函数 c++支持编译时多态(静态多态)和运行时多态(动态多态)，运算符...
C++ ----------- 多态性与虚函数
wangdass
03-27 303
多态 在C++中，多态表现形式之一是：具有不同功能的函数可以用同一个函数名，这样就可以实现用一个函数名调用不同内容的函数。从系统实现的角度来看，多态性分为两类：静态多态性和动态多态性。 静态多态性 静态多态性是通过函数重载实现的。由函数重载和运算符重载（运算符重载的实质上也就是函数重载）形成的多态性属于静态多态性，在程序编译时就能决定要调用的是哪个函数，静态函数又称为编译时的多态性，特点：速度...
C++ 17 —— 纯虚函数
xaphoenix的博客
06-11 524
源码// 17Ploy_PureVirtual.cpp : Defines the entry point for the console application. //#include "stdafx.h" #include "iostream.h" class Pet { public: void Speak() = 0; //问题1. 对于Pet类，存在一个纯虚函数，那么Pet
C++基础17-纯虚函数和抽象类
weixin_38383877的博客
08-15 383
总结： 1,含有纯虚函数的类,称为抽象基类,不可实列化。即不能创建对象,存在 的意义就是被继承,提供族类的公共接口。 2,纯虚函数只有声明,没有实现,被“初始化”为 0。 3,如果一个类中声明了纯虚函数,而在派生类中没有对该函数定义,则该虚函数在派生类中仍然为纯虚函数,派生类仍然为纯虚基类。 1、基本概念 纯虚函数是一个在基类中说明的虚函数，在基类中没有定义，要求任何派生类都定义...
c++入门经典学习笔记 17.1使用虚函数实现多态
自动驾驶行业学习、交流
05-08 218
多态：多种形态 #include <iostream> class Mammal { public: Mammal():age(1) { std::cout << "Mammal constructor ...\n"; } ~Mammal() { std::cout << "Mammal destructor ...\n"; } ...
c++17的结构化绑定
fpcc的专栏
12-17 1303
一、结构化绑定 如果搞过数据库的ORM映射，可能对这个所谓结构化绑定更好理解一些。一般来说，处理一个组合数据结构（数组、结构体、类等），当需要把其中的公有数据取出来时，一般是通过具体的位置操作或者相关属性操作取出来再进行相关的值的处理。这样以来，在一些纯数据类型或者说对数据进行全员操作时，就会显得代码很臃肿，不断重复着类似的动作。这和在数据结构中有大量数据需要初始化一样的道理，c++11以上的标准提供了初始化列表，那么同样也就会有这种取数据的操作，也就是结构化绑定。 结构化绑定可以理解成把组合数据结构和相关
自定义的类型支持C++17结构化绑定
最新发布
weixin_42951026的博客
10-21 423
自定义类型结构化绑定
C++ 面向对象- -多态性与虚函数
徐小mu的博客
10-02 1526
目录 关于多态性 用虚函数实现动态多态性 1、虚函数的作用 2、静态关联与动态关联 3、什么情况声明虚函数 4、虚析构函数 纯虚函数和抽象类 1、纯虚函数 2、抽象类 3、应用实例 关于多态性 向不同的对象发送同一个消息，不同的对象在接受时会产生不同的行为（即方法），也就是说每个对象可以用自己的方式去响应共同的消息。所谓消息，就是调用函数，不同的行为就是指不同的实现，...
多态性和虚函数【C++】
qq_45783047的博客
07-31 396
多态性和虚函数【C++】 一、多态性的概念 1、绑定 把函数体和函数调用相联系称为绑定。程序自身彼此关联的过程，也就是把一个标识符名和 一个存储地址联系在一起的过程。按照绑定进行的阶段不同，可以分为两种不同的绑定方法：静态 绑定和动态绑定。 2、静态绑定（静态联编） 联编工作出现在编译阶段，用对象名或者类名来限定要调用的函数。 C++ 中，默认的函数调用绑定方式为早绑定，也叫静态绑定，即在程序运行之前，由编译器 和连接器实现。 3、动态绑定...
第8章--多态性与虚函数
肉丸不肉
12-12 694
一、多态 1。是指具有不同功能的函数可以用同一个函数名。 函数的重载，运算符的重载其实是多态性的现象。 2。多态性分为以下两类： 静态多态性：又称编译时的多态性。编译器对源程序进行编译时就可以确定所调用的是哪一个函数。 实现方式：函数重载（普通函数、成员函数、构造函数） 运算符重载 动态多态性：有称为运行时的多态性。在程序运行过程
java多态介绍及与C++多态性的比较
xiaoweids的博客
08-20 508
java 的这种机制遵循一个原则：当超类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法。一个基类的对象引用，被赋予不同的子类对象引用，执行该方法时，将表现出不同的行为。关于java的多态，有的书上是这样讲的，它讲java的多态分成静态的多态，和动态的多态，而所谓静态的多态就是只函数的重载，动态的多态就是方法的覆写。系统会在你编译的时候根据你调用的方法的参数列表来动态的决定调用那一个函数。
学习笔记 | C++ | 多态与重载、虚函数、纯虚函数
大虎牙的博客
03-30 336
12. 多态与重载 掌握如何实现多态性 掌握虚函数的定义以及用法 熟悉虚析构函数 熟悉抽象基类 熟悉并掌握运算符重载 12.1 多态概述 多态性就相当于具有不同功能的函数可以共用同一个函数名，这样就可以用一个函数名调用具有不同功能的函数。 12.1.1 认识多态行为 所谓消息，就是调用函数，不同的行为就是指不同的实现，即执行不同的函数。 12.2 虚函数 12.3 虚析构函数 12....
【C++】多态----动态绑定（动态联编）、虚函数的梳理小结
IDoWhatIDo_92761的博客
10-15 1378
目录1.多态的定义与作用广义上的多态狭义上的多态多态的作用2.静态类型与动态类型静态类型动态类型两者的关系3. 动态多态（运行时多态、动态联编、晚绑定）例子1解释1例子2解释2去掉virtual的时候有virtual的时候向上类型转换（upcasting）4.虚函数虚函数的原理--虚函数表区分【virtual覆盖基类函数】与【派生类隐藏基类同名函数】隐藏（重定义）、覆盖、重载隐藏的规则覆盖的条件重载的条件
C++多态：静态多态（函数地址早绑定），动态多态（函数地址晚绑定）虚函数表，虚析构函数重写。
qq_51004011的博客
07-11 1858
只要类中存在修函数或纯虚函数，那么类内就会自动生成一个虚函数表指针，指向一张虚函数表，在这个虚函数表中，存放着类内所有虚函数的地址。当这个类被它的子类继承时，子类也会继承这个虚函数表指针，与虚函数表，（注意两张虚函数表不是同一张表，可以理解为复制了一张虚函数表交给子类的虚函数标配指针。） 现在只要子类中对父类的虚函数和纯虚函数进行函数重写，那么子类中重写后的函数地址就会将原来的函数地址覆盖掉。这样就实现了动态的多态。.........
C++的动态绑定(Boolan笔记第五周)
roufoo的博客
02-11 2186
C++的动态绑定
C++的动态绑定和静态绑定
To the beyond and infinity!
03-18 710
为了支持 C++ 的多态性，才有了动态绑定和静态绑定。理解他们的区别有助于更好的理解多态性，以及在编程的过程中避免犯错误。 需要理解四个名词： 对象的静态类型：对象在声明时采用的类型，是在编译期确定的； 对象的动态类型：目前所指对象的类型，是在运行期决定的。对象的动态类型可以更改，但是静态类型无法更改； 关于对象的静态类型和动态类型，看如下示例： class B {}; class C : public B {}; class D : public B {}; D* pD = new D();
虚函数和纯虚函数的区别
编程资料大全
05-11 4641
首先：强调一个概念定义一个函数为虚函数，不代表函数为不被实现的函数。 定义他为虚函数是为了允许用基类的指针来调用子类的这个函数。 定义一个函数为纯虚函数，才代表函数没有被实现。 定义纯虚函数是为了实现一个接口，起到一个规范的作用，规范继承这个类的程序员必须实现这个函数。1、简介 假设我们有下面的类层次：class A { public: virtual void foo() { c...
C++的静态绑定和动态绑定(或称静态联编和动态联编)
banxi1988的专栏
10-13 543
先看两个相似的程序的执行过程及结果: 首先是main()方法驱动Cpp文件如下: [code="c++"] #include "Test_StaticBinding_DynamicBinding.h" int main() { Figure figure; cout...
深入理解C++的动态绑定和静态绑定
热门推荐
常高伟的专栏
05-17 7万+
为了支持c++的多态性，才用了动态绑定和静态绑定。理解他们的区别有助于更好的理解多态性，以及在编程的过程中避免犯错误。 需要理解四个名词： 1、对象的静态类型：对象在声明时采用的类型。是在编译期确定的。 2、对象的动态类型：目前所指对象的类型。是在运行期决定的。对象的动态类型可以更改，但是静态类型无法更改。 关于对象的静态类型和动态类型，看一个示例： class B { } class C : public B { } class D : public B { } D* pD
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值