C++ 多态

已于 2022-07-20 12:00:29 修改
阅读量349 收藏 2
点赞数 1
分类专栏： C++进阶 文章标签： c++ 开发语言 继承与多态
于 2022-07-19 19:51:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_61548909/article/details/125878362
版权
本文详细介绍了C++中的多态性，包括构成多态的条件、虚函数、虚函数重写以及C++11的override和final关键字。还探讨了抽象类的概念，接口继承和实现继承的差异。此外，文章深入解析了多态的原理，如虚函数表和动态绑定。最后，讨论了单继承和多继承中虚函数表的结构，并列举了一些继承和多态相关的面试问题及其答案。
摘要由CSDN通过智能技术生成

目录

1. 多态的定义及实现

1.1多态的构成条件

 1.2 虚函数

1.3 虚函数的重写

虚函数重写的两个例外：

1.4 C++11 override 和 fifinal

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

2.抽象类

2.1 概念

2.2 接口继承和实现继承

3.多态的原理

3.1虚函数表

3.2 多态的原理

3.3 动态绑定与静态绑定

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

4.1 单继承中的虚函数表

 4.2 多继承中的虚函数表

4.3菱形继承、菱形虚拟继承

5.继承和多态常见的面试问题

5.1 概念查考

5.2 问答题

1. 多态的定义及实现

1.1多态的构成条件

多态是在不同继承关系的类对象，去调用同一函数，产生了不同的行为。对于常见的买票程序，比如 Student 继承了 Person。 Person 对象买票全价， Student 对象买票半价。
在继承中要 构成多态还有两个条件 ：
1. 必须通过基类的指针或者引用调用虚函数
2. 被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写

 

 1.2 虚函数

虚函数：即被virtual修饰的类成员函数成为虚函数

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

1.3 虚函数的重写

虚函数的重写 ( 覆盖 ) ： 派生类中有一个跟基类完全相同的虚函数 ( 即派生类虚函数与基类虚函数的
返回值类型、函数名字、参数列表完全相同 ) ，称子类的虚函数重写了基类的虚函数。 
class Person {
public:
	virtual void BuyTicket() { cout << "买票-全价" << endl; }
};
class Student : public Person {
public:
	virtual void BuyTicket() { cout << "买票-半价" << endl; }
	/*注意：在重写基类虚函数时，派生类的虚函数在不加virtual关键字时，虽然也可以构成重写(因
	为继承后基类的虚函数被继承下来了在派生类依旧保持虚函数属性),但是该种写法不是很规范，不建议
	这样使用*/
	/*void BuyTicket() { cout << "买票-半价" << endl; }*/
};
void Func(Person& p)
{
	p.BuyTicket();
}
int main()
{
	Person ps;
	Student st;
	Func(ps);
	Func(st);
	return 0;
}

虚函数重写的两个例外：

1. 协变(基类与派生类虚函数返回值类型不同)

派生类重写基类虚函数时，与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指
针或者引用，派生类虚函数返回派生类对象的指针或者引用时，称为协变。（了解） 
class A{};
class B : public A {};
class Person {
public:
 virtual A* f() {return new A;}
};
class Student : public Person {
public:
 virtual B* f() {return new B;}
};

2. 析构函数的重写 ( 基类与派生类析构函数的名字不同 )
如果基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加 virtual 关键字，
都与基类的析构函数构成重写，虽然基类与派生类析构函数名字不同。虽然函数名不相同，
看起来违背了重写的规则，其实不然，这里可以理解为编译器对析构函数的名称做了特殊处
理，编译后析构函数的名称统一处理成 destructor 。 
class Person {
public:
	virtual ~Person() { cout << "~Person()" << endl; }
};
class Student : public Person {
public:
	virtual ~Student() { cout << "~Student()" << endl; }
};
/* 只有派生类Student的析构函数重写了Person的析构函数，下面的delete对象调用析构函
数，才能构成多态，才能保证p1和p2指向的对象正确的调用析构函数。*/
int main()
{
	Person* p1 = new Person;
	Person* p2 = new Student;
	delete p1;
	delete p2;
	return 0;
}

1.4 C++11 override 和 fifinal

