03c++继承与多态

最新推荐文章于 2024-05-22 19:56:55 发布
最新推荐文章于 2024-05-22 19:56:55 发布
阅读量576 收藏 2
点赞数 14
分类专栏： c++初级 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80434259/article/details/138730320
版权

目录：

  • 继承的本质和原理
  • 派生类的构造过程
  • 重载覆盖 隐藏
  • 静态绑定和动态绑定
  • 多态 vfptr和vftable
  • 抽象类的设计原理
  • 多重继承以及问题
  • 虚基类 vbptr和vbtable
  • RTTI
  • c++四种类强转
  • 继承多态常见笔试面试题目分享

1、继承的本质和原理：

继承方式： 基类的访问限定 派生类的访问限定 main外部的访问限定
三种：私有全私有
保护二级私有
公有一级私有
class A
{
public:
	int ma;
protected:
	int mb;
private:
	int mc;
};


class B :public A
{
public:
	void func()
	{
		cout << "func: " << func << endl;
	}
	int md;
protected:
	int me;
private:
	int mf;
};

class C :public B
{
	//在c里面，请问ma的访问限定的是什么？
	//私有的

};

2、派生的构造过程

* 派生类如何初始化基类继承来的成员变量？
* 通过调用基类相应的构造函数
*
* 派生类的构造函数和析构函数负责初始化和清理派生类部分
#if 0
/*
* 派生类如何初始化基类继承来的成员变量？
* 通过调用基类相应的构造函数
*
* 派生类的构造函数和析构函数负责初始化和清理派生类部分
*/
class Base
{
public:
	Base(int data = 10) :ma(data) { cout << "Base()" << endl; }
	~Base() { cout << "~Base()" << endl; }

protected:
	int ma;
};

class Derive :public Base
{
public:
	Derive(int data = 20) :mb(data), Base(data)
	{
		cout << "Derive()" << endl;
	}
	~Derive()
	{
		cout << "~Derive()" << endl;
	}
private:
	int mb;

};

int main()
{
	Derive v;
	/*
	输出：
		Base()
		Derive()
		~Derive()
		~Base()
	先调用派生类的析构函数
	*/
	return 0;
}
#endif

3、重载 隐藏 覆盖

图像分析：
在这里插入图片描述
在这里插入图片描述
从图中可以看出来有危险。

/*重载 隐藏 覆盖
1、重载关系
必须处在同一个作用域中，函数名字相同，参数列表不同
2、隐藏:作用域的隐藏
*/

class Base
{
public:
	Base(int data = 10) :ma(data) {}
	void show() { cout << "Base::show()" << endl; }
	void show(int) { cout << "Base::show(int)" << endl; }

protected:
	int ma;
};
class Derive :public Base
{
public:
	Derive(int data = 20) :Base(data), mb(data) {}
	void show() { cout << "Derive::show" << endl; }


private:
	int mb;
};

int main()
{
#if 0
	Derive d;
	d.show();
	d.Base::show(); //这样子才能调用基类的
	//d.show(10); 优先查看派生类自己的作用域成员，没有的话才去基类里面找
	d.Base::show(10);
#endif 
	Base b(10);
	Derive c(20);
	//基类到派生类的转换
	b = c; //类型从下到上的转化

	//d = b;//类型从上到下的转换 error 

	//基类指针 引用 <-派生类对象 默认派生类到基类的转换
	Base* pb = &c; //只能访问派生基类部分的成员
	pb->show();
	pb->show(10);
	/*Base::show()
	Base::show(int)
	*/

	((Derive*)pb)->show(); //这样子就调用了派生类的show

	//在继承结构中进行上下的类型的转换，默认支持从下到上的转换
	Derive* pd = (Derive*)&b; //派生类的show方法 没有派生类对象 
	//b是基类哇 不安全涉及内存的非法访问
	pd->show();
	return 0;
}

4、虚函数、静态绑定、动态绑定

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述


