C++ 多态(2): 纯虚函数, 抽象类和接口类

青旅半醒 2024-04-18 19:06 69阅读 0赞

![在这里插入图片描述][20190910205236707.png_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly94aW9uZ3lpbWluZy5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70_pic_center]

### 文章目录 ###

*  1 纯虚函数和抽象类
 *   *  代码示例
 *  2 接口类
 *   *  代码示例
 *  参考资料

**注：转载请标明原文出处链接：**https://xiongyiming.blog.csdn.net/article/details/100711676

# 1 纯虚函数和抽象类 #

如下图所示，纯虚函数没有函数体，在函数声明后加上=0 .

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly94aW9uZ3lpbWluZy5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70_pic_center]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly94aW9uZ3lpbWluZy5ibG9nLmNzZG4ubmV0_size_10_color_FFFFFF_t_70_pic_center]

这里，我们把含有**纯虚函数**的类称之为 **抽象类**。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly94aW9uZ3lpbWluZy5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70_pic_center 1]

**抽象类的特性：**  
(1) 抽象类无法实例化对象;  
(2) 抽象类的子类也为是抽象类；

例如，如下图所示，在定义父类Person时，我们不知道虚函数work() 和printInfo()函数不知道要实现什么功能时，可以直接使用纯虚函数。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly94aW9uZ3lpbWluZy5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70_pic_center 2]

接下来，对于子类Worker继承父类Person时，纯虚函数也继承下来，对于printInfo()函数想实现什么功能，就可以写函数体了，此时，printInfo()函数变成了虚函数。work() 还不知道要实现什么功能时，可以继续使用纯虚函数。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly94aW9uZ3lpbWluZy5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70_pic_center 3]

然后，对于子类Dustman继承父类Person时，纯虚函数也继承下来，对于work() 和printInfo()函数想实现什么功能，就可以写函数体了，此时，work() 和printInfo()函数变成了虚函数。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly94aW9uZ3lpbWluZy5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70_pic_center 4]

## 代码示例 ##

**要求**

纯虚函数抽象类

1.  Person类  
    成员函数：构造函数 虚析构函数 纯虚函数work  
    数据成员：名字m\_strName
2.  Worker类  
    成员函数：构造函数 虚析构函数 work  
    数据成员：年龄m\_iAge
3.  Dustman类  
    成员函数：构造函数 work

Person.h

#pragma once
    #include<iostream>
    #include<string>
    
    using namespace std;
    
    class Person
    {
        
    public:
    	Person(string name);
    	virtual void work() = 0;//纯虚函数
    	virtual ~Person(); //虚析构函数
    
    private:
    	string m_strName;
    };

Person.cpp

#include"Person.h"
    using namespace std;
    
    
    Person::Person(string name)
    {
        
    	m_strName = name;
    }
    
    
    Person::~Person()
    {
        
    	cout << "~Person()" << endl;
    }

Worker.h

#pragma once
    #include<iostream>
    #include<string>
    #include"Person.h"
    using namespace std;
    
    class Worker :public Person
    {
        
    public:
    	Worker(string name, int age);
    	virtual ~Worker();
    	virtual void work();
    
    private:
    	int m_iAge;
    };

Worker.cpp

#include<iostream>
    #include<string>
    #include"Worker.h"
    using namespace std;
    
    Worker::Worker(string name, int age):Person(name)
    {
        
    	m_iAge = age;
    }
    
    
    
    Worker::~Worker()
    {
        
    	cout << "~ Worker()" << endl;
    }
    
    void Worker::work()
    {
        
    	cout << "work()" << endl;
    }

Dustman.h

#pragma once
    #include<iostream>
    #include<string>
    #include"Worker.h"
    using namespace std;
    
    class Dustman :public Worker 
    {
        
    public:
    	Dustman(string name, int age);
    	virtual void work();
    
    
    };

Dustman.cpp

#include<iostream>
    #include<string>
    #include"Dustman.h"
    
    using namespace std;
    
    Dustman::Dustman(string name, int age):Worker(name, age)
    {
        
    
    }
    
    void Dustman::work()
    {
        
    	cout << "Dustman 扫地 " << endl;
    }

main.cpp

#include<iostream>
    #include"Person.h"
    #include"Worker.h"
    #include"Dustman.h"
    using namespace std;
    
    
    
    /***************
    纯虚函数抽象类
    1.Person类
    	成员函数：构造函数 虚析构函数 纯虚函数work
    	数据成员：名字m_strName
    
    2. Worker类
    	成员函数：构造函数 虚析构函数 work
    	数据成员：年龄m_iAge
    
    3. Dustman类
    	成员函数：构造函数 work
    	
    ***************/
    
    int main(void)
    {
        
    	/* 父类Person work()为纯虚函数
    	子类Worker work()为虚函数 */
    	Worker worker("zhangsan", 20);
    	worker.work();
    	cout << "--------------" << endl;
    
    
    	/* 父类Person work()为纯虚函数
    	子类Worker work()为虚函数
    	子类Dustman work()为虚函数*/
    	Dustman dustman("lisi", 50);
    	dustman.work();
    
    	cin.get();
    	return 0;
    
    }

**运行结果**

![在这里插入图片描述][20190910204308781.png_pic_center]

# 2 接口类 #

**接口类：仅含有纯虚函数的类称之为接口类。**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly94aW9uZ3lpbWluZy5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70_pic_center 5]

**接口类**更多的表达一种能力或协议。

如下所示，Flyable接口类含有两个纯虚函数，那么只有继承这个类，去实现起飞和降落两个函数后，Flyable类才具有能力/协议。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly94aW9uZ3lpbWluZy5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70_pic_center 6]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly94aW9uZ3lpbWluZy5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70_pic_center 7]

