C++初阶--多态

最新推荐文章于 2024-07-21 11:20:00 发布
最新推荐文章于 2024-07-21 11:20:00 发布
阅读量747 收藏 26
点赞数 25
分类专栏： c++ 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_71321720/article/details/128756973
版权

目录

1.多态的概念

2.多态的定义和实现

        2.1多态的构成条件

        2.2虚函数

        2.3重写(覆盖)

3.派生类的析构函数

4.override和final

5.重载、覆盖(重写)、隐藏(重定义)的对比

6.抽象类

7.接口继承和实现继承

8.多态的原理

        8.1虚函数表

        8.2打印虚函数表中内容

1.多态的概念

        多态：多种形态，不同的对象去完成同一件事，结果不同。

2.多态的定义和实现

2.1多态的构成条件

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

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

2.2虚函数

        被virtual修饰的类非静态成员函数

2.3重写(覆盖)

        派生类中有一个跟基类完全相同的虚函数(返回值类型、函数名、参数列表完全相同)，称子类的虚函数重写了基类的虚函数。 
//多态:多种形态
//静态的多态：函数重载,看起来调用同一个函数有不同行为。静态：原理是编译时
//动态的多态：一个父类的引用或指针去调用同一个函数，传递不同的对象，会调用不同的函数。动态：原理是运行时实现
//本质：不同人去做同一件事情，结果不同
class Person
{
public:
	virtual void BuyTicket()
	{
		cout << "买票-全价" << endl;
	}
};

class Student : public Person
{
public:
	//子类中满足三同(函数名、参数、返回值)(协变除外) 、 虚函数,  叫做  重写（覆盖）
	virtual void BuyTicket()
	{
		cout << "买票-半价" << endl;
	}
};

//构成多态，跟p的类型没有关系，传的哪个类型的对象，调用的就是这个类型的虚函数 -- 跟对象有关
//不构成多态，调用的就是p类型的函数 -- 跟类型有关

void Func(Person& p)
{
	p.BuyTicket();     //多态
}

int main()
{
	Person ps;
	Student st;

	Func(ps);
	Func(st);

	return 0;
}

        重写要求返回值相同有一个例外:协变--要求返回值是父子关系的引用或指针

//重写要求返回值相同有一个例外：协变--要求返回值是父子关系的指针或引用
class A{};
class B : public A{};

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

class Student : public Person
{
public:
	virtual B* BuyTicket()
	{
		cout << "买票-半价" << endl;
		return nullptr;
	}
};

void Func(Person& p)
{
	p.BuyTicket();     
}

int main()
{
	Person ps;
	Student st;

	Func(ps);
	Func(st);

	return 0;
}

3.派生类的析构函数

        动态申请的父子对象，如果给了父类指针管理，那么需要析构函数是虚函数完成重写，构成多态，那么才能正确调用析构函数。析构函数名被特殊处理了，处理成了destructor。

//析构函数名被特殊处理了，处理成了destructor
class Person
{
public:
	virtual ~Person()
	{
		cout << "~Person()" << endl;
	}
};

class Student : public Person
{
public:
	virtual ~Student()
	{
		cout << "~Student()" << endl;
	}
};

int main()
{
	//普通对象，析构函数是否虚函数，是否完成重写，都正确调用了
	//Person p;
	//Student s;

	//动态申请的父子对象，如果给了父类指针管理，那么需要析构函数是虚函数完成重写，构成多态，那么才能正确调用析构函数
	Person* p1 = new Person;         //operator new + 构造函数
	Person* p2 = new Student;

	//析构函数 + operator delete                
	delete p1;      //p1->destructor()
	delete p2;		//p2->destructor()				

	return 0;
}

        虚函数的重写允许两个都是虚函数或者父类是虚函数，再满足三同，就构成重写

//虚函数的重写允许两个都是虚函数或者父类是虚函数，再满足三同，就构成重写
class Person
{
public:
	virtual void BuyTicket() { cout << "买票-全价" << endl;}

	virtual ~Person() { cout << "~Person()" << endl;}
};

class Student : public Person
{
	//虽然子类没写virtual，但是他是先继承了父类的虚函数的属性，再完成重写。也算虚函数
	void BuyTicket() { cout << "买票-半价" << endl;}
public:
	~Student() { cout << "~Student()" << endl;}
};

void Func(Person& p)
{
	p.BuyTicket();     
}

4.override和final

        设计一个不能被继承的类 (C++98)

//设计一个不能被继承的类
//C++98

class A
{
private:
	A(int a = 0)
		:_a(a)
	{}

public:
	static A CreatOBj(int a = 0)
	{
		//new A;
		return A(a);
	}

protected:
	int _a;
};

