C++核心编程 day07 静态联编和动态联编、多态、虚函数与纯虚函数

于 2023-11-06 20:47:27 发布
阅读量85 收藏
点赞数
分类专栏： C++核心编程 文章标签： c++ 开发语言
月仙儿
本文链接：https://blog.csdn.net/qq_42198306/article/details/134239509
版权

C++核心编程 day07 静态联编和动态联编、多态、虚函数与纯虚函数

1. 静态联编和动态联编

静态联编和动态联编实际上就是C++中的多态。面向对象有三个基本特征，分别是封装、继承和多态，而在前面我们已经学习了封装和继承的一系列知识。多态提供了接口与具体实现之间的隔离。多态可以改善代码的可读性和组织性，同时也使得程序具有良好的可扩展性，项目不仅可以在创建初期的时候扩展，也可以在后期项目需要新功能的时候也能很好地扩展。

多态可以分为静态多态和动态多态。静态多态和动态多态的区别在于函数地址是早绑定还是晚绑定。例如前面学的运算符的重载和函数的重载就是在编译时候进行函数绑定的，也就是静态多态，在编译阶段就可以确定函数的调用地址。而动态多态属于晚绑定，也就是程序在运行时才能确定函数的调用地址。比如前面类的继承就是一种动态多态，此节后续的虚函数实现也是一种动态多态。静态多态也就是静态联编，动态多态也就是动态联编。接下来我们看一个关于静态多态的例子，代码如下：

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

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

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

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

	void eat(int a)
	{
		cout << "小猫在吃饭" << endl;
	}
};

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

	void eat(int a)
	{
		cout << "小狗在吃饭" << endl;
	}
};

void doAct(Animal &animal)
{
	animal.speak();
	animal.eat(1);
}

void test01()
{
	Cat cat;
	doAct(cat);

	Dog dog;
	doAct(dog);
}

int main()
{
	test01();

	system("pause");
	return 0;
}

该程序的运行结果为：

在这里插入图片描述

我们先单独地看一下关于Dog类的模型：

在这里插入图片描述

实际上在编译的时候我们就已经决定了这里Animal类中的speak和eat函数就绑定了&Animal::speak和&Animal::eat函数。如果我们想要实现Cat类使用Cat类的speak和eat函数，Dog类使用Dog类的speak和eat函数，我们就需要Animal类中的speak和eat函数实现动态的绑定，也就是运行的时候才决定函数的调用地址。实现这个方法可以使用虚函数来实现，也就是在Animal类中的speak和eat函数前面加上virtual进行修饰，此时就会出现动态绑定，代码如下。

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

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

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


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

	void eat(int a)
	{
		cout << "小猫在吃饭" << endl;
	}
};

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

	void eat(int a)
	{
		cout << "小狗在吃饭" << endl;
	}
};

// 动态多态产生条件：
// 先有继承关系
// 父类中有虚函数，子类重写了父类中的虚函数
// 父类的指针或者引用指向了子类对象

// 对于有父子关系的两个类 指针或者引用是可以直接转换的
void doAct(Animal &animal)
{
	// 如果地址早就绑定好了，地址早绑定属于静态联编
	// 如果想要调用子类中的方法，那么函数的地址就不能早就绑定好，而是在运行阶段再去绑定函数调用地址，属于动态联编
	animal.speak();
	animal.eat(1);
}

void test01()
{
	Cat cat;
	doAct(cat);

	Dog dog;
	doAct(dog);
}

int main()
{
	test01();

	system("pause");
	return 0;
}

此时的运行结果为：

在这里插入图片描述
实现了各个类分别调用各个类中的函数。那么动态多态的产生要有什么条件呢？需要三个条件，分别如下：

  • 类之间要有继承关系。
  • 父类中有虚函数，子类要重写了父类中的虚函数。在子类中重写的的父类虚函数前的virtual关键字可以加上，也可以不用加上。
  • 父类的指针或者引用指向了子类对象。 这种情况下不需要对对象进行强制类型转换。

