『C++进阶』第二章--- 多态

最新推荐文章于 2024-08-28 14:35:43 发布
最新推荐文章于 2024-08-28 14:35:43 发布
阅读量1k 收藏 23
点赞数 26
分类专栏： C++进阶知识 文章标签： c++ 开发语言 c语言 面试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_54443558/article/details/140662574
版权

目录

1.多态的概念

  1.1 概念

2. 多态的定义及实现

  2.1 多态的构成条件

2.2 虚函数

2.3 虚函数的重写

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

 2.析构函数的重写（基类与派生类析构函数的名字不同）

2.4 C++11 override 和final

2.5 重载、覆盖（重写）、隐藏（重定义）的对比

 3. 抽象类

      3.1 概念

3.2 接口继承和实现继承

4. 多态的原理

  4.1 虚函数表

4.2 多态的原理

4.3 动态绑定与静态绑定

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

5.1 单继承中的虚函数表

 5.2 多继承中的虚函数表

 5.3 菱形继承、菱形虚拟继承

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

  6.1 概念查考

6.2 问答题

1.多态的概念

  1.1 概念

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

   举个例子： 比如买票这个行为，当普通人买票时，是全价买票；学生买票时，是半价买票；军人买票时是优先买票。

    这就是多态，不同对象去完成同一件动作时，产生的是不同的形态。

2. 多态的定义及实现

  2.1 多态的构成条件

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

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

        1.  必须通过基类的指针或者引用 调用虚函数。

        2.  被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写。

2.2 虚函数

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

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

2.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 Test1(Person& p)
{
	p.BuyTicket();
}
void Test2(Person* p)
{
	p->BuyTicket();
}

int main()
{
	Person p;
	Student s;
	
	Test1(p); // 全价
	Test1(s);  // 半价

	Person& rp = p;
	Student& rs = s;

	Test1(rp); // 全价
	Test1(rs);  // 半价

	rp = s;
	Test1(rp);   // 全价
	rs =(Student&) p;
	Test1(rs);   // 半价

	Person* pp=&p;  
	Student* ps=&s;   

	Test2(pp);  // 全价
	Test2(ps);  // 半价

	p = s;
	Test1(p);  // 输出为全价，派生类切片赋值给基类，但本质上还是基类

	pp = &s;
	Test2(pp);  //半价   pp虽然是基类指针，但他指向派生类，所以输出是半价

	//ps = &p;
	//ps =(Student*) & p;
	
	// 子类对象可以直接切片赋值给父类对象  
	// 子类指针不能直接指向父类对象地址,但是可以强行转换成子类指针赋值，虽然这样可以，但是会存在越界问题
	// 子类引用同样不能直接赋值父类对象，但是可以通过强转完成赋值
	// 父类对象不能直接赋值给子类对象
	// 父类指针可以指向子类对象地址，实现调用子类的多态功能
	// 父类引用可以直接引用子类对象，但是调用的还是父类的多态


	return 0;
}

虚函数重写的两个例外：

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

          派生类重写基类虚函数时，与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指针或者引用，派生类虚函数返回派生类对象的指针或者引用时，称为协变（了解）

         

class A{};
class B :public A {};

class Person {
public:
	virtual A* f() { cout << "A" << endl; return new A; }
};

class Student:public Person {
public:
	virtual B* f() { cout << "B" << endl; return new B; }
};

int main()
{
	Person p;
	Student s;
	p.f();
	s.f();
	Person* pp = &s;
	pp->f();

	return 0;
}

 2.析构函数的重写（基类与派生类析构函数的名字不同）

     如果基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加virtual关键字，都与基类的析构函数构成重写，虽然基类与派生类析构函数名字不同。虽然函数名不相同，看起来违背了重写的规则，其实不然，这里可以理解为编译器对析构函数的名称做了特殊处理，编译后析构函数的名称统一处理成destructor。

class Person
{
public:
	virtual ~Person() { cout << "~Person()" << endl; }
};
class Student :public Person
{
public:
	~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.4 C++11 override 和final

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

  1.   final：修饰虚函数，表示该虚函数不能再被重写

class Car
{
public:
	virtual void Drive() final {}
};
class Benz : public Car
{
public:
	virtual void Drive() { cout << "Benz-舒适" << endl; }
	// 报错   无法重写final函数
};