再举一个例子

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly94aW9uZ3lpbWluZy5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70_pic_center 8]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly94aW9uZ3lpbWluZy5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70_pic_center 9]

## 代码示例 ##

**要求**

接口类

1.  Flyable类  
    成员函数：takeoff land
2.  Plane类  
    成员函数：构造函数 虚析构函数 takeoff land printCode  
    数据成员：m\_strCode
3.  FightPlane类  
    成员函数：构造函数 takeoff land

4 全局函数flyMatch(Flyable \*f1,Flyable \*f2)

Flyable.h

#pragma once
    
    class Flyable
    {
        
    public:
    	virtual void takeoff() = 0;//纯虚函数
    	virtual void land() = 0;//纯虚函数
    
    };

Plane.h

#pragma once
    #include<iostream>
    #include<string>
    #include"Flyable.h"
    
    using namespace std;
    
    class Plane :public Flyable
    {
        
    public:
    	Plane(string code);
    	virtual void takeoff();
    	virtual void land();
    	void printCode();
    
    private:
    	string m_strCode;
    };

Plane.cpp

#include<iostream>
    #include<string>
    #include"Plane.h"
    
    using namespace std;
    
    Plane::Plane(string code)
    {
        
    	m_strCode = code;
    }
    
    void Plane::takeoff()
    {
        
    	cout << "Plane--takeoff() " << endl;
    }
    
    
    void Plane::land()
    {
        
    	cout << "Plane--land() " << endl;
    }
    
    
    void Plane::printCode()
    {
        
    	cout << "m_strCode= " << m_strCode << endl;
    }

FightPlane.h

#pragma once
    #include<iostream>
    #include<string>
    #include"Plane.h"
    
    using namespace std;
    
    class FightPlane:public Plane
    {
        
    public:
    	FightPlane(string code);
    	virtual void takeoff();
    	virtual void land();
    };

FightPlane.cpp

#include<iostream>
    #include<string>
    #include"FightPlane.h"
    
    using namespace std;
    
    FightPlane::FightPlane(string code) :Plane(code)
    {
        
    
    }
    
    void FightPlane::takeoff()
    {
        
    	cout << "FightPlane--takeoff() " << endl;
    }
    
    void FightPlane::land()
    {
        
    	cout << "FightPlane--land() " << endl;
    }

main.cpp

#include<iostream>
    #include"FightPlane.h"
    
    using namespace std;
    
    /***************
    接口类
    1.Flyable类
    	成员函数：takeoff  land
    	
    2. Plane类
    	成员函数：构造函数 虚析构函数 takeoff  land printCode
    	数据成员：m_strCode
    
    3. FightPlane类
    	成员函数：构造函数  takeoff  land
    	
    4 全局函数flyMatch(Flyable *f1,Flyable *f2)
    
    ***************/
    
    void flyMatch(Flyable *f1, Flyable *f2)
    {
        
    	f1->takeoff();
    	f1->land();
    
    	cout << "-------------------" << endl;
    
    	f2->takeoff();
    	f2->land();
    
    }
    
    int main(void)
    {
        
    	Plane p1("001");
    	Plane p2("002");
    	p1.printCode();
    	p2.printCode();
    	flyMatch(&p1, &p2);
    
    	cout << "-  -  -  -  -  -  -  -  - " << endl;
    
    	FightPlane p3("003");
    	FightPlane p4("004");
    	p3.printCode();
    	p4.printCode();
    	flyMatch(&p3, &p4);
    
    	cin.get();
    	return 0;
    }

**运行结果**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly94aW9uZ3lpbWluZy5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70_pic_center 10]

--------------------

# 参考资料 #

\[1\] [C++远征之多态篇][C]

[20190910205236707.png_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly94aW9uZ3lpbWluZy5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/cf8187a0e5a7483282176a7886c0e035.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly94aW9uZ3lpbWluZy5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/cfbf99fa14d04792a7237b8a47cb6577.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly94aW9uZ3lpbWluZy5ibG9nLmNzZG4ubmV0_size_10_color_FFFFFF_t_70_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/a7991bf205b64d858d763038fcfbaccd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly94aW9uZ3lpbWluZy5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70_pic_center 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/536c884070a043568f19917b1a52bfac.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly94aW9uZ3lpbWluZy5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70_pic_center 2]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/579f709c0392413ba89abbce2f7aaec9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly94aW9uZ3lpbWluZy5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70_pic_center 3]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/aa05c0049e6145d5ab9b2a23c22fa0a5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly94aW9uZ3lpbWluZy5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70_pic_center 4]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/58337e3988c540d7a5989b9685b0c7a0.png
[20190910204308781.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/6f656308be7b49158e86a3e0d7251c23.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly94aW9uZ3lpbWluZy5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70_pic_center 5]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/d5dbd0cffeb94bc3b2b15af87bb0e873.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly94aW9uZ3lpbWluZy5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70_pic_center 6]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/ba656860809d4bd0b51be94ec5eb58ab.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly94aW9uZ3lpbWluZy5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70_pic_center 7]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/6524405ff2e94c35b6a25f76cad853b6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly94aW9uZ3lpbWluZy5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70_pic_center 8]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/7f72fe34e6a34dadb751313f21384faf.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly94aW9uZ3lpbWluZy5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70_pic_center 9]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/77d9780404ff4642803402b308749270.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly94aW9uZ3lpbWluZy5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70_pic_center 10]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/e923e65207ef408b93f628ac4ce4cdbb.png
[C]: https://www.imooc.com/learn/474