c++学习小结（11.1 继承多态）

最新推荐文章于 2023-03-01 20:59:00 发布

殷培文enen

最新推荐文章于 2023-03-01 20:59:00 发布

阅读量120

点赞数

分类专栏： c++ 文章标签： c++ 学习开发语言

本文链接：https://blog.csdn.net/weixin_66455428/article/details/127635348

版权

c++ 专栏收录该内容

17 篇文章 0 订阅

订阅专栏

继承是面向对象三大特性之一

继承的好处：减少重复代码

语法class 子类: 继承方式父类

子类也称为派生类父类也称为基类

派生类中的成员包含两部分：一类是从基类继承过来的，一类是自己增加的成员。

从基类继承过来的表现其共性，而新增的成员体现了其个性

class Basepage
{
public:
	void header()
	{
		cout << "首页，公开课，登录，注册..." << endl;
	}
	void footer()
	{
		cout << "帮助中心，交流合作，站内地图" << endl;
	}

};

class Java:public Basepage
{
	void content()
	{
		cout << "Java学科视频" << endl;
	}

};
class Python :public Basepage
{
	void content()
	{
		cout << "Python学科视频" << endl;
	}
};
class Cpp :public Basepage
{
	void content()
	{
		cout << "Cpp学科视频" << endl;
	}
};

继承的方式一共有三种

公共继承

保护继承

私有继承

在父类中所有的非静态成员属性都会被继承，只不过私有成员属性是被编译器隐藏了，但是确实被继承下去了

继承中构造和析构顺序

子类继承父类后，当创建子类对象，也会调用父类的构造函数

问题：父类和子类的构造和析构顺序是谁先谁后

先构造父类，再构造子类，析构的顺序与构造的顺序相反

继承同名成员处理方式

问题：当子类与父类出现同名的成员，如何通过子类对象，访问到子类或父类中同名的数据呢？

访问子类同名成员直接访问即可

访问父类同名成员需要加作用域

class Base
{
public :
	Base()
	{
		m_a = 100;
	}
	
	int m_a;
};

class Son :public Base
{
public:
	Son()
	{
		m_a = 200;
	}
	int m_a;
};
void test()
{
	Son s;
	cout << s.m_a << endl;//200
	cout << s.Base::m_a << endl;//100
}

如果子类出现了和父类同名的成员，则子类的同名成员会隐藏掉父类中所有同名成员函数

如果想访问父类中被隐藏的同名函数要加作用域

继承中同名静态成员处理方式

静态成员和非静态成员出现同名，处理方式一致，只不过有两种（通过对象和通过类名）

多继承语法

c++允许一个类继承多个类

语法 class 子类：继承方式父类1，继承方式父类2...

多继承可能会引发父类中有同名成员出现，需要加作用域区分

c++实际开发中不建议用多继承,会出现父类中成员属性名称相同，需加作用域

class Base1
{
public:
    Base1()
    {
        m_a = 100;
    }

    int m_a;
};
class Base2
{
public:
    Base2()
    {
        m_b = 200;
    }

    int m_b;
};

class Son :public Base1, public Base2
{

public:
    Son()
    {
        m_c = 300;
        m_d = 400;
    }

    int m_c;
    int m_d;

};
    
void test()
{
    Son s;
    cout << sizeof(s) << endl; ///16
}

菱形继承

两个派生类继承同一个基类

又有某个类同时继承这两个派生类

这种继承被称为菱形继承，或者钻石继承

虚继承：加上关键字 virtual 继承后称为虚基类

多态

多态非为两类

静态多态：函数重载和运算符重载属于静态多态，复用函数名

动态多态：派生类和虚函数实现运行时多态

静态多态和动态多态的区别：

静态多态的函数地址早绑定 - 编译阶段确定函数地址

动态多态的函数地址晚绑定 - 运行阶段确定函数地址

class animal
{
public:
    virtual void speak()//变为虚函数 为了编译器在编译时不能确定函数调用
    {
        cout << "动物" << endl;
    }
};

class Cat:public animal
{
public:
    void speak()
    {
        cout << "猫" << endl;

    }

};