从上面可以看出， C++ 对函数重写的要求比较严格，但是有些情况下由于疏忽，可能会导致函数
名字母次序写反而无法构成重载，而这种错误在编译期间是不会报出的，只有在程序运行时没有
得到预期结果才来 debug 会得不偿失，因此： C++11 提供了 override 和 fifinal 两个关键字，可以帮
助用户检测是否重写。
1. fifinal ：修饰虚函数，表示该虚函数不能再被重写 
class Car
{
public:
	virtual void Drive() final {}
};
class Benz :public Car
{
public:
	virtual void Drive() { cout << "Benz-舒适" << endl; }
};
2. override: 检查派生类虚函数是否重写了基类某个虚函数，如果没有重写编译报错。 
class Car {
public:
	virtual void Drive() {}
};
class Benz :public Car {
public:
	virtual void Drive() override { cout << "Benz-舒适" << endl; }
};

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

2.抽象类

2.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();
}

2.2 接口继承和实现继承

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

3.多态的原理

3.1虚函数表


// 这里常考一道笔试题：sizeof(Base)是多少？
class Base
{
public:
	virtual void Func1()
	{
		cout << "Func1()" << endl;
	}
private:
	int _b = 1;
};
通过观察测试我们发现 b 对象是 8bytes ， 除了 _b 成员，还多一个 __vfptr 放在对象的前面 ( 注意有些
平台可能会放到对象的最后面，这个跟平台有关 ) ，对象中的这个指针我们叫做虚函数表指针 (v 代
表 virtual ， f 代表 function) 。一个含有虚函数的类中都至少都有一个虚函数表指针，因为虚函数
的地址要被放到虚函数表中，虚函数表也简称虚表，。那么派生类中这个表放了些什么呢？我们
接着往下分析 

// 针对上面的代码我们做出以下改造
// 1.我们增加一个派生类Derive去继承Base
// 2.Derive中重写Func1
// 3.Base再增加一个虚函数Func2和一个普通函数Func3
class Base
{
public:
	virtual void Func1()
	{
		cout << "Base::Func1()" << endl;
	}
	virtual void Func2()
	{
		cout << "Base::Func2()" << endl;
	}
	void Func3()
	{
		cout << "Base::Func3()" << endl;
	}
private:
	int _b = 1;
};
class Derive : public Base
{
public:
	virtual void Func1()
	{
		cout << "Derive::Func1()" << endl;
	}
private:
	int _d = 2;
};
int main()
{
	Base b;
	Derive d;
	return 0;
}
通过观察和测试，我们发现了以下几点问题：
1. 派生类对象 d 中也有一个虚表指针， d 对象由两部分构成，一部分是父类继承下来的成员，虚
表指针也就是存在部分的另一部分是自己的成员。
2. 基类 b 对象和派生类 d 对象虚表是不一样的，这里我们发现 Func1 完成了重写，所以 d 的虚表
中存的是重写的 Derive::Func1 ，所以虚函数的重写也叫作覆盖 ，覆盖就是指虚表中虚函数
的覆盖。重写是语法的叫法，覆盖是原理层的叫法。
3. 另外 Func2 继承下来后是虚函数，所以放进了虚表， Func3 也继承下来了，但是不是虚函
数，所以不会放进虚表。
4. 虚函数表本质是一个存虚函数指针的指针数组，一般情况这个数组最后面放了一个 nullptr 。
5. 总结一下派生类的虚表生成： a. 先将基类中的虚表内容拷贝一份到派生类虚表中 b. 如果派生
类重写了基类中某个虚函数，用派生类自己的虚函数覆盖虚表中基类的虚函数 c. 派生类自己
新增加的虚函数按其在派生类中的声明次序增加到派生类虚表的最后。
6. 这里还有一个很容易混淆的问题： 虚函数存在哪的？虚表存在哪的？ 答：虚函数存在
虚表，虚表存在对象中。注意上面的回答的错的 。但是很多人都是这样深以为然的。注意
虚表存的是虚函数指针，不是虚函数 ，虚函数和普通函数一样的，都是存在代码段的，只是
他的指针又存到了虚表中。另外对象中存的不是虚表，存的是虚表指针。那么 虚表存在哪的
呢？实际我们去验证一下会发现 vs 下是存在代码段的， Linux g++ 下大家自己去验证？

3.2 多态的原理

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