//间接限制，子类构成函数无法调用父类构造函数初始化成员，没办法实例化对象

class B : public A
{};

int main()
{
	A aa = A::CreatOBj(10);

	return 0;
}

        final修饰类  该类不能被继承

//C++11 直接限制
class A final
{
protected:
	int _a;
};

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

        final修饰虚函数  该虚函数不能被子类虚函数重写

//C++11 final 修饰虚函数，限制他不能被子类中的虚函数重写
class C
{
public:
	virtual void f() final
	{
		cout << "C::f()" << endl;
	}
};

class D : public C
{
public:
	//virtual void f() final
	//{
	//	cout << "D::f()" << endl;
	//}
};

        override：放在子类重写的虚函数后面，检查是否完成重写，没有重写就报错

//override放在子类重写的虚函数的后面，检查是否完成重写
//没有重写就报错
class Car
{
public:
	void Drive()
	{}
};

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

5.重载、覆盖(重写)、隐藏(重定义)的对比

重载

1.两个函数在同一作用域

2.函数名相同，参数不同

覆盖(重写)

1.两个函数分别在基类和派生类作用域

2.函数名，参数，返回值都相同(协变例外)

3.两个函数是虚函数

隐藏(重定义)

1.两个函数分别在基类和派生类作用域

2.函数名相同

3.两个基类和派生类同名的函数，不构成重写就是重定义

6.抽象类

        在虚函数后面加上=0，这个函数为纯虚函数。包含纯虚函数的类叫做抽象类(也叫接口类),抽象类不能实例化出对象。派生类继承后也不能实例化出对象，只有重写纯虚函数，派生类才能实例化出对象。纯虚函数要求派生类必须重写，更体现出了接口继承。 

class Car
{
public:
	//纯虚函数一般只声明，不实现
	//实现没有价值
	//virtual void Drive() = 0;
	virtual void Drive() = 0
	{
		cout << "virtual void Drive() = 0" << endl;
	}

	void f()
	{
		cout << "void f()" << endl;
	}
};

int main()
{
	Car* p = nullptr;
	//p->Drive();

	return 0;
}

7.接口继承和实现继承

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

8.多态的原理

        8.1虚函数表

//sizeof(Base)是多少？--12
class Base
{
public:
	virtual void Func1()
	{
		cout << "Func1()" << endl;
	}

	virtual void Func2()
	{
		cout << "Func2()" << endl;
	}

private:
	int _b = 1;
	char _ch = 'A';
};

int main()
{
	cout << sizeof(Base) << endl;
	Base bb;

	return 0;
}

        对象中的这个指针我们叫做虚函数表指针(v代表virtual，f代表function)

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

	void f(){cout << "f()" << endl;}

protected:
	int _a = 0;
};

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

protected:
	int _b = 0;
};

void Func(Person& p)
{
	//多态调用，在编译时，不能确定调用的是哪个函数
	//运行时，去p指向对象的虚表中找到虚函数的地址
	p.BuyTicket();
	p.f();
}

//普通函数与虚函数存储的位置是否一样？
//一样，都在代码段。虚函数要把地址存到虚表，方便实现多态

int main()
{
	Person Mike;
	Func(Mike);

	Student Johnson;
	Func(Johnson);

	Person& r1 = Johnson;
	Person p = Johnson;

	//Person p1 = Mike;
	//Person p2 = Johnson;
	 不是多态，编译时确定地址
	//p1.BuyTicket();
	//p2.BuyTicket();

	return 0;
}
1. 派生类对象有一个虚表指针，由两部分构成，一部分是父类继承下来的成员。
2. 基类对象和派生类对象虚表不一样，所以虚函数的重写也叫作覆盖，覆盖就是指虚表中虚函数
的覆盖。重写是语法的叫法，覆盖是原理层的叫法。
4. 虚函数表本质是一个存虚函数指针的指针数组，一般情况这个数组最后面放了一个nullptr。
5. 派生类的虚表生成：a.先将基类中的虚表内容拷贝一份到派生类虚表中 b.如果派生类重写了基类中某个虚函数，用派生类自己的虚函数覆盖虚表中基类的虚函数 c.派生类自己新增加的虚函数按其在派生类中的声明次序增加到派生类虚表的最后。
6. 虚函数存在哪?虚表存在哪?虚表存的是虚函数指针，不是虚函数，虚函数和普通函数一样，都是存在代码段的，只是他的指针又存到了虚表中。另外对象中存的不是虚表，存的是虚表指针。那么虚表存在哪的呢？vs下是存在代码段的。 

        8.2打印虚函数表中内容

