9.C++虚函数和多态

最新推荐文章于 2024-08-09 10:25:03 发布
最新推荐文章于 2024-08-09 10:25:03 发布
阅读量88 收藏 1
点赞数 1
分类专栏： C++学习笔记 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LTSky19950509/article/details/121718850
版权

  1. 虚函数与虚函数表

    1. 什么是虚函数? 用virtual 修饰的成员函数叫做虚函数

    2. 虚函数对于类的影响

      • 增加一个指针的内存，32位4个字节 ，64位就是8个字节

    3. 虚函数表(了解一下): 就是一个指针存储所有虚函数的首地址

    4. #include<iostream>
#include <string>
using namespace std;

class studentA {
public:
	void print1() {
		cout << "普通函数" << endl;
	}
protected:

private:

};
class studentB {
public:
	virtual void print1() {
		cout << "虚函数1" << endl;
	}
	virtual void print2() {
		cout << "虚函数2" << endl;
	}

protected:

private:

};

int main() {
	cout << sizeof(studentA) << endl;//空的类、结构体 普通函数  占用1字节
	cout << sizeof(studentB) << endl;//虚函数增加一个指针的内存，32位4个字节 ，64位就是8个字节，存储所有虚函数的首地址

	//虚函数表
	typedef void(*PF)();
	studentB stu;
	int** vptr = (int**)&stu;
	PF func1 = (PF)vptr[0][0];
	func1();
	PF func2 = (PF)vptr[0][1];
	func2();


	return 0;
}

  2. 虚函数与多态

    1. 多态定义: 同一种行为(调用)导致的不同的结果

    2. 多态的必要性原则

      • 必须父类存在虚函数

      • 子类必须采用public继承

      • 必须存在指针的引用(使用)

    3. #include<iostream>
#include <string>
using namespace std;
class Shape {
public:
	virtual void test1() {
		cout << "基类 测试函数1" << endl;
	}
	void test2() {
		cout << "基类 测试函数2" << endl;
	}
protected:

private:
};

class Rect :public Shape {
public:
	void test1() {
		cout << "子类 测试函数1" << endl;
	}
	void test2() {
		cout << "子类 测试函数2" << endl;
	}
protected:

private:
};

int main() {
	//正常访问不存在多态，就近原则
	Shape shape;
	shape.test1();
	shape.test2();
	Rect rect;
	rect.test1();
	rect.test2();

	//指针正常访问，就近原则
	Shape* pshape = new Shape;
	pshape->test1();
	pshape->test2();
	Rect* prect = new Rect;
	prect->test1();
	prect->test2();

	// 子类对象初始化父类指针
	//有virtual看对象类型，没有virutal看指针
	Shape* pShape = new Rect;
	pShape->test1();   //是虚函数 访问子类函数
	pShape->test2();   //不是虚函数 访问基类函数


	return 0;
}

  3. 纯虚函数与ADT(Abstract Data Type)

    1. 纯虚函数也是虚函数只是纯虚函数是没有函数体的 
      virtual 返回值类型 函数名（）=0；

    2. 抽象类： 具有至少一个纯虚函数的类，叫做抽象类

      • 抽象类不能构建对象

      • 抽象类可以构建对象指针

    3. 纯虚函数没有被重写，无论被继承多少次 都是纯虚函数，虚函数无论被继承多少次都是虚函数

    4. #include<iostream>
#include <string>
using namespace std;

#define PI 3.14

class Shape {
public:
	//纯虚函数就是做ADT(abstract data type 抽象数据类型)过程
	virtual void Draw() = 0;
	virtual void perimeter() = 0;
	virtual void area() = 0;
protected:

private:
};

