【C++】多态

已于 2024-05-22 22:45:27 修改
阅读量1.1k 收藏 22
点赞数 34
分类专栏： C++学习 文章标签： c++
于 2024-05-05 21:56:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_73914025/article/details/136573958
版权

文章目录

 
 
 

1. 多态的概念

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

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

 
 

2. 多态的定义及实现

2.1 多态的构成条件

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

那么在继承中要构成多态还有两个概念：

  1. 必须通过基类的指针或者引用调用虚函数。
  2. 被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写。
    在这里插入图片描述

 

2.2 虚函数

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

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

 

2.3 虚函数的重写

虚函数的重写(覆盖)：派生类中有一个跟基类完全相同的虚函数(即派生类虚函数与基类虚函数的返回值类型、函数名字、参数列表完全相同)，称子类的虚函数重写了基类的虚函数。在重写基类虚函数时，派生类的虚函数在不加virtual关键字时，也可以构成重写，因为继承后基类的虚函数被继承下来了在派生类依旧保持虚函数属性（换句话说，重写是重写函数的实现，声明不变）。

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;
}

在这里插入图片描述
在这里我们区分一下重载、覆盖（重写）、隐藏（重定义）的对比。
在这里插入图片描述
来看一道比较坑的题目：

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:以上都不正确

在这里插入图片描述

结果是选B，因为上面说过，重写是重写函数的实现内容，声明还是继承基类的，所以这里基类的声明时缺省参数val的值是1，所以实现出来就是B->1。这道题是为了考而出的题，实际我们肯定不能写出这么挫的代码。

再来看一道题目：

// 以下程序输出的结果是：
class A
{
public:

  A() :m_iVal(0) { test(); }

  virtual void func() { std::cout << m_iVal << ' '; }

  void test() { func(); }

public:

  int m_iVal;

};
class B : public A

{

public:

	B() { test(); }

	virtual void func()

	{

		++m_iVal;

		std::cout << m_iVal << ' ';

	}

};

int main(int argc, char* argv[])

{

	A* p = new B;

	p->test();

	return 0;

}

分析：new B时先调用父类A的构造函数，执行test()函数，在调用func()函数，由于此时还处于对象构造阶段，多态机制还没有生效，所以，此时执行的func函数为父类的func函数，打印0，构造完父类后执行子类构造函数，又调用test函数，然后又执行func(), 由于父类已经构造完毕，虚表已经生成，func满足多态的条件，所以调用子类的func函数，对成员m_iVal加1，进行打印，所以打印1， 最终通过父类指针p->test(), 也是执行子类的func, 所以会增加m_iVal的值，最终打印2， 所以答案为 0 1 2

 

2.4 虚函数重写的两个例外

  1. 协变（基类与派生类虚函数返回值类型不同）（了解一下）
    在C++中，协变是指派生类中的返回值类型可以是基类返回类型的子类型（返回值可以是其他的继承关系的父子类）。换句话说，如果一个虚函数在基类中的返回的是父类类型的指针或引用，那么派生类可以重写该虚函数并返回基类类型的子类型的指针或引用。
    协变在 C++中是通过使用返回类型协变（return type covariance）来实现的。返回类型协变是指派生类中重写的虚函数可以具有比基类更具体的返回类型。为了实现协变，需要满足以下条件：
  • 基类中的函数必须是虚函数（使用 virtual 关键字声明）。
  • 派生类中重写的函数必须具有相同的函数签名（函数名、参数列表和常量性）。
  • 派生类中重写的函数的返回类型必须是基类函数返回类型的子类型。
    下面是一个简单的代码示例：
// 定义一组继承类
class A
{
public:
	int _a = 1;
};
class B : public A
{
public:
	int _b = 10;
};


// 定义另外一组继承类
class base
{
public:
	// 返回类型是第一组继承类的基类类型指针
	virtual A* fun()
	{
		return new A;
	}
};
class derived : public base
{
public:
	// 返回类型是第一组继承类的派生类类型指针
	virtual B* fun()
	{
		return new B;
	}
};
int main()
{
	base ba;
	derived de;

	A* a = ba.fun();
	B* b = de.fun();
	cout << (*a)._a << endl;
	cout << (*b)._b << endl;

	return 0;
}