typedef void(*VF_PTR)();

//打印虚函数表中内容
void PrintVFTable(VF_PTR* table)
{
	for (int i = 0; table[i] != nullptr; ++i)
	{
		printf("vft[%d]:%p->", i, table[i]);
		VF_PTR f = table[i];
		f();
	}
	cout << endl;
}
typedef void(*VF_PTR)();

//打印虚函数表中内容
void PrintVFTable(VF_PTR* table)
{
	for (int i = 0; table[i] != nullptr; ++i)
	{
		printf("vft[%d]:%p->", i, table[i]);
		VF_PTR f = table[i];
		f();
	}
	cout << endl;
}

//单继承
class Base
{
public:
	Base()
	{
		a = 0;
	}

	virtual void func1(){ cout << "Base::func1" << endl; }
	virtual void func2(){ cout << "Base::func2" << endl; }

private:
	int a = -1;
};

class Derive :public Base
{
public:
	virtual void func1(){ cout << "Derive::func1" << endl; }
	virtual void func3(){ cout << "Derive::func3" << endl; }
	void fun4(){ cout << "Derive::func4" << endl; }

private:
	int b;
};

int main()
{
	Base b;
	//b.func1();

//#ifdef _WIN64
//	PrintVFTable((VF_PTR*)(*(long long*)&b));
//#else
//	PrintVFTable((VF_PTR*)(*(int*)&b));
//#endif
//

	PrintVFTable((VF_PTR*)(*(void**)&b));

	return 0;
}
1. inline函数可以是虚函数，不过编译器就忽略inline属性，这个函数就不再是inline，因为虚函数要放到虚表中去。调用时，如果不构成多态，这个函数保持inline属性，如果构成多态，这个函数就没有inline属性了。
2. 静态成员不可以是虚函数，因为静态成员函数没有this指针，使用类型::成员函数 的调用方式无法访问虚函数表，所以静态成员函数无法放进虚函数表。
3. 构造函数不可以是虚函数。因为对象中的虚函数表指针是在构造函数初始化列表阶段才初始化的。
4. 析构函数可以是虚函数吗？什么场景下析构函数是虚函数？答：可以，并且最好把基类的析构函数定义成虚函数。
5. 对象访问普通函数快还是虚函数更快？答：首先如果是普通对象，是一样快的。如果是指针对象或者是引用对象，则调用的普通函数快，因为构成多态，运行时调用虚函数需要到虚函数表中去查找。
6. 虚函数表是在什么阶段生成的，存在哪的？虚函数表是在编译阶段就生成的，一般情况下存在代码段(常量区)的。
7.抽象类强制重写了虚函数，另外抽象类体现出了接口继承关系。

=eqwe11
关注
  • 25
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 9
    评论
