C++13继承多态虚函数

原创 于 2025-03-27 14:21:12 发布 · 199 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++ #开发语言

1.继承的本质

// 20190420.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include "pch.h"
#include <iostream>
#include <typeinfo>
#include <string>
using namespace std;

/*
继承和多态
1.解释多态
2.RTTI
3.private和protected的区别  继承结构中

继承的本质：代码复用
1.派生类中，从基类继承来的成员的访问限定是什么？
			基类的访问限定			派生类的访问限定     main函数
public
				public				public			yes
				protected			protected		no
				private				不可访问		    no
protected
				public				protected		no
				protected			protected		no
				private				不可访问			no
private
				public				private			no
				protected			private			no
				private				不可访问			no

2.派生类怎么初始化从基类继承来的成员呢？
	通过调用基类相应的构造函数进行初始化，派生类只会初始化自己的成员

3.重载，隐藏，覆盖（基类和派生类同名成员函数之间的关系）
重载：
函数名  参数列表  作用域  =》 重载函数

隐藏：
基类和派生类当中   函数名相同   =》 隐藏

覆盖/重写：
基类和派生类当中  函数的返回值，函数名，参数列表都相同，而且基类的
函数是virtual虚函数，那么称作覆盖关系

4.  继承结构种，默认支持下到上的类型转换
》》》 基类对象  =》 派生类对象    no
》》》 派生类对象  =》  基类对象   yes
》》》 基类指针/引用 =》 派生类对象   yes
》》》 派生类指针/引用 =》 基类对象    no

5. 请解释静态（运行）绑定（函数调用）和动态（运行）绑定（函数调用）
		call 
		call ecx
6. 什么是多态
静态（编译阶段）的多态:函数重载和模板
动态（运行阶段）的多态:虚函数
多态的好处

====》  简单工厂，工厂方法和抽象工厂设计模式  代码  各自的优缺点  

7. RTTI运行时的类型信息
RTTI指针存储在虚函数表vftable当中，指向一段类型字符串

8. 抽象类（不能实例化对象Animal a;）和普通类

9. 析构函数能不能实现成虚函数？？？
能不能成为虚函数 =》  记录函数地址（vftable）/vfptr（对象）
      对象  地址
virtual 构造函数  no 在构造函数中调用virutal虚函数，请问是静态绑定还是动态绑定？
				在析构函数中调用virtual虚函数，请问是静态绑定还是动态绑定？
static成员方法 =》 virtual函数  no
virtual static void func(){}
inline内联函数
virtual inline int sum(int a, int b){return a + b;} yes!!!!

   什么时候，析构函数必须写成虚析构函数？？？
10. 调用虚函数一定会发生动态绑定吗？？？
call Base::show   call ecx/eax
Base b;
b.show();  用对象调用虚函数永远是静态绑定；动态绑定首先要用指针/引用调用虚函数
Derive d;
d.show();

单一继承！ vfptr  vftable

多重继承  =》  
1.多重继承有什么坏处？  好处？  怎么解决呢？
2.虚基类是什么？
3.vbptr vbtable

C++的四种类型转换  
const_cast :  
const int a = 10;
int *p = (int*)&a;
int *p = const_cast<int*>(&a);
static_cast
reinterpret_cast  <=>  (Type)
dynamic_cast : 识别RTTI信息的类型转换
*/

class A
{
public:
	A(int data = 0) :ma(data) { cout << "A()" << endl; }
	~A(){cout << "~A()" << endl; }
private:
	int ma;
};
class B : virtual public A 
{
public:
	B(int data = 0) :A(data), mb(data) { cout << "B()" << endl; }
	~B(){cout << "~B()" << endl; }
private:
	int mb;
};
class C : virtual public A
{
public:
	C(int data = 0) :A(data), mc(data) { cout << "C()" << endl; }
	~C(){cout << "~C()" << endl; }
private:
	int mc;
};

class D : public B, public C
{
public:
	D(int data=0):B(data), C(data), md(data) { cout << "D()" << endl; }
	~D(){cout << "~D()" << endl; }
private:
	int md;
};
/*
B::
	vbptr  --->  vbtable  14h
	mb
C::
	vbptr  --->  vbtable  0Ch
	mc
md
A::ma
*/
int main()
{
	D d;

	return 0;
}