我们继续看一下关于这个Dog类的模型：

在这里插入图片描述我们可以发现这里是维护了一个vfptr指针，也就是虚函数表指针。虚函数表指针指向vftable，也就是虚函数表。在表中我们可以看见有两个函数的入口地址，这两个入口地址都是本类中重写了的虚函数。假如我们没有重写父类的虚函数呢？则会绑定父类的虚函数地址，下面是没有重写时候的Dog类模型图。

在这里插入图片描述
这样就可以实现我们的多态。同样因为我们在动态多态中的时候需要维护一个虚函数表，所有在空对象的时候也会有一个指针的大小，所有空对象所占用的内存空间也是4字节，而在静态多态中空对象占用的空间大小为1字节。

既然如此接下来有这么一行代码：

Animal *animal = new Dog;

那么我们如何根据指针的偏移去调用这两个函数呢？首先我们来看看speak函数。

首先animal就是该对象的地址，接下来强制转换为int *类型，由于虚函数表指针的偏移量是0，所以直接解引用就是虚函数表。也就是*(int *)animal就表示的是虚函数表。接下来将类型强制转换为int *指针，由于&Dog::speak的偏移量为0，所有直接解引用就是Dog::speak的地址。也就是*(int *)*(int *)animal表示的就是&Dog::speak，但是指针类型不对，由于speak的返回值为void类型，形参列表为空，将该地址强转为void (*)()函数类型就可以直接调用。所有最终的调用形式为((void (*)()) *(int *)*(int *)animal)();。

参照上述的操作，我们也可以写出来eat函数使用指针偏移进行调用的形式，答案是((void (*)(int)) *((int *)*(int *)animal + 1))(1);。但是这个结果运行的时候会出现以下的错误.

在这里插入图片描述

这里的错误并不是我们写错了，而是我们的调用惯例不对。调用惯例在C语言阶段已经提过，主要是函数的入栈方式以及函数结束的时候空间由主调函数释放还是被调函数释放。由于我们的eat函数只有一个参数，所以不可能是形参的入栈顺序出错，因为无论是从左往右入栈还是从右往左入栈的结果都是一样的，所以应该是释放内存的时候出现的错误。在我们C/C++中，默认的调用惯例是__cdecl，而我们真实的调用惯例却是__stdcall，所以我们需要在上述的强制类型转换中写明调用管理。定义函数指针类型可以按照一下的类型定义。

typedef 返回类型 (调用管理 *函数类型名)(形参列表);

因此在我们强制类型转化的时候可以写成这样((void (__stdcall*)(int)) *((int *)*(int *)animal + 1))(1);。这样就可以不会报任何错误。

上述完整的代码如下（略有重复）。

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

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

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


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

	void eat(int a)
	{
		cout << "小猫在吃饭" << endl;
	}
};

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

	void eat(int a)
	{
		cout << "小狗在吃饭" << endl;
	}
};

// 动态多态产生条件：
// 先有继承关系
// 父类中有虚函数，子类重写了父类中的虚函数
// 父类的指针或者引用指向了子类对象

// 对于有父子关系的两个类 指针或者引用是可以直接转换的
void doAct(Animal &animal)
{
	// 如果地址早就绑定好了，地址早绑定属于静态联编
	// 如果想要调用子类中的方法，那么函数的地址就不能早就绑定好，而是在运行阶段再去绑定函数调用地址，属于动态联编
	animal.speak();
	animal.eat(1);
}

void test01()
{
	Cat cat;
	doAct(cat);

	Dog dog;
	doAct(dog);
}

void test02()
{
	Animal *animal = new Dog;

	// *(int *)animal 解引用到虚函数表中
	// *(int *)*(int *)animal 解引用到函数speak的地址
	((void (*)()) *(int *)*(int *)animal)();

	// C/C++默认调用惯例是__cdecl
	// 在下面调用的时候真实的调用惯例是__stdcall
	((void (__stdcall*)(int)) *((int *)*(int *)animal + 1))(1);

}

