C++多态【上】

最新推荐文章于 2024-05-22 17:03:04 发布
最新推荐文章于 2024-05-22 17:03:04 发布
阅读量121 收藏 1
点赞数
分类专栏： 遣返回家的C家家 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LHRan_ran_/article/details/132320251
版权

在这里插入图片描述

文章目录

1.多态的介绍

1.1概念

在这里插入图片描述
简单来说，同样一种行为，不同对象完成时会呈现不同的状态。比如：

  1. 吃东西 牛吃草 狼吃羊 猫吃鱼
  2. 买票 学生票 军人票 普通票

1.2分类

静态多态: 函数重载 和 运算符重载 — 编译阶段确定函数地址
动态多态: 虚函数 — 运行阶段确定函数地址

2.多态的实现

2.1虚函数的介绍

1.定义

被virtual修饰的类的成员函数
在这里插入图片描述

2.重写

1.通常情况

派生类重写基类的虚函数：派生类中有一个跟基类完全相同的虚函数(返回值类型、函数名字、参数列表完全相同)

2.特例
  1. 子类重写父类的虚函数【不加virtual也构成重写–继承基类的虚函数后实现】
  2. 协变：返回值是父子关系的指针或引用–返回值不同也构成重写

对照组：

class Animal
{
public:
   virtual void express()
   {
        cout << "我在疯狂动物叫" << endl;
   }
};

class Dog :public Animal
{
public:
    virtual void express()
    {
        cout << "我在疯狂狗叫" << endl;
    }

};
void func(Animal& animal)
{
    animal.express();
}
int main() 
{
    Animal animal;
    func(animal);
    Dog dog;
    func(dog);
    return 0;
}

实验组1：

class Animal
{
public:
    virtual Animal* express()
    {
        cout << "我在疯狂动物叫" << endl;
        return this;
    }

};

class Dog :public Animal
{
public:
    virtual Dog* express()
    {
        cout << "我在疯狂狗叫" << endl;
        return this;
    }

};
void func(Animal& animal)
{
    animal.express();
}
int main()
{
    Animal animal;
    func(animal);
    Dog dog;
    func(dog);
    return 0;
}

实验组2：

class Ox  //牛
{

};
class Bull :public Ox//公牛
{

};
class Animal
{
public:
    virtual Ox* express()
    {
        cout << "我在疯狂动物叫" << endl;
        return nullptr;
    }

};

class Dog :public Animal
{
public:
    virtual Bull* express()
    {
        cout << "我在疯狂狗叫" << endl;
        return nullptr;
    }

};
void func(Animal& animal)
{
    animal.express();
}
int main()
{
    Animal animal;
    func(animal);
    Dog dog;
    func(dog);
    return 0;
}

2.2多态构成条件

  1. 指向子类对象的基类指针或引用调用虚函数
  2. 派生类重写基类的虚函数
class Animal
{
public:
   virtual void express()
   {
        cout << "我在疯狂动物叫" << endl;
   }
};

class Dog :public Animal
{
public:
    virtual void express()
    {
        cout << "我在疯狂狗叫" << endl;
    }

};
void func(Animal& animal)
{
    animal.express();
}
int main() 
{
    Animal animal;
    func(animal);
    Dog dog;
    func(dog);
    return 0;
}

在这里插入图片描述

例题

在这里插入图片描述

class A
{
public:
	virtual void func(int value = 1) 
	{ 
		cout << "A->" << value << endl; 
	}
	virtual void test() 
	{ 
		func();
	}
};
class B : public A
{
public:
	void func(int value = 0)
	{ 
		cout << "B->" << value << endl; 
	}
};
int main()
{
	A* pb = new B;  //B -> 1
	
	pb->test();
	return 0;
}

2.3破坏多态的情况

1.父类没有虚函数 子类有对应虚函数重写

class Dad
{
public:
	void Cook()
	{
		cout << "佛跳墙" << endl;
	}

	virtual void Work()
	{
		cout << "Work" << endl;
	}
	int _a = 0;
};