#if 0
class Base // 虚基类
{
public:
	Base(int data = 10) :ma(data) { cout << "Base()" << endl; }
	~Base() { cout << "~Base()" << endl; }
private:
	int ma;
};
/*
vbptr(virtual base ptr) ------>  vbtable  0  8
mb
ma
*/

class Derive : virtual public Base // 虚继承
{
public:
	Derive(int data=20):Base(data), mb(data) { cout << "Derive()" << endl; }
	~Derive() { cout << "~Derive()" << endl; }
private:
	int mb;
};
int main()
{
	cout << sizeof(Derive) << endl;
	return 0;
}


class Base
{
public:
	Base(int a) :ma(a)
	{
		cout << "Base()" << endl;
	}
	~Base() { cout << "~Base()" << endl; }
	virtual void show() { cout << "Base::show()" << endl; }
protected:
	int ma;
};
class Derive : public Base
{
public:
	Derive(int data) :Base(data), mb(data)
	{
		cout << "Derive()" << endl;
	}
	~Derive() { cout << "~Derive()" << endl; }
	virtual void show() { cout << "Derive::show()" << endl; }
private:
	int mb;
};
int main()
{
	Derive *p = (Derive*)new Base(10);
	p->show();
	delete p;
	cout << typeid(*p).name() << endl;
	return 0;
}


// 基类 =》不代表任何实体 =》不用实例化对象 =》给派生类保留公共的覆盖接口（重写）和公共的属性（复用）
class Base
{
public:
	Base(int a) :ma(a)
	{
		cout << "Base()" << endl;
		clear();
	}
	~Base() { cout << "~Base()" << endl; }
	void clear() { memset(this, 0, sizeof(*this)); }
	virtual void show() { cout << "Base::show()" << endl; }
protected:
	int ma;
};
class Derive : public Base
{
public:
	Derive(int data) :Base(data), mb(data)
	{
		cout << "Derive()" << endl;
	}
	~Derive() { cout << "~Derive()" << endl; }
	virtual void show() { cout << "Derive::show()" << endl; }
private:
	int mb;
};
int main()
{
	//Base *p = new Base(0);
	//p->show();

	Base *p2 = new Derive(20);  // 问题1：这里为什么没挂掉
	p2->show();
	delete p2; //问题2：这里为什么不调用派生类的析构函数

	return 0;
}





class Base
{
public:  // &Base::~Base
	Base(int data) :pa(new int(data)) { cout << "Base()" << endl; }
	// 虚析构函数
	virtual ~Base() { cout << "~Base()" << endl; delete pa; }
private:
	int *pa;
};
class Derive : public Base
{
public:
	Derive(int data) :Base(data), pb(new int(data))
	{
		cout << "Derive()" << endl;
	}// &Derive::~Derive   
	~Derive() { cout << "~Derive()" << endl; delete pb; }
private:
	int *pb;
};
int main()
{
	//Derive d(20)
	Base *p = new Derive(10);
	delete p;  // eax, dword ptr[p]   ecx,dword ptr[eax]  call ecx
	
	return 0;
}



class Base
{
public:
	Base(int a) :ma(a) 
	{ 
		cout << "Base()" << endl; 
		clear();
	}
	~Base() { cout << "~Base()" << endl; }
	void clear() { memset(this, 0, sizeof(*this)); }
	virtual void show() { cout << "Base::show()" << endl; }
protected:
	int ma;
};
class Derive : public Base
{
public:
	Derive(int data) :Base(data), mb(data) 
	{
		cout << "Derive()" << endl; 
	}
	~Derive() { cout << "~Derive()" << endl; }
	virtual void show() { cout << "Derive::show()" << endl; }
private:
	int mb;
};
int main()
{
	//Base *p = new Base(0);
	//p->show();

	Base *p2 = new Derive(0);  // 问题1：这里为什么没挂掉
	p2->show();
	delete p2; //问题2：这里为什么不调用派生类的析构函数

	return 0;
}


class Animal // 有纯虚函数的类  =》  抽象类          >>>>>（多重继承）虚基类
{
public:
	Animal(string name) :_name(name) {}
	virtual void bark() = 0;// 纯虚函数
protected:
	string _name;
};