int main()
{
	test01();
	test02();

	system("pause");
	return 0;
}

2. 多态案例----计算器案例

在设计的时候，我们有一个开闭原则。也就是对扩展进行开放，对修改进行关闭。例如接下来的计算器案例我们使用多态设计如下：

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

class AbstractCaculator
{
public:
	virtual int getResult()
	{
		return 0;
	}

	int m_A;
	int m_B;
};

// 加法计算器
class AddCaculator : public AbstractCaculator
{
public:
	virtual int getResult()
	{
		return this->m_A + this->m_B;
	}
};

// 减法计算器
class SubCaculator : public AbstractCaculator
{
public:
	virtual int getResult()
	{
		return this->m_A - this->m_B;
	}
};

// 乘法计算器
class MulCaculator : public AbstractCaculator
{
public:
	virtual int getResult()
	{
		return this->m_A * this->m_B;
	}
};


int main()
{
	AbstractCaculator *caculator = new AddCaculator;
	caculator->m_A = 10;
	caculator->m_B = 20;
	cout << caculator->getResult() << endl;
	delete caculator;

	caculator = new SubCaculator;
	caculator->m_A = 20;
	caculator->m_B = 10;
	cout << caculator->getResult() << endl;
	delete caculator;

	caculator = new MulCaculator;
	caculator->m_A = 10;
	caculator->m_B = 10;
	cout << caculator->getResult() << endl;
	delete caculator;

	system("pause");
	return 0;
}

在上面的案例中，我们在设计计算器类的时候只设计了virtual int getResult();，也就是提供了一个规范，这样在后面的继承之中只需要重写这个接口函数就行。这样我们有了新的功能也只需要继续继承重写即可。但是这个不会强制让你重写。如果需要强制重写，则我们需要将上述的接口定义纯虚函数。纯虚函数的定义为virtual 返回值 函数名(形参列表) = 0;，例如上面的计算器类可以写成这样。

class AbstractCaculator
{
public:
	virtual int getResult() = 0;

	int m_A;
	int m_B;
};

需要注意的是如果一个类中有纯虚函数，则这个类不能进行实例化对象。当一个类继承了有纯虚函数的类，那么子类没有重写纯虚函数的话也不能实例化对象。纯虚函数强制规定了子类必须重写原来的某个纯虚函数，否则不能实例化，同时某些函数我们只是设计了接口不需要实现的时候就可以写成纯虚函数。有纯虚函数的类我们通常称为抽象类。

在这里插入图片描述

3. 虚析构和纯虚析构

在析构函数前面加上关键字virtual后就是虚析构函数。如下面的代码：

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

class Animal
{
public:
	Animal()
	{
		cout << "Animal的构造函数调用" << endl;
	}

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

	virtual ~Animal()
	{
		cout << "Animal的虚析构函数调用" << endl;
	}

};

class Cat : public Animal
{
public:
	Cat(char *name)
	{
		cout << "Cat的构造函数调用" << endl;
		this->name = new char[strlen(name) + 1];
		strcpy(this->name, name);
	}

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

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

	char *name;
};

int main()
{
	Animal *animal = new Cat("Tom");
	animal->speak();

	delete animal;

	system("pause");
	return 0;
}

现在我们的要求是在使用delete的时候animal会去调用Cat类中的析构函数实现name在堆区的数据的释放。这个程序的运行结果如下。

在这里插入图片描述

我们可以知道虚析构函数的作用是在派生类派生类对象被删除时，先调用派生类的析构函数，再调用基类的析构函数。这样可以确保对象的析构顺序正确，避免在派生类析构函数中访问已经被删除的成员变量和对象错误。而纯虚函数的作用是将派生类的析构函数声明为纯虚函数，从而强制派生类必须实现自己的析构函数。如果一个类中有了纯虚析构函数，那么这个类也是抽象类，不可以实例化对象。上述的代码要实现释放堆区的内存则需要改成如下。

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