class Rect :public Shape {
public:
	Rect(int Width = 0, int Height = 0) :Shape(), Width(Width), Height(Height) {}
	Rect(const Rect& rect) {
		Width = rect.Width;
		Height = rect.Height;
	}
	//子类想要创建对象，必须重写父类的纯虚函数
    //ADT: 具有强迫性,所有子类重写函数必须和父类的一模一样
	void Draw() {
		cout << "绘制矩形" << endl;
		cout << "长：" << Width << " " << "高：" << Height << endl;
	}
	void perimeter() {
		cout << "周长：" << 2 * (Width + Height) << endl;;
	}
	void area() {
		cout << "面积：" << Height * Width << endl;;
	}
	//可以增加别的函数
    //可以增加别的成员
protected:
	int Width;
	int Height;
private:
};
class Circle :public Shape {
public:
	Circle(int Radius = 0) :Radius(Radius) {}
	Circle(const Circle& circle) {
		Radius = circle.Radius;
	}
	void Draw() {
		cout << "圆形" << endl;
		cout << "半径：" << Radius << endl;
	}
	void perimeter() {
		cout << "周长：" << 2 * PI * Radius << endl;;
	}
	void area() {
		cout << "面积：" << PI * Radius * Radius << endl;;
	}

protected:
	int Radius;
private:
};

//统一访问接口
class Drawer {
public:
	void Draw(Shape* shape) {
		shape->Draw();//传进来的是那个子类的对象，就会实现那个子类里面的函数
	}
	void perimeter(Shape* shape) {
		shape->perimeter();
	}
	void area(Shape* shape) {
		shape->area();
	}
protected:

private:
};


int main() {
	Shape* shape = new Rect(20, 10);
	shape->Draw();
	shape->perimeter();
	shape->area();

	Drawer* drawer = new Drawer;
	Rect* rect1 = new Rect(20, 10);
	drawer->Draw(rect1);//相当于Shape* shape = new Rect(20, 10); shape->Draw();
	drawer->perimeter(rect1);
	drawer->area(rect1);

	Circle* circle = new Circle(10);
	drawer->Draw(circle);
	drawer->perimeter(circle);
	drawer->area(circle);

	return 0;
}

  4. 虚析构函数

    1. 在用子类对象初始化父类指针，父类需要虚析构函数做内存释放
    2. #include<iostream>
#include <string>
using namespace std;
class Parent
{
public:
	virtual ~Parent() {
		cout << "父类析构" << endl;
	}
	void print() {
		cout << "基类" << endl;
	}
protected:

private:

};

class Son:public Parent
{
public:
	~Son() {
		cout << "子类析构" << endl;
	}
	void print() {
		cout << "子类" << endl;
	}
protected:

private:

};

int main() {
	//在用子类对象初始化父类指针，父类需要虚析构函数做内存释放
	Parent* parent = new Son;
	parent->print();
	delete parent;
	return 0;
}

  5. overdide与final

    1. final
      1. final:禁止重写
      2.  final子类不能存在同名函数
    2. override
      1. 强制重写，标识作用，用检查父类中是否存在当前的虚函数
      2. 若父类不存在同名虚函数，会报错
    3. #include <iostream>
using namespace std;
class A
{
public:
	//final:禁止重写
	//final子类不能存在同名函数
	virtual void print() final
	{
		cout << "禁止重写" << endl;
	}
	virtual void printData() {}
};
class B :public A
{
public:
	//限制子类不能重写函数
	//void print() 
	//{
	//}
	 
	//强制重写，标识作用，用检查父类中是否存在当前的虚函数
	//不存在 就会报错
	void printData() override
	{
		cout << "表示当前函数是重写函数" << endl;
	}
};
int main()
{
	B b;
	A a;
	a.print();
	b.print();
	return 0;
}

  6. C++类型转换

    1. const_cast

      #include<iostream>
#include <string>
#include <stdio.h>
using namespace std;
class A {
public:
	A(const char*str):str(const_cast<char*>(str)){}
	void print()
	{
		cout << str << endl;
	}
protected:
	char* str;
private:
};
class B
{
public:
	B(int num) :num(num) {}
	void print()
	{
		cout << num << endl;
	}
protected:
	int num;
};