class Son : public Dad
{
public:
	virtual void Cook()
	{
		cout << "方便面" << endl;
	}

	int _b = 0;
};

void Test(Dad& p)
{
	p.Cook();
}

int main()
{
	Dad dad;
	Test(dad);

	Son son;
	Test(son);

	return 0;
}

父类没有虚函数表 编译时就已经确定了函数地址 即不论父类或子类对象调用的都是父类的成员函数

2.父类有虚函数 子类没有重写对应虚函数

#define _CRT_SECURE_NO_WARNINGS 
#include <iostream>
#include <list>
#include <vector>
#include <algorithm>
#include <array>
#include <time.h>
#include <queue>
using namespace std;

class Dad
{
public:
	virtual void Cook()
	{
		cout << "佛跳墙" << endl;
	}

	virtual void Work()
	{
		cout << "Work" << endl;
	}
	int _a = 0;
};

class Son : public Dad
{
public:
	/*virtual void Cook()
	{
		cout << "方便面" << endl;
	}*/

	int _b = 0;
};

void Test(Dad& p)
{
	p.Cook();
}

int main()
{
	Dad dad;
	Test(dad);

	Son son;
	Test(son);

	return 0;
}

父类有虚函数 运行时才确定函数地址 只不过子类没有重写 虚函数表存放的均为父类的虚函数地址 所以均调用父类的成员函数

2.4虚析构和纯虚析构

1.虚析构

1.一般情况：调用完子类析构后自动调用父类析构

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

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

	//int* _ptr;
};

class Student : public Person 
{
public:
	Student()
	{
		cout << "Student()" << endl;
	}
	// 析构函数名底层为：destructor -- 构成虚函数重写
	~Student() 
	{
		cout << "~Student()" << endl;
	}
};

int main()
{
	Student s;

	return 0;
}

在这里插入图片描述
2.没有虚析构导致错误的场景

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

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

	//int* _ptr;
};

class Student : public Person 
{
public:
	Student()
	{
		cout << "Student()" << endl;
	}
	// 析构函数名底层为：destructor -- 构成虚函数重写
	~Student() 
	{
		cout << "~Student()" << endl;
	}
};

int main()
{
	Person* ptr1 = new Person;
	delete ptr1;

	Person* ptr2 = new Student;
	delete ptr2;
    
	return 0;
}

在这里插入图片描述
3.成功样例

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

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

	//int* _ptr;
};

class Student : public Person 
{
public:
	Student()
	{
		cout << "Student()" << endl;
	}
	// 析构函数名底层为：destructor -- 构成虚函数重写
	virtual ~Student() 
	{
		cout << "~Student()" << endl;
	}
};

int main()
{
	Person* ptr1 = new Person;
	delete ptr1;

	Person* ptr2 = new Student;
	delete ptr2;                  //ptr2 -> destructer();
                                  //operator delete(ptr2);
	return 0;
}

在这里插入图片描述

2.纯虚析构

class Dad 
{
public:

    Dad()
    {
        cout << "Dad 构造函数调用！" << endl;
    }

    //虚析构函数
    //virtual ~Dad()
    //{
    //    cout << "Dad 虚析构函数调用！" << endl;
    //}
    //**虚析构和纯虚析构都必须有函数【实现】
    //纯虚析构函数
    virtual ~Dad() = 0;

    virtual void Name() = 0;

};

Dad::~Dad()
{
    cout << "Dad 纯虚析构函数调用！" << endl;
}

class Son : public Dad
{
public:
    Son(string name)
    {
        cout << "Son 构造函数调用！" << endl;
        _name = new string(name);
    }
   
    ~Son()
    {
        cout << "Son 析构函数调用!" << endl;
        if (this->_name != NULL) 
        {
            delete _name;
            _name = NULL;
        }
    }

    virtual void Name()
    {
        cout << *_name << "是son的名字" << endl;
    }
public:
    string* _name;
};

int main() 
{

    Dad* dad = new Son("Mike");
    dad->Name();

    delete dad;

    return 0;
}

在这里插入图片描述