  2.  override： 检查派生类虚函数是否重写了基类某个虚函数，如果没有重写，编译报错。

class Car
{
public:
	virtual void Drive()  {}
};
class Benz : public Car
{
public:
	virtual void Drive()  override { cout << "Benz-舒适" << endl; }
};

2.5 重载、覆盖（重写）、隐藏（重定义）的对比

 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 虚函数表

{
public:
	virtual void Func1()
	{
		cout << "Func1()" << endl;
	}
private:
	int _b = 1;
};

 通过观察测试我们发现b对象是8bytes,除了_b成员，还多一个_vfptr放在对象的前面（注意有些平台可能会放到对象的最后面，这个跟平台有关，对象中的这个指针我们叫做虚函数表指针（v代表virtual，f代表function）。一个含有虚函数的类中都至少都有一个虚函数表指针，因为虚函数的地址要放到虚函数表中，虚函数表也简称为虚表。那么派生类中这个表放了些什么呢？ 我们接着看

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++ 下

测试代码：

int main()
{
	Base b;
	Derive d;
	int a;
	int* pa = new int;
	static int  t = 1;
	const char* ch = "1231";

	cout << "栈：" << &a << endl;
	printf("常量区：%p\n", ch);
	cout << "堆：" << pa << endl;
	cout << "静态区：" << &t << endl;
	printf("Base虚表位置:%p\n", *(int*)&b);   //因为虚表指针位于对象的前四个字节，因为Base 无法直接转换为int类型，因为指针都是相同字节的，所以可以相互转换，所以可以转成int* 然后重载前四个字节就得到了虚表的地址位置
	printf("Derive 虚表位置:%p\n", *(int*)&d);   // 因为cout重载的问题，给一个指针，可能会打印指针的值例如打印字符串，可以通过字符串首字符指针，来打印整个字符，所以这里采用printf来打印
	cout << "Base对象位置："<< & b << endl;      //因为虚表指针位于对象中，所以知道对象的地址也就知道了虚表指针的位置
	cout << "Derive 对象位置："<< & d << endl;

	return 0;

}

如图，可以知道虚表位置位于常量区也就是代码段，对象位置位于栈上 

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对象时，而mike对象是一个Person类型，p->BuyTicket在mike的虚表中找到虚函数是Person::BuyTicket。
  2. 观察下图的蓝色箭头我们可以看到，p是指向johnson对象时，而johnson对象是一个Student类型，p->BuyTicket在johson的虚表中找到虚函数是Student::BuyTicket。
  3. 这样就实现出了不同对象去完成同一行为时，展现出不同的形态。
  4. 反过来思考我们要达到多态，有两个条件，一个是虚函数覆盖，一个是对象的指针或引用调用虚函数。反思一下为什么？
  5.  再通过下面的汇编代码分析，看出满足多态以后的函数调用，不是在编译时确定的，是运行起来以后到对象的中去找的。不满足多态的函数调用是编译时确认好的。

class Person
{
public:
	virtual void BuyTicket()
	{
		cout << "Person::BuyTicket()" << endl;
	}
	virtual void func2() {}

};
class Student:public Person
{
	virtual void BuyTicket()
	{
		cout << "Student::BuyTicket()" << endl;
	}
	virtual void func2() {}

};

void Func(Person* p)
{
	p->BuyTicket();
}
void Test(Person* p)
{
	p->func2();
}
int main()
{
	Person mike;
	Func(&mike);
	Test(&mike);

	Student s;
	Func(&s);

	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)
...
}

4.3 动态绑定与静态绑定

  1. 静态绑定又称为前期绑定（早绑定），在程序编译期间确定了程序的行为，也称为静态多态，比如：函数重载
  2. 动态绑定又称后台绑定（晚绑定），是在程序运行期间，根据具体拿到的类型确定程序的具体行为，调用具体的函数，也称为动态多态。
  3. 之前的（4.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;
};

观察下图的监视窗口中我们发现看不到func3和func4。这里是编译器的监视窗口故意隐藏了这两个函数，也可以认为是他的一个小bug。那么我们如果查看d的虚表呢？下面我们使用代码打印出虚表中的函数。

 

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