class Person {
public:
	virtual void BuyTicket() { cout << "买票-全价" << endl; }
};
class Student : public Person {
public:
	virtual void BuyTicket() { cout << "买票-半价" << endl; }
};
void Func(Person& p) {
	p.BuyTicket();
}
int main()
{
	Person Mike;
	Func(Mike);
	Student Johnson;
	Func(Johnson);
	return 0;
}
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.3 动态绑定与静态绑定

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

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

需要注意的是在单继承和多继承关系中，下面我们去关注的是派生类对象的虚表模型，因为基类

的虚表模型前面我们已经看过了，没什么需要特别研究的

4.1 单继承中的虚函数表 

class Base {
public:
	virtual void func1() { cout << "Base::func1" << endl; }
	virtual void func2() { cout << "Base::func2" << endl; }
private:
	int a;
};
class Derive :public Base {
public:
	virtual void func1() { cout << "Derive::func1" << endl; }
	virtual void func3() { cout << "Derive::func3" << endl; }
	virtual void func4() { cout << "Derive::func4" << endl; }
private:
	int b;
};
观察下图中的监视窗口中我们发现看不见 func3 和 func4 。这里是编译器的监视窗口故意隐藏了这
两个函数，也可以认为是他的一个小 bug 。那么我们如何查看 d 的虚表呢？下面我们使用代码打印
出虚表中的函数。 

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()
{
	Base b;
	Derive d;
	// 思路：取出b、d对象的头4bytes，就是虚表的指针，前面我们说了虚函数表本质是一个存虚函数
	指针的指针数组，这个数组最后面放了一个nullptr
		// 1.先取b的地址，强转成一个int*的指针
		// 2.再解引用取值，就取到了b对象头4bytes的值，这个值就是指向虚表的指针
		// 3.再强转成VFPTR*，因为虚表就是一个存VFPTR类型(虚函数指针类型)的数组。
		// 4.虚表指针传递给PrintVTable进行打印虚表
		// 5.需要说明的是这个打印虚表的代码经常会崩溃，因为编译器有时对虚表的处理不干净，虚表最
		后面没有放nullptr，导致越界，这是编译器的问题。我们只需要点目录栏的 - 生成 - 清理解决方案，再
		编译就好了。
		VFPTR * vTableb = (VFPTR*)(*(int*)&b);
	PrintVTable(vTableb);
	VFPTR* vTabled = (VFPTR*)(*(int*)&d);
	PrintVTable(vTabled);
	return 0;
}

 4.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;
}
观察下图可以看出： 多继承派生类的未重写的虚函数放在第一个继承基类部分的虚函数表中

4.3菱形继承、菱形虚拟继承

实际中我们不建议设计出菱形继承及菱形虚拟继承，一方面太复杂容易出问题，另一方面这样的

模型，访问基类成员有一定得性能损耗。所以菱形继承、菱形虚拟继承我们的虚表我们就不看
了，一般我们也不需要研究清楚，因为实际中很少用。可以去看下面的两篇链接文章。

5.继承和多态常见的面试问题

5.1 概念查考