class Animal
{
public:
	Animal()
	{
		cout << "Animal的构造函数调用" << endl;
	}

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

	// 如果子类中有指向堆区的属性，那么利用虚析构技术，在delete的时候调用子类的析构函数
	//virtual ~Animal()
	//{
	//	cout << "Animal的虚析构函数调用" << endl;
	//}

	// 纯虚析构需要有声明，也需要有实现
	// 如果一个类中有了纯虚析构函数，那么这个类也属于抽象类，无法实例化对象
	virtual ~Animal() = 0;

};

Animal::~Animal()
{
	cout << "Animal的纯虚析构函数调用" << endl;
}

class Cat : public Animal
{
public:
	Cat(char *name)
	{
		cout << "Cat的构造函数调用" << endl;
		this->name = new char[strlen(name) + 1];
		strcpy(this->name, name);
	}

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

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

	char *name;
};

int main()
{
	Animal *animal = new Cat("Tom");
	animal->speak();

	delete animal;

	system("pause");
	return 0;
}

运行结果如下。

在这里插入图片描述

4. 多态案例----电脑组装案例

在这里我们就对多态的学习结束了。在多态的时候我们是将父类的指针指向子类的对象，或者是父类的引用接收子类的对象，这是不需要去强制类型转换的，这是安全的。但是如果我们把父类的对象强制类型转化子类就会有安全隐患的产生，因为当父类转换为子类的时候就会出现访问越界的情况。

最后再区分一个概念，关于函数的重载、重定义以及重写。函数的重载要求必须在同一个作用域中且函数名相同。重载可以是函数的参数个数，也可以是函数的参数顺序，或者是参数的数据类型。重载是和函数返回值是没有任何关系的。函数的重定义发生在继承之中，子类重新定义了父类的非虚函数，此时编译器会把父类的同名成员函数包括所有同名的重载都隐藏起来，需要访问必须借助作用域运算符。函数的重写也是要求有继承关系，是子类重写了父类的虚函数。函数的返回值、函数的名字以及函数参数必须和基类中的虚函数保持一致。

下面给一个关于多态的计算机组装的案例。要求是由三个基类分别是CPU、显卡和内存条。有两家厂商分别生产这三样东西，而我们需要将这些东西组装成一台电脑，代码如下。

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


// CPU基类
class CPU
{
public:
	virtual void caculate() = 0;
};

// 显卡基类
class GraphicsCard
{
public:
	virtual void display() = 0;
};

// 内存条基类
class Memory
{
public:
	virtual void storage() = 0;
};

// 电脑
class Computer
{
public:
	Computer(CPU *cpu, GraphicsCard *graphicsCard, Memory *memory)
	{
		cout << "电脑的构造函数调用" << endl;
		this->cpu = cpu;
		this->graphicsCard = graphicsCard;
		this->memory = memory;
	}

	void work()
	{
		this->cpu->caculate();
		this->graphicsCard->display();
		this->memory->storage();
	}

	~Computer()
	{
		cout << "电脑的析构函数调用" << endl;
		if (this->cpu != NULL)
		{
			delete this->cpu;
			this->cpu = NULL;
		}

		if (this->graphicsCard != NULL)
		{
			delete this->graphicsCard;
			this->graphicsCard = NULL;
		}

		if (this->memory != NULL)
		{
			delete this->memory;
			this->memory = NULL;
		}
	}

	CPU *cpu;
	GraphicsCard *graphicsCard;
	Memory *memory;
};

// Intel厂家
class IntelCPU : public CPU
{
public:
	void caculate()
	{
		cout << "Intel CPU正在计算" << endl;
	}
};


class IntelGraphicsCard : public GraphicsCard
{
public:
	void display()
	{
		cout << "Intel 显卡正在显示" << endl;
	}
};

class IntelMemory : public Memory
{
public:
	void storage()
	{
		cout << "Intel 内存条正在存储" << endl;
	}
};