void doSpeak(animal& animal)
{
    animal.speak();
}
void test()
{
    Cat c;
    doSpeak(c); //猫 父类不是虚函数的话输出动物
}

地址早绑定，在编译阶段确定函数地址

如果想执行让猫说话，那么这个函数地址就不能提前绑定，需要在运行阶段进行绑定，地址晚绑定

动态多态满足条件

1.有继承关系

2.子类重写父类的虚函数

重写：函数返回值类型函数名参数列表完全相同

动态多态使用

父类的指针或者引用，执行子类对象

多态的优点：

代码组织结构清晰

可读性强

利于前期和后期的扩展以及维护

案例:计算器类

分别利用普通写法和多态技术，实现计算器类

//普通写法
class Cacllator
{
public:
    int getRuslt(string oper)
    {
        if (oper == "+")
        {
            return num1 + num2;
        }
        else if (oper == "-")
        {
            return num1 - num2;
        }
        else if (oper == "*")
        {
            return num1 * num2;
        }
    }

    int num1;
    int num2;
};
void test()
{
    Cacllator c;
    c.num1 = 10;
    c.num2 = 10;

    cout << c.getRuslt("+") << endl;
    cout << c.getRuslt("-") << endl;
    cout << c.getRuslt("*") << endl;
}

    int main()
{
        test();

    return 0;
}

普通功能想要拓展功能，需要修改源码

在真的开发中，提倡开闭原则：对扩展进行开发，对修改进行关闭

//利用多态实现计算器

//实现计算器抽象类
class AbstractCalculator
{
public:
    virtual int getResult()
    {
        return 0;
    }

    int num1;
    int num2;
};

class AddCalculator:public AbstractCalculator
{
public:
    virtual int getResult()
    {
        return num1 + num2;
    }

};

class SubCalculator :public AbstractCalculator
{
public:
    virtual int getResult()
    {
        return num1 - num2;
    }

};
class MulCalculator :public AbstractCalculator
{
public:
    virtual int getResult()
    {
        return num1 * num2;
    }

};

void test2()
{
    //多态使用条件：父类指针或者引用指向子类对象
    
    AbstractCalculator* abc = new AddCalculator;
    abc->num1 = 10;
    abc->num2 = 10;
    cout << abc->getResult() << endl; //20
    delete abc;

    abc = new SubCalculator;
    cout << abc->getResult() << endl; //0
    delete abc;

}

纯虚函数和抽象类

在多态中，通常父类中虚函数的实现是毫无意义的，主要都是调用子类重写的内容

因此可以将虚函数改为纯虚函数

纯虚函数语法：virtual 返回值类型函数名（参数列表） = 0；

当类中有了纯虚函数，这个类也称为抽象类

抽象类的特点：

无法实例化对象

子类必须重写抽象类中的纯虚函数，否则也属于抽象类

多态案例二：制作饮品

煮水 - 冲泡 - 倒入杯中 - 加入辅料

class AbsteactDrinking
{
public:

    //煮水
    virtual void Boil() = 0;

    //冲泡
    virtual void Brew() = 0;

    //倒入杯中
    virtual void PourIncup() = 0;

    //辅助佐料
    virtual void PutSomething() = 0;

    void makeDrink()
    {
        Boil();
        Brew();
        PourIncup();
        PutSomething();
    }
};

//制作咖啡
class Coffee :public AbsteactDrinking
{
public:
    //煮水
    virtual void Boil()
    {
        cout << "煮农夫山泉" << endl;
    }

    //冲泡
    virtual void Brew()
    {
        cout << "冲泡咖啡" << endl;
    }

    //倒入杯中
    virtual void PourIncup()
    {
        cout << "倒入杯中" << endl;
    }

    //辅助佐料
    virtual void PutSomething() 
    {
        cout << "加糖和牛奶" << endl;
    }
};

//制作茶叶
class Tea :public AbsteactDrinking
{
public:
    //煮水
    virtual void Boil()
    {
        cout << "煮怡宝" << endl;
    }