/*
* 虚函数 ，静态绑定 和动态绑定
* 总结一：如果类里面定义了虚函数，那么编译阶段，编译器给这个类类型产生了一个唯一的vftable虚函数表,
*虚函数表中的主要存储的内容就是RTTI指针和虚函数的地址 ，程序运行中，每一张虚函数表都会记载到内存的.rodata区
*
* 总结二：
* 一个类里面定义了函数，那么这个类定义的对象运行的时候，内存中开始 部分，多存储了vfptr虚函数指针，指向相应类型 的虚函数表vftable
* 一个类型定义的n个对象，他们的vfptr指向都是同一张虚函数表
*
* 总结三：
* 一个类里卖弄虚函数的个数，不影响对象内存大小（vfptr），影响的是虚函数表的大小
*
* 总结四：
* 如果派生类中的方法，和基类继承来的某个方法，返回值、函数名、参数列表都相同，
* 而且基类的方法都是virtual虚函数，那么派生类的这个方法，自动处理成虚函数
*/

class Base
{
public:
	Base(int data = 10) :ma(data) {}
	//虚函数
	virtual void show() { cout << "Base::show()" << endl; }
	//虚函数
	virtual void show(int) { cout << "Base::show(int)" << endl; }

protected:
	int ma;
};
class Derive :public Base
{
public:
	Derive(int data = 20) :Base(data), mb(data) {}
	void show() { cout << "Derive::show" << endl; } //不写virtual也是虚函数


private:
	int mb;
};

int main()
{
	Derive d(50);
	Base* pb = &d;
	pb->show(); //静态（编译时期）的绑定 （函数的调用）
	//如果发现是虚函数，就进行动态绑定了
	pb->show(10);
	/*
	E8 0B EE FF FF       call        Base::show (07FF6900A13F7h)
	BA 0A 00 00 00       mov         edx,0Ah
	48 8B 4D 28          mov         rcx,qword ptr [pb]
	E8 E2 EA FF FF       call        Base::show (07FF6900A10DCh)
	*/

	cout << sizeof(Base) << endl;
	cout << sizeof(Derive) << endl;

	cout << typeid(pb).name() << endl;

	/*如果Base没有虚函数，*pb识别的就是编译时期的 如果有虚寒申诉就是运行时期的*/
	cout << typeid(*pb).name() << endl;
	/*
	Derive::show
	Base::show(int)
	16
	24
	class Base * __ptr64
	class Derive
	| vptr (8 字节) | ma (4 字节) | 填充 (4 字节) |

	*/
	return 0;
}
/*
* Base::show()
Base::show(int)
4
8
class Base * __ptr64
class Base

*/

5、多态

/*
解释多态：
静态编译时期：函数重载
编译阶段就已经确定好的；
动态编译时期：
在继承中，基类指针引用指向派生类的对象，通过该指针引用调用同名的覆盖方法（虚函数)基类指针指向哪个派生类对象，就会调用哪个派生类对象同名覆盖的方法，称为多态。
访问谁的vfptr=>继续访问谁的vftable;调用对应的派生类对象的方法
*/

class Animal
{
public:
	Animal(string name) :_name(name) {}
	virtual void  bark()
	{

	}
protected:
	string _name;
};

class Cat :public Animal
{
public:
	Cat(string name) :Animal(name) {}
	void bark() { cout << "猫叫" << endl; }
};

class Dog :public Animal
{
public:
	Dog(string name) :Animal(name) {}
	void bark() { cout << "狗叫" << endl; }
};

void bark(Animal* p)
{
	p->bark();
}
int main()
{
	Cat a("wocao");
	Dog b("shabi");
	bark(&a);
	bark(&b);
	return 0;
}

6、理解抽象类

//汽车的基类
class Car
{
public:
	Car(string name, double oil) :name(name), oil(oil) {}
	double getLiftMiles()
	{
		return oil * getMilesPersonGallon();
	}
public:
	string name;
	double oil;
	virtual double getMilesPersonGallon() = 0; //纯虚函数

};

class Bnze :public Car
{
public:
	Bnze(string name, double oil) :Car(name, oil) {}
	double getMilesPersonGallon() { return 20.0; }
};

class Audi :public Car
{
public:
	Audi(string name, double oil) :Car(name, oil) {}
	double getMilesPersonGallon() { return 18.0; }
};

void  showCarLeftMiles(Car& car)
{
	cout << "Car name:" << car.name << endl << car.getLiftMiles() << endl;

}
int main()
{
	Audi car("1", 12);
	Bnze car1("2", 12);
	showCarLeftMiles(car);
	showCarLeftMiles(car1);
	return 0;
}

7、再谈动态绑定

/*虚函数和动态绑定 问题：是不是虚函数的调用一定就是动态绑定？ 不是
类的构造函数中，调用虚函数不会发生动态绑定
*/