1. 下面哪种面向对象的方法可以让你变得富有 ( )
A: 继承 B: 封装 C: 多态 D: 抽象
2. ( ) 是面向对象程序设计语言中的一种机制。这种机制实现了方法的定义与具体的对象无关，
而对方法的调用则可以关联于具体的对象。
A: 继承 B: 模板 C: 对象的自身引用 D: 动态绑定
3. 面向对象设计中的继承和组合，下面说法错误的是？（）
A ：继承允许我们覆盖重写父类的实现细节，父类的实现对于子类是可见的，是一种静态复
用，也称为白盒复用
B ：组合的对象不需要关心各自的实现细节，之间的关系是在运行时候才确定的，是一种动
态复用，也称为黑盒复用
C ：优先使用继承，而不是组合，是面向对象设计的第二原则
D ：继承可以使子类能自动继承父类的接口，但在设计模式中认为这是一种破坏了父类的封
装性的表现
4. 以下关于纯虚函数的说法 , 正确的是 ( )
A ：声明纯虚函数的类不能实例化对象 B ：声明纯虚函数的类是虚基类
C ：子类必须实现基类的纯虚函数 D ：纯虚函数必须是空函数
5. 关于虚函数的描述正确的是 ( )
A ：派生类的虚函数与基类的虚函数具有不同的参数个数和类型 B ：内联函数不能是虚函数
C ：派生类必须重新定义基类的虚函数 D ：虚函数可以是一个 static 型的函数
6. 关于虚表说法正确的是（ ）
A ：一个类只能有一张虚表
B ：基类中有虚函数，如果子类中没有重写基类的虚函数，此时子类与基类共用同一张虚表
C ：虚表是在运行期间动态生成的
D ：一个类的不同对象共享该类的虚表
7. 假设 A 类中有虚函数， B 继承自 A ， B 重写 A 中的虚函数，也没有定义任何虚函数，则（ ）
A ： A 类对象的前 4 个字节存储虚表地址， B 类对象前 4 个字节不是虚表地址
B ： A 类对象和 B 类对象前 4 个字节存储的都是虚基表的地址
C ： A 类对象和 B 类对象前 4 个字节存储的虚表地址相同
D ： A 类和 B 类虚表中虚函数个数相同，但 A 类和 B 类使用的不是同一张虚表
8. 下面程序输出结果是什么 ? （） 
#include<iostream>
using namespace std;
class A {
public:
	A(char* s) { cout << s << endl; }
	~A() {}
};
class B :virtual public A {
public:
	B(char* s1, char* s2) :A(s1) { cout << s2 << endl; }
};
class C :virtual public A {
public:
	C(char* s1, char* s2) :A(s1) { cout << s2 << endl; }
};
class D :public B, public C {
public:
	D(char* s1, char* s2, char* s3, char* s4) :B(s1, s2), C(s1, s3), A(s1)
	{
		cout << s4 << endl;
	}
};
int main() {
	D* p = new D("class A", "class B", "class C", "class D");
	delete p;
	return 0;
}
A ： class A class B class C class D B ： class D class B class C class A
C ： class D class C class B class A D ： class A class C class B class D
9. 多继承中指针偏移问题？下面说法正确的是 ( ) 
 class Base1 { public:  int _b1; };
class Base2 { public:  int _b2; };
class Derive : public Base1, public Base2 { public: int _d; };
int main() {
	Derive d;
	Base1* p1 = &d;
	Base2* p2 = &d;
	Derive* p3 = &d;
	return 0;
}
A ： p1 == p2 == p3 B ： p1 < p2 < p3 C ： p1 == p3 != p2 D ： p1 != p2 != p3
10. 以下程序输出结果是什么（） 
class A
{
public:
	virtual void func(int val = 1) { std::cout << "A->" << val << std::endl; }
	virtual void test() { func(); }
};

class B : public A
{
public:
	void func(int val = 0) { std::cout << "B->" << val << std::endl; }
};

int main(int argc, char* argv[])
{
	B* p = new B;
	p->test();
	return 0;
}
A: A->0 B: B->1 C: A->1 D: B->0 E: 编译出错 F: 以上都不正确

5.2 问答题