观察下图可以看出：多继承派生类的未重写的虚函数放在第一个继承基类部分的虚函数表中 

 5.3 菱形继承、菱形虚拟继承

        实际中我们不建议设计出菱形继承及菱形虚拟继承，一方面太复杂容易出问题，另一方面这样的模型，访问基类成员有一定的性能损耗。所以菱形继承、菱形虚拟继承我们的虚表我们就不看了，一般我们也不需要研究清楚，因为实际中很少用，当然，可以通过下面两篇文章，自行了解。

C++虚函数表解析

C++对象的内存布局

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

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

参考答案：
1. A 2. D 3. C 4. A 5. B
6. D 7. D 8. A 9. C 10. B

6.2 问答题

  1. 什么是多态？ 答： 就是当不同的对象去完成同一个行为时会产生出不同的形态。
  2. 什么是重载、重写（覆盖）、重定义（隐藏）？ 答：参考上面内容
  3. 多态的实现原理？ 答：参考上述内容
  4. inline函数可以是虚函数吗？ 答： 可以，不过编译器就会忽略inline属性，这函数就不再是inline，因为虚函数要放到虚表中去。（所有类成员函数和非成员函数代码存放在代码区；为运行函数而分配的局部变量、函数参数、返回数据、返回地址等存放在栈区）
  5. 静态成员可以是虚函数吗？ 答：不能，因为静态成员函数没有this指针，使用类型:: 成员函数的调用方式无法访问虚函数表，所以静态成员函数无法放进虚函数表
  6. 构造函数可以是虚函数吗？ 答：不能，因为对象中的虚函数表指针是在构造函数初始化列表阶段才初始化的。
  7. 析构函数可以是虚函数吗？ 什么场景下析构函数是虚函数？ 答：可以，并且最好把基类的析构函数定义成虚函数。
  8. 对象访问普通函数快还是虚函数快？ 答： 首先如果是普通对象，是一样快的。如果是指针对象或者是引用对象，则调用的普通函数快，因为构成多态，运行时调用虚函数需要到虚函数表中去查找
  9. 虚函数是在什么阶段生成的，存在哪的？ 答： 虚函数表是在编译阶段就生成的，一般情况存在代码段（常量区）的。
  10. C++菱形继承的问题？虚继承的原理？ 答：参考上一章内容。注意这里不要把虚函数表和虚基表搞混了
  11. 什么是抽象类？抽象类的作用？ 答： 参考（3.抽象类）。 抽象类强制重写了虚函数，另外抽象类体现了接口继承关系。