// Lenovo厂商
class LenovoCPU : public CPU
{
public:
	void caculate()
	{
		cout << "Lenovo CPU正在疯狂计算中" << endl;
	}
};

class LenovoGraphicsCard : public GraphicsCard
{
public:
	void display()
	{
		cout << "Lenovo 显卡正在疯狂显示中" << endl;
	}
};

class LenovoMemory : public Memory
{
public:
	void storage()
	{
		cout << "Lenovo 内存条正在疯狂存储中" << endl;
	}
};

int main()
{
	cout << "组装第一台电脑:" << endl;
	CPU *cpu1 = new LenovoCPU;
	GraphicsCard *graphicsCard1 = new IntelGraphicsCard;
	Memory *memory1 = new IntelMemory;

	Computer *computer1 = new Computer(cpu1, graphicsCard1, memory1);
	computer1->work();
	delete computer1;

	cout << "组装第二台电脑:" << endl;
	CPU *cpu2 = new IntelCPU;
	GraphicsCard *graphicsCard2 = new IntelGraphicsCard;
	Memory *memory2 = new IntelMemory;

	Computer *computer2 = new Computer(cpu2, graphicsCard2, memory2);
	computer2->work();
	delete computer2;

	cout << "组装第三台电脑:" << endl;
	CPU *cpu3 = new LenovoCPU;
	GraphicsCard *graphicsCard3 = new LenovoGraphicsCard;
	Memory *memory3 = new LenovoMemory;

	Computer *computer3 = new Computer(cpu3, graphicsCard3, memory3);
	computer3->work();
	delete computer3;

	system("pause");
	return 0;
}
月仙儿
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++虚函数多态和纯虚函数多态的经典示例源码
02-25
C++虚函数多态和纯虚函数多态的经典示例源码
C++虚函数与动态联编
程序人生
07-11 2520
静态联编和动态联编        编译器将源代码中的函数调用解释为执行特定的函数代码块，这一行为被称为函数名联编（binding）。联编行为发生在编译过程中则被称为静态联编（static binding），又称为早期联编（early binding）。然而，虚函数使这项工作变得更困难。虚函数的特点使得程序使用哪一个函数是不能再编译时确定的，因为编译器不知道用户将选择哪一种类型的对象。所以，编译器...
【C++】多态----动态绑定（动态联编）、虚函数的梳理小结
IDoWhatIDo_92761的博客
10-15 1139
目录1.多态的定义与作用广义上的多态狭义上的多态多态的作用2.静态类型与动态类型静态类型动态类型两者的关系3. 动态多态（运行时多态、动态联编、晚绑定）例子1解释1例子2解释2去掉virtual的时候有virtual的时候向上类型转换（upcasting）4.虚函数虚函数的原理--虚函数表区分【virtual覆盖基类函数】与【派生类隐藏基类同名函数】隐藏（重定义）、覆盖、重载隐藏的规则覆盖的条件重载的条件
动态联编与虚函数
qq_42932834的博客
05-30 637
动态联编 有时候我们并不希望某些环节在编译阶段完成，而需要它在程序运行时才可以确定将要调用的函数，称为动态联编。动态联编提高了编程的灵活性和程序的易维护性，但与静态联编相比，函数调用速度慢。 虚函数是实现动态联编的基础，它是一种动态的重载方式，它允许在运行时建立函数调用与函数体之间的关系。 虚函数是一个在基类中声明为virtual的函数，并在一个或多个派生类中被重新定义的成员函数，虚函...
C++的静态联编和动态联编详解
01-01
静态联编是指在编译阶段就将函数实现和函数调用关联起来，因此静态联编也叫早绑定，在编译阶段就必须了解所有的函数或模块执行所需要检测的信息，它对函数的选择是基于指向对象的指针（或者引用）的类型，C语言中，...
c++中虚函数和纯虚函数的作用与区别
12-31
虚函数为了重载和多态的需要，在基类中是有定义的，即便定义是空，所以子类中可以重写也可以不写基类中的此函数！ 纯虚函数在基类中是没有定义的，必须在子类中加以实现，很像java中的接口函数！ 虚函数 引入原因：...
c++ 虚函数与纯虚函数的区别(深入分析)
01-20
在面向对象的C++语言中，虚函数（virtual function）是一个非常重要的概念。因为它充分体现 了面向对象思想中的继承和多态性这两大特性，在C++语言里应用极广。比如在微软的MFC类库中，你会发现很多函数都有virtual...
C++中虚函数与纯虚函数的用法
12-31
本文较为深入的分析了C++中虚函数与纯虚函数的用法，对于学习和掌握面向对象程序设计来说是至关重要的。具体内容如下： 首先，面向对象程序设计（object-oriented programming）的核心思想是数据抽象、继承、动态...
虚函数和动态联编
04-20
虚函数和动态联编的PP他，觉得有用的可以下载，勿拍砖
虚函数(动态联编)
wangprince2017
07-19 622
  #include&lt;iostream&gt; using namespace std; class A {     int x,y ;    public:        A(int i,int j) { x=i; y=j; }       virtual void disp() { cout&lt;&lt;"x="&lt;&lt;x&lt;&lt;" y="&lt;&lt;y