在这里插入图片描述

  1. 析构函数的重写(基类与派生类析构函数的名字不同)
    如果基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加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;
}

 

2.5 override 和 final

从上面可以看出，C++对函数重写的要求比较严格，但是有些情况下由于疏忽，可能会导致函数名字母次序写反而无法构成重载，而这种错误在编译期间是不会报出的，只有在程序运行时没有得到预期结果才来debug会得不偿失，因此：C++11提供了override和final两个关键字，可以帮助用户检测是否重写。

  1. final：修饰虚函数，表示该虚函数不能再被重写
    在这里插入图片描述
  2. override：检查派生类虚函数是否重写了基类某个虚函数，如果没有重写编译报错
    在这里插入图片描述

 
 

3. 抽象基类

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

 

3.2 接口继承和实现继承

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

 
 

4. 多态的原理

4.1 虚函数表

C++中的虚表（Virtual Function Table）是在编译期间生成的。在编译阶段，编译器会为每个包含虚函数的类创建一个虚表，该表中存放着类中虚函数的地址。当程序运行时，编译器会将具体的某个虚函数的首地址赋值给虚函数表内部的函数指针。

// 这里常考一道笔试题：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. 总结一下派生类的虚表生成：
    • 先将基类中的虚表内容拷贝一份到派生类虚表中
    • 如果派生类重写了基类中某个虚函数，用派生类自己的虚函数覆盖虚表中基类的虚函数
    • 派生类自己新增加的虚函数按其在派生类中的声明次序增加到派生类虚表的最后。

我们来看一个问题，虚函数是存在哪里的？虚表又是存在哪里的？
从上面调试窗口这张图，我们可以看出，Base类对象和Derive类对象的前四个字节存的就是虚函数表，而虚函数的指针是存放在虚函数表内的。
那我们写一段代码看一下虚表，和虚函数是在哪个位置：

typedef void (*vf_ptr)(); // 将形参和返回值都为void的函数指针重命名为vf_ptr

void printVfTable(vf_ptr* VfTable)
{
	// 注意:这里我是故意这样设计的,
	// 实际中的虚函数返回类型和形参可能各不相同,
	// 所以就不能用这样的方式来获取虚函数的地址
	for (int i = 0;VfTable[i] != nullptr;++i)
	{
		printf("第%d个虚函数地址:0x%p->", i, VfTable[i]);
		vf_ptr f = VfTable[i];
		f();
	}
	cout << endl;

}

int main()
{
	static int s = 0;  // 数据段
	int i = 0;  // 栈区
	const char* str = "XXX"; // 代码段
	double* d = new double(1.11); // 堆区

	Base b;
	Derive de;

	printf("数据段:%p\n", &s);
	printf("栈区:%p\n", &i);
	printf("代码段:%p\n", str);
	printf("堆区:%p\n\n", d);

	printf("Base虚函数表:%p\n", *(int*)&b); // 取b对象的前四个字节解引用
	printVfTable((vf_ptr*)(*(int*)&b)); // 这里这样写的目的是,取出b对象前四个地址,强转为vf_ptr*类型,这样做才能正常传参

	printf("Derive虚函数表:%p\n", *(int*)&de); // 取de对象的前四个字节解引用
	printVfTable((vf_ptr*)(*(int*)&de)); // 与上同理
	return 0;
}

我在这里解释一下这串代码的意思：
 
首先，我先定义了一些变量，这些变量分别散布在数据段、栈区、代码段、堆区。
 
随后，我想拿到b对象虚表的位置，由于我在前面调试窗口看到，在VS中，虚表指针是存在b对象的第一个位置，所以在x86平台下，我想拿到虚表指针，我就得拿到b对象的前四个字节，所以我将b的地址强制转换为int*，然后再进行解引用就拿到了前四个字节。
 
最后，我构造了一个函数（打印出虚函数的地址），因为这里我是故意将前面这些类的虚函数都写成返回值和形参类型都是void的函数，所以，我在这里将void(*)()的函数指针类型重命名为vf_ptr。由于虚函数是存在虚表里面。所以，printVfTable(vf_ptr* VfTable)函数的目的就是将虚表传过去，然后将虚表里面的函数按顺序打印出来。为了能够传参过去，所以将b对象的前四个字节强制转化成vf_ptr*（因为我们是将虚表传过去，虚函数是存在虚函数表中，所以这里是用虚函数的函数指针接收）。
 