class Base
{
public:
	Base(int data = 10) :ma(data) {}
	//虚函数
	virtual void show() { cout << "Base::show()" << endl; }
	//虚函数
	virtual void show(int) { cout << "Base::show(int)" << endl; }

protected:
	int ma;
};
class Derive :public Base
{
public:
	Derive(int data = 20) :Base(data), mb(data) {}
	void show() { cout << "Derive::show" << endl; } //不写virtual也是虚函数


private:
	int mb;
};
int main()
{
	Base b;
	Derive d;
	/*
	E8 6F E9 FF FF       call        Base::Base (0121118h)
	6A 14                push        14h
	8D 4D DC             lea         ecx,[d]
	E8 24 E9 FF FF       call        Derive::Derive (01210D7h)
	对象本身调用虚函数是静态绑定
	*/
	b.show();
	d.show();

	//动态绑定
	Base* pb1 = &b;
	pb1->show();
	Base* pb2 = &d;
	pb2->show();

	//动态绑定
	Base& rb1 = b;
	rb1.show();
	Base& rb2 = d;
	rb2.show();

	//动态绑定
	Derive* p = (Derive*)&b;
	p->show();
	//如果不是引用或者指针调用则是静态调用
	return 0;
}

8、虚析构函数

/*

/*
1、哪些函数不能实现虚函数
虚函数依赖：
	1虚函数能产生地址，存储在虚函数表vftable中
	2、对象必须存在(vfptr->vftable->虚函数地址)

构造函数：
1、virtual + 构造函数
2、构造函数中华调用的任何函数都是静态绑定的调用虚函数，也不会产生静态绑定派生类的对象构造过程。
1、先调用的是基类的构造函数2、才调用派生类的构造函数

static静态成员方法 No virtual + static

问题二：
虚析构函数 析构函数调用的时候存在，对象是存在的！
什么时候吧基类的析构函数必须实现成虚函数？
基类的指针(引用)指向堆上new出来的派生类对象的时候,delete pb(基类的指针)
,它调用析构函数的时候必须发生动态绑定，否则会导致派生类的析构函数无法调用
*/


class Base
{
public:
	Base(int data = 10) :ma(data) { cout << "Base()" << endl; }
	virtual ~Base() { cout << "~Base()" << endl; }
	//虚函数
	virtual void show() { cout << "Base::show()" << endl; }
	//虚函数
	virtual void show(int) { cout << "Base::show(int)" << endl; }

protected:
	int ma;
};
class Derive :public Base
{
public:
	Derive(int data = 20) :Base(data), mb(data) { cout << "Derive()" << endl; }
	//基类的析构函数是虚函数，派生类的析构函数默认成为虚函数
	~Derive() { cout << "~Derive()" << endl; }
	void show() { cout << "Derive::show" << endl; } //不写virtual也是虚函数


private:
	int mb;
};

int main()
{
	Base* pb = new Derive(10);
	pb->show();//动态绑定
	delete pb;//派生类的析构函数，没有呗调用
	/*
	pb->Base Base::~Base 对于析构函数的调用就是静态绑定了

	发现是虚析构函数就是动态绑定了
	call Base::~Base
	*/
	return 0;
}

在这里插入图片描述
在这里插入图片描述

9、题目分享

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 << "猫叫" << endl; }
};

class Dog :public Animal
{
public:
	Dog(string name) :Animal(name) {}
	void bark() { cout << "狗叫" << endl; }
};

int main()
{
	Animal* p1 = new Cat("加菲猫");
	Animal* p2 = new Dog("二哈");

	int* p11 = (int*)p1;

	int* p22 = (int*)p2;
	int tmp = p11[0]; //cat的前四个字节 vfptr -> Dog vftable
	p11[0] = p22[0];  //dog的前四个字节 vfprt ->Cat vftable
	p22[0] = tmp;

	p1->bark(); //cat vfptr -> dog vfptr->dog vftable
	p2->bark();
	delete p1;
	delete p2;
	return 0;
}

class Base
{
public:
	virtual void show(int i = 10)
	{
		cout << "call Base::show i" << i << endl;
	}
};

class Derive :public Base
{
public:
	void show(int i = 20)
	{
		cout << "call Derive ::show i " << i << endl;
	}
};