    //冲泡
    virtual void Brew()
    {
        cout << "冲泡茶叶" << endl;
    }

    //倒入杯中
    virtual void PourIncup()
    {
        cout << "倒入杯中" << endl;
    }

    //辅助佐料
    virtual void PutSomething()
    {
        cout << "加柠檬" << endl;
    }
};

void doWork(AbsteactDrinking * abs)
{
    abs->makeDrink();
    delete abs;
}

void test()
{
    //制作咖啡
    doWork(new Coffee);
    //制作茶叶
    doWork(new Tea);
}

虚析构和纯虚析构

多态使用时，如果子类中有属性开辟到堆区，那么父类指针再释放是无法调用到子类的析构代码

解决方式：将父类中的析构函数改为虚析构和纯虚析构

虚析构和纯虚析构共性：

可以解决父类指针释放子类对象

都需要有具体的函数实现

虚析构和纯虚析构区别：

如果是纯虚析构，该类属于抽象类，无法实例化对象

虚析构语法：

virtual ~类名(){}

纯虚析构语法：

virtual ~类名() = 0;

类外：

类名：：~类名(){}

如果子类中没有堆区数据，可以不写虚析构或纯虚析构

案例三电脑组装

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

//抽象不同零件类
//抽象cpu类
class CPU
{
public:
    //抽象的计算函数
    virtual void calculate() = 0;
};
//显卡
class  VideoCard
{
public:
    //抽象的显示函数
    virtual void display() = 0;
};
//内存条
class  Memory
{
public:
    //抽象的存储函数
    virtual void storage() = 0;
};

//电脑
class Computer
{
public:
    Computer(CPU* cpu, VideoCard* vc, Memory* mem)
    {
        m_cpu = cpu;
        m_vc = vc;
        m_mem = mem;
    }

    //工作函数
    void Work()
    {
        m_cpu->calculate();
        
        m_vc->display();
        
        m_mem->storage();
    }

    //提供析构函数 释放3个电脑零件
    ~Computer()
    {
        if (m_cpu != NULL) {
            delete m_cpu;
            m_cpu = NULL;
        }
        if (m_vc != NULL) {
            delete m_vc;
            m_vc = NULL;
        }
        if (m_mem != NULL) {
            delete m_mem;
            m_mem = NULL;
        }
    }
private:
    CPU* m_cpu;
    VideoCard* m_vc;
    Memory* m_mem;
};

//具体厂商
//Inter
class IntelCPU:public CPU
{
public:
    virtual void calculate()
    {
        cout << "Inter的CPU开始计算了" << endl;
    }
};

class IntelVideoCard:public VideoCard
{
public:
    virtual void display()
    {
        cout << "Inter的VideoCard开始计算了" << endl;
    }
};

class IntelMemory:public Memory
{
public:
    virtual void storage()
    {
        cout << "Inter的Memory开始计算了" << endl;
    }
};

//Lenovo
class LenovoCPU :public CPU
{
public:
    virtual void calculate()
    {
        cout << "Lenovo的CPU开始计算了" << endl;
    }
};

class LenovoVideoCard :public VideoCard
{
public:
    virtual void display()
    {
        cout << "Lenovo的VideoCard开始计算了" << endl;
    }
};

class LenovoMemory :public Memory
{
public:
    virtual void storage()
    {
        cout << "Lenovo的Memory开始计算了" << endl;
    }
};

void test()
{
    cout << "第二台电脑开始工作：" << endl;
    //第一台电脑
    CPU* intelcpu = new IntelCPU;
    VideoCard* intelcard = new IntelVideoCard;
    Memory* intelMem = new IntelMemory;

    //创建一台电脑
    Computer* computer1 = new Computer(intelcpu, intelcard,intelMem);
    computer1->Work();
    delete computer1;

    cout << "------------------" << endl;
    cout << "第二台电脑开始工作：" << endl;
    //创建第二台电脑
    Computer* computer2 = new Computer(new LenovoCPU, new LenovoVideoCard,new LenovoMemory);
    computer2->Work();
    delete computer2;

}

测试结果：