对象de的分析与对象b同理。

 

4.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. 再通过下面的汇编代码分析，看出满足多态以后的函数调用，不是在编译时确定的，是运行起来以后到对象的中取找的。不满足多态的函数调用时编译时确认好的。
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;
	mike.BuyTicket(); // 普通调用

	Func(&mike);
	return 0;
}

在这里插入图片描述
ps：这里汇编代码我只截取了一部分来解释这里的过程，所以并不全。这里体现出了普通调用是在编译时就已经从符号表确认了函数的地址，所以直接call函数的地址，而多态调用不是在编译时确定的，是运行起来以后到对象的虚函数表中去找到再call的。

 

4.3 动态绑定与静态绑定

  1. 静态绑定又称为前期绑定(早绑定)，在程序编译期间确定了程序的为也称为静态多态，比如：函数重载，模版泛型机制
  2. 动态绑定又称后期绑定(晚绑定)，是在程序运行期间，根据具体拿到的类型确定程序的具体行为，调用具体的函数，也称为动态多态。

 
 

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

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

5.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;
};

int main()
{
	Base b;
	Derive d;
	return 0;
}
};

观察下图中的监视窗口中我们发现看不见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;
}

在这里插入图片描述

 

5.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;
}

观察下图可以看出：多继承派生类的未重写的虚函数放在第一个继承基类部分的虚函数表中
在这里插入图片描述
注意：这里有个细节，不知道大家看到没有，在上图中，我们可以看到，这两张虚函数表中的第一个虚函数的地址并不相同，这是为什么？
函数的地址一般是指向函数编译为一串指令时的第一串指令的地址。所以这里想要分析这个问题就得看一看汇编。
在这里插入图片描述

从我截的这一部分图来看，这里可以看到其实它们如果是调用func1，它们最终调用的是同一个函数，只过不是使用Base2调用的时候，它多了一个指令。简单来说就是使用Base1调用的时候是直接调用，使用Base2调用的时候绕路了，那么它为什么要这样做呢，还有那个ecx为什么要sub8呢？
在这里插入图片描述

通过这张图可以看到，&d和p1是相等的，所以我们去调用func1，就是去Base1切片的那个位置。如果我们直接使用p2去调用的func1函数的话，那么通过切片，就会指向中间那个位置。所以我们使用Base2去调用时，它会先将ecx去sub一个数（ecx是用来修饰this指针的，这里相当于将this指针向前移动8位），这个数就是Base2距离Base1的位置。所以最后我们可以看到它们去调用func1时，其实还是调用同一个函数。

 