class Cat : public Animal
{
public:
	Cat(string name):Animal(name){}
	void bark() { cout << _name << " bark:喵喵!" << endl; }
};
class Dog : public Animal
{
public:
	Dog(string name) :Animal(name) {}
	void bark() { cout << _name << " bark:旺旺!" << endl; }
};
int main()
{
	Animal *p1 = new Cat("猫");
	Animal *p2 = new Dog("二哈");
	int *p11 = (int*)p1;
	int *p22 = (int*)p2;
	int tmp = p11[0];
	p11[0] = p22[0];
	p22[0] = tmp;
	p1->bark();
	p2->bark();
	cout << typeid(*p1).name() << endl;
	return 0;
}


class Window
{
public:
	Window(int t = 0) 
	{ a = t; cout << "window" << endl; }
	virtual void onResize() 
	{ a = 10;  cout << "call Window::onResize" << endl; }
	int a;
};

class SpecialWindow :public Window
{
public:
	virtual void onResize()
	{
		// (Test)50;
		((Window)(*this)).onResize();
		cout << "call SpecialWindow::onResize" << endl;
		cout << Window::a << endl;
	}
};
int main()
{
	SpecialWindow sw;  //  8  vfptr  a
	sw.onResize();

	return 0;
}

//老师，这段代码中，如果使用子类的对象调用onResize()函数，为什么a的值没有被改变呢？


class Base
{
public:
	Base(int a) :ma(a) { cout << "Base()" << endl; }
	~Base() { cout << "~Base()" << endl; }
	virtual void show() { cout << "Base::show()" << endl; }
	virtual void show(int i) { cout << "Base::show(int)" << endl; }
protected:
	int ma;
};
class Derive : public Base
{
public:
	Derive(int data) :Base(data), mb(data) { cout << "Derive()" << endl; }
	~Derive() { cout << "~Derive()" << endl; }
	virtual void show() { cout << "Derive::show()" << endl; }
private:
	int mb;
};
int main()
{
	Derive d(20);
	
	Base *pb = &d;
	pb->show(); //静态绑定 Base::show   call  Base::show (0E912DAh)
	/*
	动态绑定    vfptr vftable什么时候生成，运行时加载到哪块内存
	mov eax, dword ptr[pb]
	mov ecx, dword ptr[eax]
	call ecx
	*/
	cout << sizeof(Base) << endl;  // 4  8
	cout << sizeof(Derive) << endl; // 8  12

	// 识别的都是静态(编译时期)类型，显示识别的是RTTI run-time type infomation
	cout << typeid(pb).name() << endl;  // Base*  Base*
	cout << typeid(*pb).name() << endl; // Base   Derive

	return 0;
}
#endif

#if 0
class Base
{
public:
	Base(int a) :ma(a) { cout << "Base()" << endl; }
	~Base() { cout << "~Base()" << endl; }
	void show() { cout << "Base::show()" << endl; }
	void show(int i) { cout << "Base::show(int)" << endl; }
protected:
	int ma;
};
class Derive : public Base
{
public:
	Derive(int data) :Base(data), mb(data) { cout << "Derive()" << endl; }
	~Derive() { cout << "~Derive()" << endl; }
	void show() {cout << "Derive::show()" << endl;}
private:
	int mb;
};
int main()
{
	// 继承结构  从上到下的结构  
	Base b(10);
	Derive d(20);
	//a part of... xxx是xxx的一部分  组合 body  leg
	//a kind of... xxx是xxx的一种    继承 人Man  =  学生Student
	//d = b;  // 派生类对象 = 基类对象  no   上 =》 下
	b = d;  // 基类对象 = 派生类对象  yes  下 =》 上

	Base *pb = &d; // 基类指针/引用 = 派生类对象  yes   下 =》 上
	pb->show(10);

	//Derive *pd = &b; // 派生类指针/引用 = 基类对象 上 =》 下
	//pd->show();  // mb

	return 0;
}


class Base
{
public:
	Base(int a) :ma(a) { cout << "Base()" << endl; }
	~Base() { cout << "~Base()" << endl; }
	void show() { cout << "Base::show()" << endl; }
	void show(int i) { cout << "Base::show(int)" << endl; }
protected:
	int ma;
};
class Derive : public Base
{
public:
	//“Base”: 没有合适的默认构造函数可用
	Derive(int data) :Base(data), mb(data) { cout << "Derive()" << endl; }
	~Derive() { cout << "~Derive()" << endl; }
	void show() 
	{ 
		cout << "Derive::show()" << endl;
	}
private:
	int ma;
	int mb;
};
int main()
{
	Derive d(10);
	d.show(20); // “Derive::show”: 函数不接受 1 个参数
	d.show();
	d.Base::show();
	

	return 0;
}