Dklau-c
关注
  • 26
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++进阶：多态
欧尼酱的技术园
07-29 299
文章目录前言一，多态的概念1.1 概念二，多态的定义及实现2.1 多态的构成条件2.2 虚函数2.3 虚函数的重写2.4 重载，覆盖（重写），隐藏（重定义）的对比三， 抽象类四，多态的原理4.1 虚函数表4.2 动态绑定与静态绑定五，常见问题总结 前言 本文章将为大家介绍多态的内容，多态是C++高级语法的核心部分，希望大家重视起来。 一，多态的概念 1.1 概念 多态的概念：通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。 例如：同样是扫码抢红包，不同的用户得到的
C++ 基础 --多态
Iiverson2000的博客
10-13 292
C++--多态多态多态的概念多态的定义虚函数虚函数的重写虚函数重写的两个例外C++11 override 和 final重载、重写（覆盖）、隐藏（重定义）对比 多态 多态的概念 当完成某个行为时，不同的对象去完成，会有不同的状态 举个小栗子：买票这个行为，学生买会有打折，普通人买全价票，军人可以优先购票 —多态性为 多态分为静态多态和动态多态，其中静态多态就是我们所熟知的函数重载。这里静态的含义是指：在编译期间完成的事件 而我们今天主要了解的是动态多态，也就是在进程运行期间的多态。 多态的定义 多态是不同
C++进阶-多态
~
01-30 1864
【C++进阶学习】C++中的多态零、前言一、多态的概念和定义二、虚函数1、概念和定义2、虚函数重写的特例3、C++11 override 和 final4、重载/重写/重定义对比三、抽象类四、多态的原理1、虚函数表2、多态的原理3、动态绑定与静态绑定4、多继承虚函数表五、继承和多态常见的面试问题 零、前言 C++有五大特性：对象，封装，继承，抽象和多态。而本章则将学习讲解C++中的多态 一、多态的概念和定义 概念： 通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同
『C++进阶』第一章--- 继承
m0_54443558的博客
07-23 858
C++ 继承的详细解释
《Visual C++程序员成长攻略》-戴博-源代码-第5章.rar
05-19
学习如何编写和使用模板是C++进阶的重要一步。 5. **文件操作**：C++提供了丰富的I/O流库用于读写文件，这是任何实际应用项目中不可或缺的部分。第5章可能包含读写文本文件或二进制文件的实例。 6. **MFC...
新标准C++程序设计教材11-20章课后题答案
11-14
《新标准C++程序设计教材11-20章课后题答案》是针对C++初学者和进阶者的一份宝贵资源，由知名讲师郭炜编写。这份资料详尽解答了教材中后半部分（第11至20章）的所有课后习题，涵盖了C++语言的核心概念和高级特性，...
C++Primer（第4版）-课后习题答案.pdf
11-01
2. 第二章变量和基本类型：讲解C++中的基本数据类型，如整型、浮点型、字符型等，以及变量的声明、初始化和作用域。 3. 第三章标准库类型：介绍C++标准库中的容器，如`std::string`用于处理字符串，`std::complex`...
VC++6.0从入门到精通第二版实例代码1-6章
03-06
2. 第二章：基本数据类型与运算符 - 基本数据类型（整型、浮点型、字符型等） - 运算符的种类（算术、赋值、比较、逻辑等） - 常量与变量的概念及用法 - 类型转换的规则 3. 第三章：流程控制语句 - 条件语句...
《Visual C++程序员成长攻略》-戴博-源代码-第1章
05-19
在《Visual C++程序员成长攻略》一书中，作者戴博为我们揭示了Visual C++编程的基础与进阶知识。本章的源代码旨在帮助读者更好地理解并实践VC++的基本工程构建和编程技巧。以下是对这些知识点的详细阐述： 1. **...
windows C++-windows C++/CX简介(六)
苏洛的博客
08-23 711
windows C++/CX介绍
【C++】链表
qq_38801607的博客
08-22 1085
链表是一种常见的动态数据结构，与数组相比，它在插入和删除操作中具有更高的效率。链表的每个元素称为节点（Node），节点包含两个部分：数据域（存储数据）和指针域（指向下一个节点的指针）。链表的最大特点是节点的内存位置不需要连续，可以通过指针来链接在一起。
【C/C++】C++程序设计基础（输入输出、数据类型、动态内存、函数重载、内联函数、常量、引用）
最新发布
强者征服今天，懦夫哀叹昨天，懒汉坐等明天。
08-28 391
在后面的章节中，会讲到类与对象，欢迎各位的关注~
C++ 重载运算符和重载函数
lly202406的博客
08-25 934
在C++编程语言中，运算符重载和函数重载是两个非常核心的概念，它们允许开发者扩展或重新定义运算符和函数的行为，以适应特定的数据类型或对象。本文将详细探讨C++中的运算符重载和函数重载，包括它们的基本概念、使用场景、实现方式以及注意事项。
C语言破墙镐对称飞迷宫
qq_69383179的博客
08-22 1784
这里有我用C语言编译的破墙镐对称飞迷宫和与之相关的一些东西
C++语言特性常见问题
wuxiaoyu0806的博客
08-25 618
循环引用是指两个或多个对象相互持有对方的，导致内存无法释放。解决方案是将其中一个改为，从而打破循环引用，避免内存泄漏。引用计数的引用计数在创建、复制、移动和销毁时发生变化，用于管理对象的生命周期。弱引用计数的弱引用计数在创建、复制、移动和销毁时变化，不影响对象的生命周期，但用于监控对象是否仍然存在。当最后一个被销毁时，引用计数归零，对象会被销毁并释放内存。
初识顺序表---C语言
weixin_74202161的博客
08-23 680
顺序表是一种以数组为基础的结构，对数组进行封装，实现常用的增删改查等操作的。//销毁。
＜C++＞ 多态
prodigy623的博客
08-24 1169
多态的细节
适用于 Visual Studio 的 C++ 万能头
Xi Xu 的博客
08-25 433
修改版本是根据 GNU General Public License v3.0 or later 分发的。原始文件是根据 GNU General Public License v3.0 or later 分发的。用于在 Visual Studio 上预编译的 C++ 包含。文件的修改版本，与 Visual Studio 兼容。此文件是 GCC 13.1.0 中。此文件的配置方法可在互联网上搜索。修改由本文作者完成。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值