虚函数及静态联编与动态联编---学习笔记
jinzhou520 的专栏
08-23 3295
C++ Primer Plus 第13章 类继承     提到
函数静态联编与动态联编与虚函数的成本
qq_36101436的博客
01-16 185
将源代码中的函数调用解释为执行对应的函数代码块被称为函数名联编， 静态联编 C/C++编译器可以在编译过程中完成这种函数名联编叫做静态联编。又称为早期联编。编译器对非虚方法使用静态联编。 动态联编 在程序运行时选择正确的虚函数代码的方法称为动态联编，又称为晚期联编。编译器对虚方法使用动态联编。 使用虚函数的缺点 1 每个对象都将增大，在内存和执行速度方面有一定的成本。 2 对于每个类
详细介绍C++中的虚函数和动态联编
haojingus的专栏
10-12 457
面向对象程序设计的基本观点是用程式来仿真大千世界，这使得它的各种根本特性非常人性化，如封装、继承、多态等等，而虚函数就是c++中实现多态性的主将。为了实现多态性，c++编译器也革命性地提供了动态联编（或叫晚捆绑）这一特征。 虚拟函数亦是mfc编程的关键所在,mfc编程主要有
C++笔记——虚函数与动态联编
寻陌的博客
02-20 900
C++笔记——虚函数与动态联编 动态联编？静态联编？ 程序调用函数时，将使用哪个可执行代码块呢？编译器负责回答这个问题。将源代码中的函数调用解释为执行特定的函数代码块被称为函数名联编（binding）。在C语言中，这非常简单，因为每个函数名部对应一个不同的函数。在C++中，由于函教重载的缘故，这项任务更复杂。编译器必须查看函数参数以及函数名才能确定使用哪个函数。然而，C/C++编译器可以在编译过...
动态联编 和 静态联编
热门推荐
Miibotree
12-15 2万+
关于 动态联编 和 静态联编 这个概念，自己听了老师上课讲的课仍然没有明白原理。 那么既然这样，只能自己去学习了。 首先我们知道的是，动态联编 和 静态联编 都是多态性的一种体现。 关于面向对象的三个基本要素：封装（类型抽象）， 继承 和 多态。 首先我们从概念性上面了解了 动态联编 和 静态联编 的功能：实现了多态性。 然后我们从最最基本的开始讲解。 1.什么
解释一下动态联编、静态联编、兼容赋值规则、虚函数等c++的较难专业性名词
最新发布
06-12
1. 动态联编：在程序运行时确定函数的具体实现，也称为运行时多态。通过使用虚函数实现。在C++中，通过将基类的成员函数声明为虚函数，派生类可以覆盖父类的虚函数，从而在运行时可以根据实际的对象类型来调用相应的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值