3.虚析构/纯虚析构存在的意义

  1. 虚析构语法：virtual ~类名(){}
    纯虚析构语法： virtual ~类名() = 0; 类名::~类名(){}
  2. 二者目的皆是能够【delete指向子类对象的父类指针】时正确调用析构函数。
    区别在于：纯虚析构适用于：当前基类作为一个抽象类，不想要实例化对象，只作为子类的父类，并且可以强制子类重写析构函数。
    但是使用虚析构和纯虚析构需要注意：二者必须有函数实现–虚析构在类内即可完成函数实现–纯虚析构需要在类外完成。
    如果子类中没有堆区数据，可以不写为虚析构或纯虚析构

2.5总结及拓展

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

在这里插入图片描述

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

在这里插入图片描述

在这里插入图片描述

3.重载、覆盖(重写)、隐藏(重定义)

重载：

两个函数在同一作用域
函数名相同参数不同（类型个数顺序 ）

重写(覆盖)：

两个函数分别在基类和派生类的作用域
R_函数名/参数/返回值都必须相同(协变例外)
两个函数必须是虚函数

重定义(隐藏)：子类和父类中有同名成员，直接访问时将屏蔽父类同名成员

两个函数分别在基类和派生类的作用域
函数名相同
两个基类和派生类的同名函数不构成重写就是重定义

2.6抽象类

通常多态中父类虚函数的实现是毫无意义的，主要都是调用子类重写的内容
因此可以将虚函数改为纯虚函数
纯虚函数语法：virtual 返回值类型 函数名 （参数列表）= 0 ;
当类中有了纯虚函数，这个类称为抽象类
抽象类特点：

  • 无法实例化对象
  • 子类必须重写抽象类中的纯虚函数，否则也属于抽象类

1.概念

包含纯虚函数的类叫做抽象类（接口类），抽象类不能实例化出对象。
派生类只有重写纯虚函数后才能实例化对象。

  1. 纯虚函数规范了派生类必须重写
  2. 纯虚函数体现出了接口继承

2.接口继承和实现继承

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

3.代码演示

class Plant
{
public:
	virtual void Breath() = 0;
};
class Rose :public Plant
{
public:
	virtual void Breath()
	{
		cout << "Rose-疏影暗香" << endl;
	}
};
class Grass :public Plant
{
public:
	virtual void Breath()
	{
		cout << "Grass-生生不息" << endl;
	}
};
void Test()
{
	Plant* pRose = new Rose;
	pRose->Breath();

	Plant* pGrass = new Grass;
	pGrass->Breath();
}
int main()
{
	Test();
	return 0;
}

在这里插入图片描述