int main()
{
	Base* p = new Derive();//虚析构函数

	/*
	* push 0Ah =》函数调用参数压栈的在编译时期就确定好的 是基类的10
	* mov eax,dword ptr[p];
	* mov ecx,dword ptr[eax]
	* call ecx;
	*/
	p->show();
	delete p; //动态绑定 p->Derive vfptr ->Derive vftable

	return 0;
}

class Base
{
public:
	virtual void show()
	{
		cout << "call Base::show " << endl;
	}
};

class Derive :public Base
{
private: //改成私有还能调用吗？
	void show()
	{
		cout << "call Derive ::show " << endl;
	}
};

int main()
{
	Base* p = new Derive();
	/*
	* 成员方法能不能调用就是说方法的访问权限是不是public,实在编译时期就需要确定的
	* 只能看到Base::show
	* 基类：call Base::show静态
	* call Derive::show动态
	*/
	p->show(); //最终调用是在运行时期才确定的 这个调用的call Derive show()
	delete p;
	return 0;
}


class Base
{
public:
	Base()
	{
		/*
		push ebp
		mov ebp,esp
		sub esp,4Ch
		rep  stos esp<->ebp
		vfptr <= &Base::vftable
		*/
		cout << "call Base()" << endl;
		clear();
	}
	void clear() { memset(this, 0, sizeof(*this)); }

	virtual void show()
	{
		cout << "call Base::show()" << endl;
	}
};

class Derive :public Base
{
public:
	/*
	push ebp
	mov ebp,esp
	sub esp,4Ch
	rep  stos esp<->ebp
	vfptr <= &Derivev::vftable
	*/
	Derive()
	{
		cout << "call Derive ()" << endl;
	}

	void show()
	{
		cout << "call Derive::show()" << endl;
	}

};