int main() {
	//去掉const属性
	//1.作用普通指针
	const int num = 12;
	int* pNum = const_cast<int*>(&num);
	*pNum = 15;
	cout << &num << endl;
	cout << pNum << endl;
	cout << num << endl;//num依旧是12
	cout << *pNum << endl;//15
	//2.操作类中的char*类型指针
	A object("HelloWorld");
	object.print();
	char str[] = "Hello";
	A object1(str);
	object1.print();
	//3.操作类指针
	const B* pB = new B(10);
	//pB->print();  //常对象指针只能调用常成员函数
	B* ppB = const_cast<B*>(pB);
	ppB->print();
	//4.操作常量引用
	int a=12;
	const int& b = a;
	int& c = const_cast<int&>(b);
	cout << c << endl;;
	//5.加上const属性
	int aa = 11;
	int *pa = &aa;
	const int* ppa = const_cast<const int*>(pa);
	cout << *ppa;
	return 0;
}

    2. static_cast

      #include <iostream>
using namespace std;
/*
	static_cast<要转换的类型>(要转换的目标)
	1.基本数据类型转换(类似C语言强制类型转换)
	2.把空指针转换成目标类型指针
	3.把任何类型的变量转换为void类型
	4.用在类上面的转换(基类和派生类对象之间的转换)
		4.1 进行上行转换(从子到父 指针或者引用转换) 安全
		4.2 进行下行转换(从父到子 指针或者引用转换)
	注意点:static_cast不能去掉const
*/
class Parent
{
public:
	void print()
	{
		cout << "parent" << endl;
	}
	void printParent()
	{
		cout << "parent1" << endl;
	}
};
class Son :public Parent
{
public:
	void print()
	{
		cout << "son" << endl;
	}
	void printData()
	{
		cout << "son2" << endl;
	}
};

int main()
{
	//1.基本数据类型
	char cNum = 'A';
	int iNum = static_cast<int>(cNum);
	cout << iNum << endl;
	//2.空类型指针
	double* pD = new double;
	void* pVoid = static_cast<void*>(pD);
	//3.const类型转换
	int x = 10;
	const int constNum = static_cast<const int>(x);
	//4.错误用法
	const int xx = 0;
	//int* p = static_cast<int*>(&xx);// 去掉const 必须用const_cast
	//5.从子到父
	Parent* p = new Son;
	p->print();
	Son* pson = new Son;
	p = static_cast<Parent*>(pson);
	p->print();

	Parent* parent = new Parent;
	Son* son = static_cast<Son*>(parent);
	son->print();
	son->printData();
	son->printParent();
	return 0;
}

    3. dynamic_cast

      #include <iostream>
#include <string>
using namespace std;
/*
	dynamic_cast<要转换类型>(要转换的东西)
	1.上行转换 和static_cast一样的
	2.下行转换 dynamic_cast更安全
	3.交叉转换 多继承
*/
class Parent
{
public:
	Parent(string pName = "父类") :pName(pName) {}
	virtual void print() { 
		cout << pName << endl;
	}
protected:
	string pName;
};
class Son :public Parent
{
public:
	Son(string sName = "子类") :sName(sName) {}
	virtual void print() { 
		cout << sName << endl; 
	}
	//void printData() { cout << gName << endl; }
protected:
	string sName;
};
class A
{
public:
	virtual void print()
	{
		cout << "A" << endl;
	}
};
class B
{
public:
	virtual void print()
	{
		cout << "B" << endl;
	}
};
class C :public A, public B
{
public:
	void print()
	{
		cout << "C";
	}
};