// A是基类
class A
{
public:
	int ma;
protected:
	int mb;
private:
	int mc;
};
// B是派生类，继承到派生类里面的成员访问限定 <= 继承方式
class B : private A 
{
public:
	int md;
protected:
	int me;
private:
	int mf;
};
class C : public B
{
	// ma的访问限定是什么？
};

int main()
{
	B b;
	cout << b.mb << endl;

    std::cout << "Hello World!\n"; 
}
#endif

// 运行程序: Ctrl + F5 或调试 >“开始执行(不调试)”菜单
// 调试程序: F5 或调试 >“开始调试”菜单

// 入门提示: 
//   1. 使用解决方案资源管理器窗口添加/管理文件
//   2. 使用团队资源管理器窗口连接到源代码管理
//   3. 使用输出窗口查看生成输出和其他消息
//   4. 使用错误列表窗口查看错误
//   5. 转到“项目”>“添加新项”以创建新的代码文件，或转到“项目”>“添加现有项”以将现有代码文件添加到项目
//   6. 将来，若要再次打开此项目，请转到“文件”>“打开”>“项目”并选择 .sln 文件

2. C++结构

请添加图片描述

3.c++继承

请添加图片描述

4.c++总结

在这里插入图片描述

5.c++常见问题

#include<iostream>
using namespace std;
/*
重载，隐藏（），覆盖（虚函数）
虚函数（动态绑定，在运行时绑定）
在编译阶段产生虚函数表；存放虚函数的地址，在.rodata段存放
对象多一个虚函数指针，
虚函数多少不影响对象的大小，只影响虚函数表，函数表与类型对应

派生类继承的基类的虚函数后自己也是虚函数，隐藏的作用域，覆盖虚函数表，
大小（vfptr，加对象），
两个vfptr指向派生类的虚函数表
多态：
静态（编译运行）的多态：函数模板和模板，

动态（运行阶段）的多态：虚函数
基类指针调用同名覆盖方法


9.常见问题实例：析构函数可以实现为虚函数
能不能成为虚函数：====》记录虚函数地址，找到虚函数指针（在对象的前四个字节），要有还要能取地址
1.构造函数不可以为虚函数，在构造之前没有对象
在构造函数中在调用virutal函数，请问是动态还是静态？？？是静态绑定，未产生对象，没有对象的前四个字节，先初始化基类的构造函数，
在析构函数中调用virutal函数，请问是动态还是静态？？==》动态，可以，对象是在的
virual static void fun（）不可以，因为不需要对象，没有虚函数表
virual inline void fun（）内联函数，可以，
2.什么时候析构函数必须写为虚析构函数，？？？
基类指针指向或引用堆上派生类的对象时，

10.调用虚函数一定会发生动态绑定吗？哈哈哈
汇编  call +函数名   ==》静态绑定
call  寄存器===》动态绑定
对象调用虚函数，永远是静态绑定
指针，引用，调用虚函数发生动态绑定 ，
不能用派生类指针指向基类对象，
单一继承
多重继承：
1.有什么坏处？？？
答：继承的基类数据可能有多份
2.虚基类是什么
被虚继承的那个类，
在考虑继承类的内存布局时，先不考虑虚继承，然后再把虚基类的地方改为vbptr表，
里面存放的是到此继承类数据的偏移量
3.vbptr（虚基类指针）向上向偏移量，vdptr，
空类大小是1个字节；
C++的四种类型强制转换
：
const_cast
const int a=10;
int *p =(int *)&a;
int *pconst_cast<int *>(&a);
static_cast;
reinterpret_cast<==>(Type)
dynamic_cast;识别RRTTI类型的转换
STL六大
顺序，关联，迭代器，泛型算法，函数对象

*/