1. 什么是多态？ 
2. 什么是重载、重写 ( 覆盖 ) 、重定义 ( 隐藏 ) ？ 
3. 多态的实现原理？ 
4. inline 函数可以是虚函数吗？答：可以，不过编译器就忽略 inline 属性，这个函数就不再是
inline ，因为虚函数要放到虚表中去。
5. 静态成员可以是虚函数吗？答：不能，因为静态成员函数没有 this 指针，使用类型 :: 成员函数
的调用方式无法访问虚函数表，所以静态成员函数无法放进虚函数表。
6. 构造函数可以是虚函数吗？答：不能，因为对象中的虚函数表指针是在构造函数初始化列表
阶段才初始化的。
7. 析构函数可以是虚函数吗？什么场景下析构函数是虚函数？答：可以，并且最好把基类的析
构函数定义成虚函数。参考本节课件内容
8. 对象访问普通函数快还是虚函数更快？答：首先如果是普通对象，是一样快的。如果是指针
对象或者是引用对象，则调用的普通函数快，因为构成多态，运行时调用虚函数需要到虚函
数表中去查找。
9. 虚函数表是在什么阶段生成的，存在哪的？答：虚函数表是在编译阶段就生成的，一般情况
下存在代码段 ( 常量区 ) 的。
10. C++ 菱形继承的问题？虚继承的原理？答：参考继承。注意这里不要把虚函数表和虚基
表搞混了。
11. 什么是抽象类？抽象类的作用？答：参考（ 抽象类）。抽象类强制重写了虚函数，另外抽
象类体现出了接口继承关系。
ScarboroughFair#
关注
专栏目录
C++多态
weixin_50569901的博客
04-20 1万+
C++中的多态分为静态多态和动态多态两种，其中： 静态多态在编译阶段实现，其原理是由函数重载实现，通过不同的实参调用其相应的同名函数。 动态多态通过虚函数实现，以下着重介绍 动态多态的两个必要条件： 必须通过基类的指针或者引用调用 被调用的必须是虚函数，且在派生类中实现了该虚函数的重写 以下解释何为通过基类的指针或者引用调用 int main() { Person p; student s; Person &tmp1 = p; Person &tmp2 = s;//tm
C++多态Demo
05-01
这个“C++多态Demo”示例中，我们看到长方形和三角形作为形状（Shape）类的派生类，体现了面向对象编程中的继承和多态概念。 首先，让我们来理解一下基础的面向对象概念： 1. **类（Class）**: 类是创建对象的蓝图...
第十四课_读写内存
ELaXiaoSi的博客
10-24 2163
前言 今天讲讲汇编如何读写内存。 还有一件事，本id觉得，单单讲这些太无趣了，以后文章末尾加点东西，暂时叫《本id的梦话》，也想不出什么好名字了，内容不限，不过大多是生活吧，就算是记录一下自己的生活吧。 之前讲过第一条汇编指令，如：mov eax,0xFFFFFFFF,有自己在OD上练习的，这应该很熟悉。这个命令就是把十六进制的0xFFFFFFFF放到寄存器eax中。在汇编中我们把这种确切的数值（如这里的0xFFFFFFFF）称为立即数。 既然数能移到寄存器中，那如何移到内存中呢？也就是写到内.
直接调用类成员函数地址
桂林哈秋 - 我想学编程
03-24 1408
原文：http://www.vckbase.com/document/viewdoc/?id=1818一、成员函数指针的用法　　在C++中，成员函数的指针是个比较特殊的东西。对普通的函数指针来说，可以视为一个地址,在需要的时候可以任意转换并直接调用。但对成员函数来说，常规类型转换是通不过编译的，调用的时候也必须采用特殊的语法。C++专门为成员指针准备了三个运算符: "::*"用于指针的声明
C++指针与地址详解
Neo的专栏
09-21 1398
◆ 1、“存储器”的概念 文件柜-->文件柜上的抽屉-->抽屉上的编号 对应于： 存储器----->存储单元----->存储单元的地址 ◆ 2、存储器的使用 1）定义变量时，系统为变量分配相应的存储单元，通过变量名可以直接使用该存储单元。例如：     int x=5,y;     y=15; // y可以理解成该存储单元的当前名字 2) 通过存储单元的地址来使用该存储单元
汇编指令学习
三月泡生长在阳春三月天，把鲜红的美味奉献给世人
05-03 446
第一个例子： mov ax,bx //将寄存器AX的内容送到BX中 mov 0x1, %eax //将1传送到eax寄存器 add 0x2, %eax //将2与eax寄存器的值1相加，将将结果存入eax寄存器 第二个例子： mov 1, %eax //将1传送到eax寄存器，EAX 是"累加器"(accumulator), 它是很多加法乘法指...
C++ 多态 超详细讲解
热门推荐
qq_53558968的博客
05-18 5万+
文章目录多态概念引入1、C++中多态的实现1.1 多态的构成条件1.2 虚函数1.3虚函数的重写1.4 C++11 override && final1.5 重载，覆盖(重写)，重定义（隐藏）2、抽象类2.1 抽象类的概念2.2 接口继承和实现继承3、 多态的原理3.1 虚函数表3.2多态的原理3.3动态绑定与静态绑定4 、继承中的虚函数表4.1 单继承中的虚函数表4.2 多继承中的虚函数表other 一些有意思的题目 多态概念引入 多态字面意思就是多种形态。 我们先来想一想在日常生活中
C++多态详解
lim6ere的博客
03-29 814
我们知道C++语言的三大特性（封装，继承，多态）在之前的文章中我们已经学习了封装和继承，在这篇文章中我们将会学习到有关多态的相关问题。这两个关键字是c++11新增的🌟重载：同一作用域中，函数名相同，函数参数不同的函数🌟 重定义（隐藏）：父类和子类两个不同的作用域，只要父类和子类的函数名相同就可以。🌟重写（覆盖）：两个函数分别在子类和父类的作用域，两个函数必须是虚函数，这两个函数函数名，参数，返回值相同（有例外，特殊考虑）。🌟如果子类和父类中既满足重写又满足隐藏，重写优先。
C++多态的用法详解
分享学习的知识，记录我的技术成长道路
04-23 1万+
C++多态是在继承的基础上实现的，了解多态之前我们需要掌握一定的C++继承的知识，本文将介绍C++中多态的概念，构成条件以及用法。
c++多态 详解
qq_39117115的博客
03-09 1157
综上：如果满足多态，看指向对象的类型，调用这个类型的成员函数如果不满足多态， 看调用者类型，调用这个类型的成员函数解释：满足多态的情况下，我们定义Parent * p= new student，这个会调用Student的发生重写的函数我们定义Parent *p =new Parent ，这个会调用Parent中被重写的函数不满足多态的情况下，我们定义Student *s =new Student，这个会调用Student的函数。
C++多态的实现机制深入理解
12-26
在面试过程中C++的多态实现机制经常会被面试官问道。大家清楚多态到底该如何实现吗？下面小编抽空给大家介绍下多态的实现机制。 1. 用virtual关键字申明的函数叫做虚函数，虚函数肯定是类的成员函数。 2. 存在虚...
C++ 多态的游戏例程
01-20
1）头文件 game.h #ifndef GAME_H #define GAME_H // base class class CCreature { protected: int m_nLifePower， m_nPower; public: virtual void Attack(CCreature *pCreature){} virtual void Hurted...
C++ STL中sort函数
weixin_43349440的博客
09-15 423
刷题中经常遇到，用于各种元素排序，可以自定义排序方式，vector、deque适用。详细讲解：https://zhuanlan.zhihu.com/p/36274119。，为避免QuickSort快排的递归调用带来过大的额外负荷，就改用。一旦分段后的数据量小于某个门槛。STL的sort算法，
C++_map_set详解
2302_77644537的博客
09-16 1051
set是按照一定次序存储元素的容器在set中，元素的value也标识它(value就是key，类型为T)，并且每个value必须是唯一的。set中的元素不能在容器中修改(元素总是const)，但是可以从容器中插入或删除它们。在内部，set中的元素总是按照其内部比较对象(类型比较)所指示的特定严格的排序准则（默认是小于）进行排序。set在底层是用二叉搜索树(红黑树)实现的。map是关联容器，它按照特定的次序(按照key来比较)存储由键值key和值value组合而成的元素。
TMS Scripter Crack TMS Scripter is a Delphi C++ Builder
最新发布
q2315702359的博客
09-19 946
　　The integrated development environment or the IDE allows the users in process of creating script jobs during the runtime with the help of multiple cross-language scripts such as de Pascal and the Basics.　　It has support for the cross-utilization of the s
CCF201903_1
m0_67663419的博客
09-14 265
【代码】CCF201903_1。
在typescript浏览器端中调用C++编写的函数，WebAssembly传递指针类型的参数，以及处理指针类型的返回值。
Xeon_CC的博客
09-17 435
最后是返回一个C++结构体指针，在TypeScript中通过DataView来获取内存中的地址偏移量来取得结构体中的数据，因为em++编译器是以32位来编译.cpp文件的，所以指针占4个字节。DataResult结构体第一个属性dArr是一个指针，那么就是地址偏移量0，然后以32位无符号整型取得dArr指针，通过这个指针去读取wasm中memoryBuffer中的数据，就可以得到dArr属性对应的值了。同理，通过地址偏移量+4来得到propCount属性，以32位整数读取数据即可。
c++ 多态
05-25
C++中的多态（Polymorphism）是指在父类和子类之间的相互转换，以及在不同对象之间的相互转换。 C++中的多态性有两种：静态多态和动态多态。 1. 静态多态 静态多态是指在编译时就已经确定了函数的调用，也称为...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值