int main()
{
	Parent* parent = new Parent;
	Son* son = new Son;
	//1.上行转换
	Parent* pStatic = static_cast<Parent*>(son);
	Parent* pDyn = dynamic_cast<Parent*>(son);
	pStatic->print();
	pDyn->print();
	//2.下行转换
	Son* pStatic1= static_cast<Son*>(parent);  //不存在virtual 不会报错
	pStatic1->print();  //不存在virtual 会中断
	Son* pDyn1 = dynamic_cast<Son*>(parent);		//dynamic_cast检查父类中是否存在virutal 不存在 类型转换直接错误
	//下行转换，调用子类中父类没有函数会报错
	if (pDyn1 != nullptr)
	{
		pDyn1->print();
	}
	//3.交叉转换

	A* a = new C;
	B* b = dynamic_cast<B*>(a);
	b->print();
	return 0;
}

    4. reinterpret_cast

      #include <iostream>
using namespace std;
int Max(int a, int b)
{
	return  a > b ? a : b;
}
int main()
{
	//把一个指针转换成一个整数，也可以把一个整数转换成一个指针
	int num = reinterpret_cast<int>(Max);
	cout << num << endl;
	cout << Max << endl;
	//先把一个指针转换成一个整数，再把该整数转换成原类型的指针，还可以得到原先的指针值
	auto pMax = reinterpret_cast<int(*)(int, int)>(num);
	cout << pMax(1, 2) << endl;
	return 0;
}