阿猿收手吧！
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
c++多态总结
08-30
c++多态总结，vptr总结，多态原理探究
C++多态Demo
05-01
长方形和三角形均继承于形状，拥有高和宽，分别求面积
C++ 多态的游戏例程
01-20
1）头文件 game.h #ifndef GAME_H #define GAME_H // base class class CCreature { protected: int m_nLifePower， m_nPower; public: virtual void Attack(CCreature *pCreature){} virtual void Hurted...
c++多态解析1
08-08
2.只有类的成员函数才能说明为虚函数，因为虚函数仅适合用与有继承关系的类对象，所以普通函数不能说明为虚函数 3.静态成员函数不能是虚函数,因为静态成员函数的特点
C++多态解释1
08-08
2.只有类的成员函数才能说明为虚函数，因为虚函数仅适合用与有继承关系的类对象，所以普通函数不能说明为虚函数 3.静态成员函数不能是虚函数,因为静态成员函数的特点
C语言 变量的存储类型
weixin_45966674的博客
05-21 481
今天 我们来说变量的存储类型变量的存储类型是指系统为变量分配存储区域的方式。决定着变量存储空间在哪里分配，和变量的生存期、作用域存在着一定联系。
C语言——函数指针与指针函数
qq_67319052的博客
05-19 639
函数指针与指针函数有什么区别？
C/C++免杀--原生态(GG)
金灰的博客
05-20 395
看个热闹吧... metasploit payload运行原理浅析(sockedi调用约定是什么) lib/msf/core/payload/windows/reverse_tcp.rb: metasploit-framework/lib/msf/core/payload/windows/reverse_tcp.rb at master · rapid7/metasploit-framework · GitHub 原生态: MSF: #include <Windows
【C++】初始化列表
qq_46049113的博客
05-19 169
当创建一个类的实例时，类的构造函数会被调用来初始化该实例。构造函数可以通过其体（即大括号内的代码部分）或通过初始化列表来初始化成员变量。：使用初始化列表可以直接初始化成员变量，而不是先默认构造成员然后再赋值。：对于常量成员变量和引用成员，初始化列表是必需的，因为这些类型的成员一旦创建后就不能再被赋值。：如果一个类继承自基类，或者它包含其他类的对象作为成员，这些基类和成员对象只能通过初始化列表进行初始化。这种初始化方式确保了代码的效率和成员变量的正确设置，特别是在涉及复杂类型或类的资源管理时尤为重要。
STL--set和multiset集合
m0_75266675的博客
05-20 1049
STL--set和multiset集合
手搓顺序表（C语言）
m0_62646213的博客
05-19 834
顺序表头插头删，尾插尾删，任意位置插入删除的实现和优劣分析
初识C语言+第二十三天
硬件菜鸟的成长之路
05-19 289
【代码】初识C语言+第二十三天。
PointCloudLib 点云随机降采样 C++版本
linux_huangyu的博客
05-21 24
随机降采样是众多降采样算法中，速度最快的（应该是），多次测试之后感觉降采样还是比较平均。
C++之std::numeric_limits
mls805379973的博客
05-21 155
在 C++ 中，是一个模板类，它用于查询各种数据类型（如整数、浮点数等）的属性。对于浮点类型（如double），提供了几个静态成员函数和静态常量，用于获取该类型的属性。是一个静态成员函数，它返回double类型能够表示的最小的有限值。与不同，后者返回的是最小的正值（最接近 0 的正数）。以下是一个使用。
C语言：字符函数和字符串函数
最新发布
2301_80416749的博客
05-22 897
在不同的系统和C语⾔标准库的实现中都规定了⼀些错误码，⼀般是放在 errno.h 这个头⽂件中说明 的，C语⾔程序启动的时候就会使⽤⼀个全⾯的变量errno来记录程序的当前错误码，只不过程序启动 的时候errno是0，表⽰没有错误，当我们在使⽤标准库中的函数的时候发⽣了某种错误，就会讲对应 的错误码，存放在errno中，⽽⼀个错误码的数字是整数很难理解是什么意思，所以每⼀个错误码都是 有对应的错误信息的。• strtok函数找到str中的下⼀个标记，并将其⽤ \0 结尾，返回⼀个指向这个标记的指针。
C++(24): C++17探索：std::variant的使用
tecsai的博客
05-21 390
std::variant是C++标准库中的一个模板类，它允许我们在一种类型安全的方式下存储多种类型的值。它的行为类似于C语言中的联合体（union），但提供了更多的类型安全性和功能。与C语言的联合体不同，std::variant跟踪其当前持有的类型，并确保在使用时不会出现未定义的行为。
【C++】牛客——BC157 素数回文
一岁就可帅的博客
05-21 432
备注。
C/C++常用错误 or 规范注意
xuexiwd的博客
05-20 176
之前做过关于python报错集（未来如果出现一些有意义的错误还是会继续更新的），今天记录一下C/C++的一些常见错误（可能其实不算error，只是根据规范，尽量提升代码质量）
【C++】＜知识点＞ 标准模板库STL（上）
致力于Linux的博客
05-21 589
C++中的标准模板库STL内容（上）
c++ 多态
05-25
C++中的多态（Polymorphism）是指在父类和子类之间的相互转换，以及在不同对象之间的相互转换。 C++中的多态性有两种：静态多态和动态多态。 1. 静态多态 静态多态是指在编译时就已经确定了函数的调用，也称为...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

阿猿收手吧！

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

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

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

打赏作者

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

抵扣说明：

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

余额充值