int main()
{
	//Base* p = new Base();
	//p->show();//动态绑定
	//delete p;

	Base* p1 = new Derive();
	p1->show(); //动态绑定
	delete p1;
	return 0;
}
编程小公举
关注
  • 14
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++继承与多态例子
06-28
C++实现的一个继承与多态的例子，内容详细且易懂
C++ 继承与多态
XXXTENTAC1ON的博客
03-23 2284
继承与多态介绍继承的概念与定义 介绍 继承机制 是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员保持原有类特性的基础上进行扩展，增加功能；这样产生新的类，称派生类；继承呈现了面向对象程序设计的层次结构；体现了由简单到复杂的认识过程 多态性 是考虑在不同层次的类中，以及在统一类中，统么的成员函数之间的关系问题。函数的重载，运算符的重载，属于编译时的多态性；以虚基类为基础的运行时的多态性是面向对象程序设计的标志性特征；体现了类推和比喻的思想方法 早期绑定：编译时就确定了调用关系 晚绑定：程序运行的过
C++ 继承和多态
凡事都是靠练习
08-17 2039
讲解继承和多态，多态的实现原理
C++ 封装、继承和多态
SimpleForest的博客
07-08 1157
多态指的是同一个函数名可以调用不同类型的函数，从而实现不同对象之间的差异性行为。静态多态是通过函数重载和运算符重载来实现的，而动态多态则是通过虚函数来实现的。多态的目的是实现代码的灵活性和可扩展性，使得程序可以更好地适应不同的应用场景。封装是指的是将数据和操作数据的方法封装在类中，使得数据和方法不能被外部直接访问，只能通过类的公共接口进行访问和修改。封装的目的是实现代码模块化和信息隐藏，提高代码的可维护性和可重用性。继承是指的是一个类（子类）通过继承另一个类（父类）的属性和方法，从而实现代码的扩展。
C++——继承和多态
weixin_57133901的博客
03-07 2201
多态： 多态按字面的意思就是多种形态。当类之间存在层次结构，并且类之间是通过继承关联时，就会用到多态。 C++ 多态意味着调用成员函数时，会根据调用函数的对象的类型来执行不同的函数。 多态性是面向对象程序设计的关键技术之一。若程序设计语言不支持多态性，不能称为面向对象的语言。利用多态性技术，可以调用同一个函数名的函数，实现完全不同的功能。 1.1两种多态： 1.1.1编译时多态（早绑定）： 编译时的多态通过函数的重载和运算符的重载来实现的。 就像是未出生的男女孩定下的娃娃亲。 1.1.2运行时多态（晚绑定）
【C++】继承与多态
Pursue quality, not quantity.
03-01 1709
C++继承与多态万字详解！！
“C++继承与多态”常见面试题
仟各的博客
06-10 1079
（注：以下内容是在阅读相关书籍以及课程学习之后的总结内容，如果错误，希望大佬指点！）1、解释一下C++的多态？ 首先，C++的多态机制是指：派生类对象的地址可以赋值给基类指针。对于通过基类指针调用基类和派生类中都有同名、同参数表的虚函数语句，编译时并不需要确定调用的这个函数是基类的函数派生类的，在程序运行到这条语句的时候，如果基类指针指向的是一个基类对象，则基类的虚函数被调用，如果基类的指针指向的是一个派生类的对象，则派生类的虚函数被调用。 其次，多态性只存在子类继承层次中。 另外C++中支持多态性的几种方
C++的继承和多态
linzixi0220的博客
01-30 1726
继承与派生 面向对象程序设计的三大特征是封装、继承和多态。其中继承体现的是一种持续发展的、开放的编程态度。继承和派生可以在不破坏原有类的封装特性的情况下获得原有类的数据和功能，并在此基础上增加新的数据和功能。基类是为解决以前的老问题而设计的，但在遇到新问题时其功能就有局限，这是在继承的基础上进行派生则能够在基类的基础上添加功能来解决新问题。因此通过继承和派生可提高代码的可重用性和持续性。 继承与派生概念：保...
c++继承与多态
qq_60916002的博客
06-27 98
c++继承与多态（有待补充
【c++ 封装、继承、多态】
小呆鸟blog
09-10 5863
函数运行的版本不是一开始就确定好了的而是在程序运行的时候才选择函数运行的版本，至于到底选择哪个函数版本取决于调用该函数的指针或者引用实际绑定的数据对象。
c++继承与多态，虚函数实例
04-26
简单例子展示虚函数展现的多态特性，更改一处注释就能对比基类是否是虚函数带来的变化
C++继承与多态课件
08-07
C++继承与多态C++继承与多态C++继承与多态C++继承与多态C++继承与多态C++继承与多态
C++继承与多态示例
12-31
利用C++中的继承与多态，实验构造函数的作用
C-数据结构-单向链表（示例）
最新发布
aqiangdeba的博客
05-22 183
【代码】C-数据结构-单向链表（示例）
C++原创人工智能QPBS01G大功告成！！！
QIPABOSHI的博客
05-21 288
这次这娃学聪明了，遇到不会的问题上网搜，我还更新了反骂人骂人功能，第一次测试我加了个关机功能，他一说完话就关机了，我草，烦烦烦烦烦烦烦烦烦烦烦烦烦烦烦烦死了！我之前的版本bug太多，结果这两天晚上改的我两眼发白，太烦人了。俗话说得好，你周五周六不写作业，要上学了才着急了。
【C++】初始化列表
qq_46049113的博客
05-19 179
当创建一个类的实例时，类的构造函数会被调用来初始化该实例。构造函数可以通过其体（即大括号内的代码部分）或通过初始化列表来初始化成员变量。：使用初始化列表可以直接初始化成员变量，而不是先默认构造成员然后再赋值。：对于常量成员变量和引用成员，初始化列表是必需的，因为这些类型的成员一旦创建后就不能再被赋值。：如果一个类继承自基类，或者它包含其他类的对象作为成员，这些基类和成员对象只能通过初始化列表进行初始化。这种初始化方式确保了代码的效率和成员变量的正确设置，特别是在涉及复杂类型或类的资源管理时尤为重要。
【C++】菱形继承、菱形虚拟继承、继承与组合
dhgiuyawhiudwqha的博客
05-21 670
不过继承也有用武之地的，有 些关系就适合继承那就用继承，另外要实现多态，也必须要继承。类之间的关系可以用 继承，可以用组合，就用组合。，如上面的继承关系，在student和teacher的继承person时使用虚拟继承，即可解决问题。此时就不存在了对_name访问不明确的问题，因为虚拟继承保证在整个继承层次中只存在一份基类的实例。继承是一种“is-a”关系，表示一个类是另一个类的特殊化。
c++继承与多态设计图书管理系统思路
05-24
设计一个图书管理系统，可以采用面向对象的思想，使用C++语言来实现，以下是一个简单的设计思路： 1. 首先，创建一个基类 Book，包含一些共同的属性和方法，例如书名、作者、出版社、价格等属性，以及借阅、归还等...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值