LTSky19950509
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++虚函数实现多态的机制
希望我的博客，能帮上你解决学习中工作中所遇到的问题
03-23 733
虚函数是C++实现多态的机制，那么它是如何做到的呢？ 以下通过反汇编探索虚函数内存模型，查看虚函数实现多态的过程。 工具 Visual studio 2017：以下程序仅做VC++编译器下的32位程序探讨，其他编译器与64位程序所产生的差异不作讨论。 反汇编过程 首先声明一个不包含虚函数的简单C++类，如下： 在构造函数中加入断点，使得反汇编构造函数代码，如图： 当运行到断点时，在Visual...
深入解析C++中的虚函数与多态
01-21
对C++ 了解的人都应该知道虚函数（Virtual Function）是通过一张虚函数表（Virtual Table）和一个指向虚函数表的指针（vptr）来实现的。虚函数表，简称为vtbl，虚函数表表对实现多态起着至关重要
C++:虚函数与多态
2301_79959126的博客
07-26 618
本文介绍了C++中的虚函数与多态的概念，并介绍了虚函数与多态的实现原理。
C++虚函数与多态
qq_63976098的博客
12-23 822
C++虚函数与多态
C++虚函数和多态
雪狼的博客
07-15 1411
C++虚函数和多态
C++虚函数实现多态
蔡松豆的博客
06-03 2722
C++是通过虚函数来解决多态问题的 虚函数，就是在基类声明函数是虚拟的，并不是实际存在的函数，然后再派生类中才正式定义此函数。在程序运行期间，用指针指向某一派生类对象，这样就能调用指针指向的派生类对象中的函数，而不会调用其他派生类中的函数。 注意：虚函数的作用是允许在派生类中重新定义与基类同名的函数，并且可以通过基类指针或者引用来访问基类和派生类中的同名函数。 通过代码看看虚函数的作用#
虚函数和多态
Ryzen3的博客
04-14 2341
虚函数和多态的基础知识
汽车收费（虚函数和多态）
笔记
05-18 761
题目描述 现在要开发一个系统，实现对多种汽车的收费工作。 汽车基类框架如下所示： class Vehicle { protected: string no;//编号 public: virtual void display()=0;//应收费用 } 以Vehicle为基类，构建出Car、Truck和Bus三个类。 Car的收费公式为： 载客数*8+重量*2 Truck的收费公式为：重量*5 Bus的收费公式为： 载客数*3 生成上述类并编写主函数，要求主函数中有一个基类指针Veh
C++ 多态与虚函数
e我所欲也的博客
06-06 677
文章目录1. 多态的概念多态的性质多态的分类2. 虚函数实现动态多态性多态的构成条件虚函数虚函数重写的两个例外（不是特定规则）C++11 override 和 final3.纯虚函数与抽象类纯虚函数：抽象类接口继承和实现继承4.多态的原理虚函数表动态绑定与静态绑定（关联）5.单继承和多继承关系中的虚函数表 多态的概念 多态的定义及实现 抽象类 多态的原理 单继承和多继承关系中的虚函数表 继承和多态常见的面试问题 1. 多态的概念 多态的性质 多态性是面向对象程序设计的一个重要特性。 多态本意：一个事物有
C++ 虚函数与多态
zhongzhh8的博客
10-21 355
虚函数 虚函数是指在多态中，派生类和基类中存在返回类型、名字和参数形式都完全相同的函数，但是实现的函数体不同。 虚函数是多态的基础，没有虚函数就无法实现多态特性。在成员函数前加上一个virtual关键词就可以把函数设置为虚函数 ，当一个成员函数被声明为虚函数后，其派生类中的同名函数都自动成为虚函数。 纯虚函数就是声明后面加上 =0 。 virtual void foo()=0; 纯虚函数在基类中只声明不定义，而在派生类中必须要定义。拥有纯虚函数的类成为抽象类，抽象类不能实例化。 虚函数的实现原理 当一个类
c++虚函数与多态
ruo_bing的博客
10-03 1382
夫人们佛
c++语言中虚函数实现多态的原理详解
12-25
自上一个帖子之间跳过了一篇总结性的帖子，之后再发，今天主要研究了c++语言当中虚函数对多态的实现，感叹于c++设计者的精妙绝伦 c++中虚函数表的作用主要是实现了多态的机制。首先先解释一下多态的概念，多态是c++...
C++虚函数多态和纯虚函数多态的经典示例源码
02-25
总之，C++的虚函数和纯虚函数是实现多态的核心工具。虚函数允许通过基类指针调用派生类的方法，实现运行时多态；而纯虚函数则用于定义抽象基类和接口，确保所有派生类都必须实现某些特定功能。这种灵活性和通用性...
详细分析C++ 多态和虚函数
08-18
详细分析C++多态和虚函数 在C++中，多态和虚函数是两个紧密相关的概念。多态是指在编程语言中，同一个函数名称可以对应不同的函数实现，这取决于调用函数的对象的类型。虚函数则是C++中实现多态的一种机制，它允许...
STL中的迭代器失效（vector为例）
2302_80190394的博客
08-08 333
STL中的迭代器失效（vector为例）
c++ error: ‘*’ does not name a type； did you mean ‘**’?
xiaozhi
08-08 448
c++ error: ‘*’ does not name a type； did you mean ‘**’?
使用vtkRenderer创建的显示点云的窗口如何刷新(QT/C++)
最新发布
qq_19319481的博客
08-09 269
使用vtkRenderer创建的显示点云的窗口如何刷新(QT/C++)
C++ STL专题 list的讲解
Mike的博客
08-07 744
1.list是可以在常数范围内任意位置进行插入和删除的序列式容器，并且可以前后双向迭代。2. list的底层是双链表结构，双向链表中每个元素存储在互不相关的独立节点中，在节点中通过指针指向其前一个元素和后一个元素。3. list与forward_list非常相似：最主要的不同在于forward_list是单链表，只能朝前迭代。4. 与其他的序列式容器相比(vector，deque), list通常在任意位置进行插入，移除元素的执行效率更好。5. 与其他序列式容器相比，
C++ - 函数重载
jiaowenjie的专栏
08-06 329
/打印的是第二个函数的地址。//打印的是第一个函数的地址。-> 重载函数在本质上是相互独立的不同函数。-> 函数返回值不能作为函数重载的依据。-> 重载函数的函数类型不同。**3.函数默认参数和函数重载****函数重载的注意事项：****4.函数重载的本质**
C++虚函数与多态：面向对象编程的关键
多态和虚函数是C++面向对象编程中的两个关键概念，它们在软件设计中发挥着至关重要的作用。多态性是面向对象语言的核心特性之一，它允许程序以一种通用的方式处理不同类型的对象，实现了“what”与“how”的分离，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值