/*  


*/
int main()
{
	return 0;

}
【033】C++ 多态技术深度解析：理解虚函数与纯虚函数（最全讲解）
Lion_Long的博客
06-26 1878
虚函数是一种在基类中声明的函数，它在派生类中可以被重写（覆盖）的函数。在基类中使用关键字“virtual”声明的函数就是虚函数。虚函数通过动态绑定实现了多态性，使得程序可以根据实际对象类型来调用相应的函数。在运行时，系统会根据被调用的对象的类型来确定调用哪一个重写函数。虚函数是C++中实现多态的关键所在。定义方式：在成员函数前面加virtual修饰。注意：子类重写父类的虚函数时，返回值类型、参数类型、个数顺序 必须完全一致。多态的条件：有继承、子类重写父类的虚函数、父类指针指向子类空间。
深入理解C++多态-虚函数
最新发布
LeoLei8060的博客
05-23 1325
C++多态的实现方式可以分为静态多态和动态多态，其中静态多态主要有函数重装和模板两种方式，动态多态就是虚函数。
C++继承,虚函数与多态性专题
04-08
本文分两部分即继承和虚函数与多态性，本文第一部分详细讲解了继承时的构造函数和析构函数的问题，父类与子类的 同名变量和函数问题，最后介绍了多重继承与虚基类。本文第二部分重点介绍了虚函数与多态性的问题，因此学习虚函 数的基础是继承，因此在学习虚函数前应学好继承。本文详细易懂，内容全面，是学习C++的不错的资料。
C++ 继承、多态、虚函数
weixin_33704234的博客
12-13 199
所谓继承，是指在一个已存在类的基础上建立一个新类。已存在的类称为基类(base class)或父类，新建立的类称为派生类(derived class)或子类。这样，子类与父类就形成了层次关系(用箭头表示继承方向) ： 而派生的概念则是从父类角度看待继承所形成的，它与继承的差异只是看待问题的角度不相同：一个从下往上看，另一个从上往下看， 本质上指的是同一事物。 继承性是面向对象程序设计最重要的特征...
C++10继承多态虚函数
sunshinecandy的博客
04-25 189
1.继承和多态 1.解释多态 2.RTTI 3.private和protected的区别 继承结构中 继承的本质：代码复用 1.派生类中，从基类继承来的成员的访问限定是什么？ 基类的访问限定 派生类的访问限定 main函数 public public public yes protected protected no private 不可访问 no p...
【C++】继承与多态之虚函数
qq_43411563的博客
04-09 263
一、定义 虚函数必须是基类的非静态成员函数，其访问权限可以是private或protected或public，在基类的类定义中定义虚函数的一般形式。 虚函数是一种在基类定义为virtual的函数，并在一个或多个派生类中再定义的函数。实现多态性。虚函数的特点是，只要定义一个基类的指针，就可以指向派生类的对象。 二、具体实现 我们先看一段简单的代码： #include <iostream>...
C++ 重写重载重定义区别
weixin_34221073的博客
08-25 95
（源自：http://blog.163.com/clevertanglei900@126/blog/static/111352259201102441934870/） 1 成员函数重载特征： a 相同的范围（在同一个类中） b 函数名字相同 c 参数不同 d virtual关键字可有可无 2 重写（覆盖)是指派生类函数覆盖基类函数，特征是： ...
c++继承与多态，虚函数实例
04-26
虚函数在实现多态中扮演着关键角色，它可以确保程序在运行时能够调用到正确的方法，即便对象的实际类型与指针或引用声明的类型不同。 首先，让我们深入理解“虚函数”这一概念。在C++中，虚函数通过在基类中使用`...
C++ 多态 虚函数 虚函数表 最是详细
10-01
高质量的C++多态讲解，详细讲解虚函数，虚函数表，虚函数继承，虚函数继承下的内存分配等
C++多继承多态的实例详解
01-01
C++多继承多态的实现 如果一个类中存在虚函数，在声明类的对象时，编译器就会给该对象生成一个虚函数指针，该虚函数指针指向该类对应的虚函数表。 多态的实现是因为使用了一种动态绑定的机制，在编译期间不确定...
C++多态之虚函数
weixin_30635053的博客
04-11 127
多态：不同对象收到相同消息时，产生不同的动作。（说通俗点就相当于，在一工地上有许多工人，每个工人负责的工作都不一样，但是他们在听到领班发出“开工”命令后，开始各自负责的工作）。 在c++中实现多态，我需要利用基类指针可以在隐式转换下指向派生类这一特性。当我们传入不同的对象（基类或派生类）就可以发生多态 1 #include <iostream> 2 3 usi...
C++：多态、虚函数
WangGarrison的博客
12-08 442
文章目录基本概念虚函数final与override区分函数重载、同名隐藏、覆盖虚函数与默认实参虚析构函数回避虚函数的机制纯虚函数和抽象类虚函数与虚基类的区分 基本概念 多态：多态性是面向对象的关键技术之一。多态可以认为就是同一接口有不同的形态。即利用多态技术，可以调用同一个函数名的时候，实现完全不同的功能。 多态分为静态多态和动态多态。函数重载、运算符重载以及模板都是属于静态多态，也称编译时多态。动态多态也称运行时多态，即在程序运行阶段才能确定的关系，例如某些函数的调用关系在编译阶段无法确定，到了运行阶段
C++：多态之虚函数
我们的征途是星辰大海
03-02 2156
一个面向对象的系统常常要求一组具有相同基本语义的方法能在同一接口下为不同的对象服务,这就是多态性(polymorphism).           通俗的来说，多态就是在一个方法在不同基类的派生类中表现出不同的实现形式。比如，定义水果类为基类，苹果，梨，香蕉为派生类，在水果类，苹果，梨，香蕉中都有一个计算蒸发率的成员函数，但是，在苹果，梨，香蕉中，因为他们是不同水果，有不同蒸发率，所以，虽然同样
C++ 多态，虚函数
my_et的专栏
07-01 606
在c++中可以用基类指针指向其派生类，如果一个派生类继承多个父类，那么如何通过基类指针访问同名的成员呢？         如果基类A,基类B中都有函数fun(),派生类在同时继承A、B后在内存中根据继承的顺序分配内存，例如在继承列表中出现的是B,A，那么B中的成员在A的之前，当我们用B的指针去访问时候，编译器便将指针指向B的成员，同理用A的指针去访问，编译器便将指针指向A的成员。 clas
C++多态
planetsea的博客
10-23 236
C++ 多态 多态按字面的意思就是多种形态。当类之间存在层次结构，并且类之间是通过继承关联时，就会用到多态。 C++ 多态意味着调用成员函数时，会根据调用函数的对象的类型来执行不同的函数。 下面的实例中，基类 Shape 被派生为两个类，如下所示： #include using namespace std; class Shape { protected:
C++多态（虚函数）
weixin_44117735的博客
08-17 444
文章目录一、多态？二、分类根据实现的时机三、虚函数注意总结 一、多态？ 面向对象程序设计的重要特征之一。（其他两个特征是封装和继承） 多态的本质是指同一个函数的多种形态。 简单的理解就是，同一个函数在调用的时候，不同的行为（输入）就会产生不同的实现方式。 通俗的说就是，你（函数）遇到了红绿灯（不同的行为），你就会根据红绿灯进行相应的动作（不同的实现）。就是说你还是你，但是当遇到红绿灯的时候，根据灯的状态（红 或者 绿 或者 黄），你会有不同的动作（停止 或者 行走 或者 减速）。 正式的书面表达，..
【C++】多态：虚函数
明朗晨光的专栏
01-10 1142
1. 如此继承 #include <iostream> using namespace std; class Animal { public : Animal(string name) : name(name) {} void run() { cout << "I don't know how to run" << endl; } private : string name; }; class Cat : public
【C++】多态和虚函数
Lee的博客
03-23 1513
多态和虚函数的学习与使用
c++多态性 虚函数
qq_38251888的博客
12-11 251
c++中多态性是指通过用virtual关键字来绑定同名同参数的函数，实现在编译中进行后绑定，即在编译过程中不绑定类，在运行时与具体的对象进行绑定，这样就可以动态地与实际联系 比如一个类 animal 有一个虚函数breath() 鱼类 fish 也有函数breath() 狗类 dog 函数breath() 具体调用时根据你的对象是鱼类还是狗类有关 C++的多态性用一句话概括就是：在基类的函数...
c++继承、多态和虚函数
07-28
C++中的继承、多态和虚函数是面向对象编程的重要概念。 继承是指一个类可以从另一个类继承属性和方法。子类可以继承父类的公有成员和保护成员，但不能继承私有成员。通过继承，子类可以重用父类的代码，并且可以...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

我的sun&shine

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

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

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

打赏作者

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

抵扣说明：

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

余额充值