专栏目录
C++初阶--类和对象
weixin_74792326的博客
05-23 799
1、声明和定义全部都放在类体中，但是需要注意的是如果在类中定义，编译器可能会将其当成内联函数处理。2、类声明在.h文件中，成员函数定义放在.cpp文件中。但是在.cpp中要在成员函数前面加*一般情况下推荐第二种。
C++进阶----多态
qq_41420788的博客
01-29 1030
C++进阶----多态2）多态①多态实现虚函数重写Ⅰ.特例1--协变Ⅱ.特例2--析构函数重写override final重载 / 重写 / 隐藏②抽象类 2）多态 ①多态实现 多态是在不同继承关系的类对象，去调用同一函数，产生了不同的行为 比如： 多态的构成条件： 必须通过基类的指针或者引用调用虚函数 被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写 虚函数重写 虚函数的重写(覆盖)：派生类中有一个跟基类完全相同的虚函数(即派生类虚函数与基类虚函数的返回值类型、函数名字、参数
C++ 基础 --多态
Iiverson2000的博客
10-13 265
C++--多态多态多态的概念多态的定义虚函数虚函数的重写虚函数重写的两个例外C++11 override 和 final重载、重写（覆盖）、隐藏（重定义）对比 多态 多态的概念 当完成某个行为时，不同的对象去完成，会有不同的状态 举个小栗子：买票这个行为，学生买会有打折，普通人买全价票，军人可以优先购票 —多态性为 多态分为静态多态和动态多态，其中静态多态就是我们所熟知的函数重载。这里静态的含义是指：在编译期间完成的事件 而我们今天主要了解的是动态多态，也就是在进程运行期间的多态。 多态的定义 多态是不同
C++基础之多态
someday1314的博客
03-27 300
一.多态概念 多态：一词最初来源于希腊语，意思是：多种形态。 多态分为静态多态和动态多态。静态多态分为函数重载和泛型编程。动态多态是通过虚函数来实现的。 静态多态（叫静态绑定或早绑定）：编译器在编译期间完成的，，编译器可以根据函数实参的类型（可能会进行隐式的类型转换）注意：宏不是静态多态，宏是在预处理阶段完成的 动态多态（又叫动态绑定或者晚绑定）：在程序执行期间判断所引用对象的实际类型根据其实际类型
C++ 补充-多态
05-17
C++补充-多态,简绍了有很多有用的东西，值得学习参考！希望对你有用！
C++实验-多态
04-06
C++实验-多态
C++-05继承和多态
03-11
C++继承和多态的学习笔记
C++实战-基于多态的企业职工管理系统
03-22
在本项目"C++实战-基于多态的企业职工管理系统"中，我们将探讨如何使用C++语言构建一个具有实际应用价值的软件系统。这个系统的核心特性是利用C++的多态性来实现灵活、可扩展的职工管理功能。多态性是面向对象编程的...
(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度
qq_44962949的博客
07-17 242
【代码】(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度。
C++ 继承篇
2301_79201049的博客
07-18 667
必须对继承而来的成员进行初始化直接通过初始化列表或者赋值的方式进行初始化调用父类构造函数进行初始化
学懂C语言系列（三）：C语言基本语法
martian665的专栏
07-17 572
学懂C语言系列,C语言基本语法
C++笔记3：基类指针delete子类对象的内存泄漏问题
最新发布
subtitle_的博客
07-21 142
C++笔记3：基类指针delete子类对象的内存泄漏问题
2024年华为OD机试真题-虚拟游戏理财-C++-OD统一考试（C卷D卷）
面试高手的博客
07-21 5793
现有一家Bank，它提供有若干理财产品m，风险及投资回报不同，你有N（元）进行投资，能接受的总风险值为X。第一行：产品数(取值范围[1, 20])，总投资额(整数，取值范围[1, 10000])，可接受的总风险(整数，取值范围[1, 200])投资第二项30个单位，第四项40个单位，总的投资风险为两项相加为4+6=10。第四行：最大投资额度序列，输入为整数，取值范围[1,10000]第二行：产品投资回报率序列，输入为整数，取值范围[1,60]第三行：产品风险值序列，输入为整数，取值范围[1,100]
【C++】获取环境变量
热门推荐
Badme
07-18 1万+
【C++】获取环境变量
C语言强化-1.数据结构概述
Annabelle___的博客
07-18 650
与408的关联：1. 逻辑结构和存储结构在选择题中会有涉及。2. 时间复杂度几乎是每一年大题必考内容！
【C++修炼之路 第三章】内存管理：new 与 delete
唯有忍受别人不能忍受的，才能享受别人不能享受的
07-18 695
【含常见面试题】new & delete 的概念与用法 + 定位new表达式 + malloc/free 和 new/delete 的区别
Windows 点云生成二维栅格图 [附C++完整代码实现]
weixin_43896283的博客
07-17 7877
三维点云数据转换为二维栅格图
C语言中的指针函数和函数指针
letterljhx的博客
07-18 470
C语言中的指针函数和函数指针
C#多态--虚方法实现多态
06-02
在C#中，多态是指在不同的情况下，同一个方法名可以具有不同的行为。实现多态的一种常见方式是使用虚方法。 在C#中，通过在父类中声明一个虚方法，在子类中覆盖该方法并实现不同的行为。当我们调用该方法时，实际执行的是子类中的方法。 下面是一个简单的例子： ``` class Animal { public virtual void MakeSound() { Console.WriteLine("The animal makes a sound"); } } class Cat : Animal { public override void MakeSound() { Console.WriteLine("The cat meows"); } } class Dog : Animal { public override void MakeSound() { Console.WriteLine("The dog barks"); } } class Program { static void Main(string[] args) { Animal animal1 = new Animal(); Animal animal2 = new Cat(); Animal animal3 = new Dog(); animal1.MakeSound(); animal2.MakeSound(); animal3.MakeSound(); } } ``` 在上面的例子中，我们声明了一个基类`Animal`，其中包含一个虚方法`MakeSound()`。然后我们创建了两个子类`Cat`和`Dog`，并且覆盖了基类中的`MakeSound()`方法。最后在主函数中，我们分别创建了一个基类对象和两个子类对象，并且调用了它们的`MakeSound()`方法。 运行程序后，输出结果如下： ``` The animal makes a sound The cat meows The dog barks ``` 可以看到，当我们调用`MakeSound()`方法时，实际执行的是该对象的子类中的方法。这就是多态的实现方式之一。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值