Hyt的笔记本
关注
专栏目录
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）**: 类是创建对象的蓝图...
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++ 多态
jun8086的博客
10-31 638
c++ 多态
C++多态的用法详解
分享学习的知识，记录我的技术成长道路
04-23 1万+
C++多态是在继承的基础上实现的，了解多态之前我们需要掌握一定的C++继承的知识，本文将介绍C++中多态的概念，构成条件以及用法。
C++多态详解
lim6ere的博客
03-29 803
我们知道C++语言的三大特性（封装，继承，多态）在之前的文章中我们已经学习了封装和继承，在这篇文章中我们将会学习到有关多态的相关问题。这两个关键字是c++11新增的🌟重载：同一作用域中，函数名相同，函数参数不同的函数🌟 重定义（隐藏）：父类和子类两个不同的作用域，只要父类和子类的函数名相同就可以。🌟重写（覆盖）：两个函数分别在子类和父类的作用域，两个函数必须是虚函数，这两个函数函数名，参数，返回值相同（有例外，特殊考虑）。🌟如果子类和父类中既满足重写又满足隐藏，重写优先。
c++多态 详解
qq_39117115的博客
03-09 1153
综上：如果满足多态，看指向对象的类型，调用这个类型的成员函数如果不满足多态， 看调用者类型，调用这个类型的成员函数解释：满足多态的情况下，我们定义Parent * p= new student，这个会调用Student的发生重写的函数我们定义Parent *p =new Parent ，这个会调用Parent中被重写的函数不满足多态的情况下，我们定义Student *s =new Student，这个会调用Student的函数。
C++ 多态类型
索命的博客
11-06 495
C++ 多态入门
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 167
刷题中经常遇到，用于各种元素排序，可以自定义排序方式，vector、deque适用。详细讲解：https://zhuanlan.zhihu.com/p/36274119。，为避免QuickSort快排的递归调用带来过大的额外负荷，就改用。一旦分段后的数据量小于某个门槛。STL的sort算法，
CF C. Nikita and LCM
qq_74190237的博客
09-13 264
思维题.首先先对数组排序,考虑一种特殊情况,那就是如果数组最大值不能被其他数整除,这代表什么?代表其他数里面有某个质因子,最大值里面没有或者数量不管,所有最小公倍数都会大于最大值.那么其他情况的话,就可以确定所有的数都是最大数的因子,那么形成的最小公倍数也一定是最大数的因子,那么就可以枚举一下最大数的因子,就可以了.给长度为n的数组,求出最长的特殊子数组,如果子数组的最小公倍数不在原数组中,那么就是特殊的.
C++与QML的数据交互
qq_50679120的博客
09-11 520
这里没什么好说的，在C++中组合好json后，通过信号发送到qml中，qml中是可以解析json的。通过Q_PROPERTY属性，可以轻松地在QML中读取和修改数据，并将其更新到C++中，先创建一个类。在QML接收，直接通过data.can_id这样的形式去访问结构体中的元素。这两个也没什么好说的，在C++中直接发送信号就好了，在C++中声明并注册一个结构体。然后发送信号到QML中。
【C++】【网络】【Linux系统编程】单例模式，加锁封装TCP/IP协议套接字
2301_79796701的博客
09-16 859
给系统，表明这个套接字所期望的、还未处理的（即还在等待被接受的连接）连接请求的最大队列长度。换句话说，它告诉系统内核为这个套接字分配多大的空间来存储尚未处理的连接请求。有关套接字编程的细节和更多的系统调用课参考《UNIX环境高级编程》一书，可以在如下网站搜索电子版，该书在第16章详细的介绍了各种接口。我们可以根据自己的需求，用面向对象的思想封装出接口简洁的类。在类似添加一个该类类型的指针，该指针是静态的并且是私有成员。结构体填充，为了使不同的地址格式能和套接字绑定，需要把对应的结构体强转成通用地址结构。
C++_map_set详解
最新发布
2302_77644537的博客
09-16 626
set是按照一定次序存储元素的容器在set中，元素的value也标识它(value就是key，类型为T)，并且每个value必须是唯一的。set中的元素不能在容器中修改(元素总是const)，但是可以从容器中插入或删除它们。在内部，set中的元素总是按照其内部比较对象(类型比较)所指示的特定严格的排序准则（默认是小于）进行排序。set在底层是用二叉搜索树(红黑树)实现的。map是关联容器，它按照特定的次序(按照key来比较)存储由键值key和值value组合而成的元素。
C语言从头学59——学习头文件math.h（二）
m0_72128260的博客
09-11 511
继续学习头文件的数学函数。
【C++ && Qt day11】
wzj46的博客
09-11 274
2、头文件窗口文件。
C++ Qt开发：运用QJSON模块解析数据
qq_35662333的博客
09-11 1063
转载Qt 是一个跨平台C++图形界面开发库，利用Qt可以快速开发跨平台窗体应用程序，在Qt中我们可以通过拖拽的方式将不同组件放到指定的位置，实现图形化开发极大的方便了开发效率，本章将重点介绍如何运用QJson组件的实现对JSON文本的灵活解析功能。JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，它易于人阅读和编写，也易于机器解析和生成。该格式是基于JavaScript语言的一个子集，但它是一种独立于语言的数据格式，因此可以在许多不同的编程语言中使用。
c++ 多态
05-25
C++中的多态（Polymorphism）是指在父类和子类之间的相互转换，以及在不同对象之间的相互转换。 C++中的多态性有两种：静态多态和动态多态。 1. 静态多态 静态多态是指在编译时就已经确定了函数的调用，也称为...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Hyt的笔记本

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

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

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

打赏作者

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

抵扣说明：

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

余额充值