C++ 继承

1、继承
继承是面向对象三大特性之一。有些类与类直接存在特殊的关系，例如下图中：

我们发现，定义这些类时，下级别的成员除了拥有上一级的共性，还有自己的特性。这个时候我们就可以考虑利用继承的技术，减少重复代码。

1.1 继承的基本语法
例如我们看到很多网站中国，都有公共的头部，公共的底部，甚至公共的左侧列表，只有中心内容不容接下来我们分别利用普通写法和继承的写法来实现网页中的内容，看一下继承存在的意义以及好处。

普通实现：

#include <iostream>
using namespace std;

//普通实现页面

//Java页面
class Java
{
public:
    void header()
    {
        cout << "首页、公开课、登录、注册....（公共头部）" << endl;
    }
    void footer()
    {
        cout << "帮助中心、交流合作、站内地图...(公共头部)" << endl;
    }

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

void test01()
{
    cout << "Java下载视频页面如下" << endl;
    Java ja;
    ja.header();
    ja.footer();
    ja.content();
}



int main()
{
    test01();
    system("pause");
}

总结：
继承的好处：可以减少重复的代码；
class A：public B;
A 类称为子类 或 派生类；
B 类称为父类 或 基类；

派生类中的成员，包含两大部分：
一类时从基类继承过来得，一类时自己增加的成员。
从基类继承过来的表现其共性，而新增的成员体现了其个性。

1.2 继承的方式

继承的语法：

class 子类：继承方式 父类

继承方式一共有三种：
公共继承；
保护继承；
私有继承；

#include <iostream>
#include<assert.h>
using namespace std;

//继承方式

//公共继承
class Base1
{
public:
    int m_A;
protected:
    int m_B;
private:
    int m_C;
};

class Son1 :public Base1
{
public:
    void func()
    {
        m_A = 10;//父类中的公共权限成员 到子类中依然是公共权限
        m_B = 10;//父类中的保护权限成员 到子类中依然是保护权限
        //m_C = 10;//父类中的私有权限成员  子类访问不到
    }
};

void test01()
{
    Son1 s1;
    s1.m_A = 100;
    s1.m_B = 100;
}

//保护继承函数
class Base2
{
public:
    int m_A;
protected:
    int m_B;
private:
    int m_C;
};

class Son2 :protected Base2
{
public:
    void func()
    {
        m_A = 100;//父类中公共成员，到子类中变为保护权限
        m_B = 100;//父类中保护成员，到子类中变为保护权限
    }
};

void test02()
{
    Son2 s1;
    //s1.m_A = 1000; //在Son2中 m_A 变为保护权限，因此类外访问不到
    //s1.m_B = 1000; //在Son2中 m_B 保护权限 不可以访问
}

//私有继承
class Base3
{
public:
    int m_A;
protected:
    int m_B;
private:
    int m_C;

};

class Son3 :private Base3
{
public:
    void func()
    {
        m_A = 100;//父类中公共成员 到子类中变为 私有成员
        m_B = 100;//父类中保护成员 到子类中变为 私有成员
        //m_C = 100;//父类中私有成员 子类访问不到
    }
};

void test03()
{
    Son3 s1;
    //s1.m_A =1000;//父类中公共成员 到子类中变为 私有成员
    //s1.m_B = 1000;//父类中保护成员 到子类中变为 私有成员
}

class GrandSon3 :public Son3
{
public:
    void func()
    {
        //m_A = 1000; //到Son3中 m_A变为私有，及时是儿子，也是访问不到
        //m_B = 1000; //到Son3中 m_B 变为私有，及时是儿子，也是访问不到
    }
};

int main()
{
    std::cout << "Hello World!\n";
}

1.3 继承中的对象模型

问题：从父类继承过来的成员，哪些属于子类对象中？

#include <iostream>
using namespace std;

//继承中的对象模型

class Base
{
public:
    int m_A;
protected:
    int m_B;
private:
    int m_C;
};

class Son :public Base
{
public:
    int m_D;

};

//利用开发人员命令提示工具查看对象模型
//跳转盘符  F：
//跳转文件路径 cd 具体路径下
//查看命名
//cl /dl reportSingleClassLayout类名

void test01()
{
    //父类中所有非静态成员属于都会被子类继承下去
    //父类中私有成员属性 是被编译器给隐藏，因此是访问不到，但是确实在继承中使用
    cout << "size of Son=" <<sizeof(Son) << endl;
}

int main()
{
    test01();
    system("pause");
}

1.4 继承中构造和析构顺序
子类继承父类后，当创建子类对象，也会调用父类的构造函数。

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

#include <iostream>
using namespace std;

//继承中构造与析构顺序
class Base
{
public:
    Base()
    {
        cout << "Base构造函数！" << endl;
    }
    ~Base()
    {
        cout << "Base析构函数！" << endl;
    }
};

class Son :public Base
{
public:
    Son()
    {
        cout << "Son构造函数！" << endl;
    }
    ~Son()
    {
        cout << "Son析构函数！" << endl;
    }
};

void test01()
{
    Base b;

    //继承中的构造和析构顺序如下：
    //先构造父类，再构造子类，析构的顺序与构造的顺序相反
    Son s;
}

int main()
{
    test01();
    system("pause");
}

1.5 继承同名成员处理方式

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

访问子类同名成员 直接访问即可
访问父类同名成员 需要加作用减

#include <iostream>
using namespace std;

//继承中同名成员处理
class Base
{
public:
    Base()
    {
        m_A = 100;
    }

    void func()
    {
        cout << "Base - func()调用" << endl;
    }


    int m_A;
};

class Son :public Base
{
public:
    Son()
    {
        m_A = 100;
    }

    int m_A;
};

//同名成员属性的处理方式
void test01()
{
    Son s;
    cout << "m_A" << s.m_A << endl;
    //如果通过子类对象 访问到父类中同名成员，需要加作用域

    cout << "Base 下m_A =" << s.Base::m_A << endl;
    
}

//同名成员函数处理
void test02()
{
    Son s;
    s.func();//直接调用 调用是子类中的同名成员

    //如何调用到父类中同名成员函数？
    s.Base::func();

    //如果子类中出现和父类同名的成员函数，子类的同名成员会隐藏父类中所有同名成员函数
    //如果想访问到父类中被隐藏的同名成员函数，需要加作用域
    s.Base::func(100);
}

int main()
{
    test01();
    system("pause");
}

总结：
1)、子类对象可以直接访问到子类中同名成员；
2）、子类对象加作用域可以访问到父类同名成员；
3）、当子类与父类拥有同名的成员函数，子类对隐藏父类中同名成员函数，加作用域可以访问到父类中同名函数；

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

问题：继承中同名的静态成员在子类对象上如何进行访问？

静态成员和非静态成员出现同名，处理方式一致。

访问子类同名成员，直接访问即可；
访问父类同名成员，需要加作用域；

#include <iostream>
using namespace std;

//继承同名静态成员处理方式
class Base
{
public:
    static int m_A;

    static void func()
    {
        cout << "Base - static void func()" << endl;
    }
    static void func(int a)
    {
        cout << "Base - static void func(int a)" << endl;
    }

    static int m_A;
};

int Base::m_A = 100;

class Son :public Base
{
public:
    static int m_A;

    static void func()
    {
        cout << "Son - static void func()" << endl;
    }
};

int Son::m_A = 200;

//同名静态成员属性
void test01()
{
    //通过对象访问
    cout << "通过对象访问：" << endl;
    Son s;
    cout << "Son 下m_A" << s.m_A << endl;
    cout << "Base 下m_A" << s.m_A << endl;

    //通过类名访问
    cout << "通过类名访问:" << endl;
    cout << "Son 下 m_A=" << Son::m_A << endl;
    //第一个：：代表通过类名方式访问  第二个::代表访问父类作用域下
    cout << "Base 下 m_A=" << Son::Base::m_A << endl;
}

//同名静态成员函数
void test02()
{
    //通过对象访问
    Son s;
    s.func();
    s.Base::func();

    //通过类名访问
    cout << "通过类名访问" << endl;
    Son::func();
    Son::Base::func();

    //子类出现和父类同名静态成员函数，也会隐藏父类中所有同名成员函数
    //如果想访问父类中被隐藏同名成员，需要加作用域
    Son::Base::func(100);
}

int main()
{
    test01();
    test02();
    system("pause");
}

1.7 多继承语法

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

语法：

class 子类 : 继承方式 父类1,继承方式 父类2...

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

C++ 实际开发中不建议用多继承

#include <iostream>
using namespace std;

//多继承语法
class Base1
{
public:
    Base1()
    {
        m_A = 100;
    }
public:
    int m_A;
};

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

//子类 需要继承Base1和Base2
//语法：class 子类:继承方式 父类1，继承方式 父类2
class Son:public Base1, public Base2
{
public:
    Son()
    {
        m_C = 300;
        m_D = 400;
    }

    int m_C, m_D;
};

void test01()
{
    Son s;
    cout << "sizeof Son = " << sizeof(s) << endl;
    //当父类中出现同名成员，需要加作用域区分
    cout << "Base1::m_A =" << s.Base1::m_A << endl;
    cout << "Base2::m_A=" << s.Base2::m_A << endl;
}

int main()
{
    test01();
}

1.8 菱形继承

菱形继承概念：
两个派生类继承同一个基类；
又有某个类同时继承者两个派生类
这种继承被称为菱形继承，或者钻石继承。

典型的菱形继承案例：

菱形继承问题：
1）、羊继承了动物的数据，驼同样继承了动物的数据，当草泥妈使用数据时，就会产生二义性；
2）、草泥妈继承自动物的数据继承了两份，其实我们应该清楚，这份数据我们只需要一份就可以；

#include <iostream>
using namespace std;

//动物类

class Animal
{
public:
    int m_Age;
};

//利用虚继承 解决菱形继承的问题
//继承之前 加上关键字 virual 变为虚继承
// Animal 类称为 虚基类
//羊类
class Sheep:virtual public Animal{};

//驼类
class Tuo:virtual public Animal{};

//羊驼类
class SheepTuo:public Sheep,public Tuo{};

void test01()
{
    SheepTuo st;
    st.Sheep::m_Age = 18;
    st.Tuo::m_Age = 28;
    //当菱形继承，两个父类拥有相同数据，需要加以作用域区分
    cout << "st.Sheep::m_Age=" << st.Sheep::m_Age << endl;
    cout << "st.Sheep::m_Age=" << st.Tuo::m_Age << endl;

    //
}

int main()
{
    test01();
    system("pause");
}

1.9 多态
1.9.1 多态的基本概念
多态是C++面向对象三打特性之一
多态分为两类
静态多态：函数重载 和 运算父重载属于静态多态，复用函数名。
动态多态：派生类和虚函数实现运行时多态。

静态多态和动态多态区别：
静态多态的函数地址早绑定 - 变异阶段确定函数地址；
动态多态的函数地址晚绑定 - 运行阶段确定函数地址。

下面通过案例进行讲解多态

#include <iostream>
using namespace std;

//多态

//动物类
class Animal
{
public:
    //虚函数
    virtual void speak()
    {
        cout << "动物在说话" << endl;
    }
};

//猫类
class Cat :public Animal
{
public:
    //重写 函数返回只类型 函数名 参数列表 完全相同
    void speak()
    {
        cout << "小猫说话" << endl;
    }
};

//狗类
class Dog :public Animal
{
public:
    void speak()
    {
        cout << "小狗在说话" << endl;
    }
};

//执行说的函数
//地址早绑定 在编译节点确定函数地址
//如果想执行让猫说话，那么这个函数地址就不能提前绑定，需要在运行阶段进行绑定，地址晚绑定
//动态多态马总条件
//
void doSpeak(Animal& animal)
{
    animal.speak();
}

void test01()
{
    Cat cat;
    doSpeak(cat);

    Dog dog;
    doSpeak(dog);
}

int main()
{
    test01();
    system("pause");
}

总结：
多态满足条件
有继承关系
子类重写父类中的虚函数
多态使用条件
父类指针或引用指向子类对象
重写：函数返回值类型 函数名 参数列表 完全一致称为重写。

2.0 多态案例 — 计算器类

案例描述：
分别利用普通写法和多态技术，设计实现两个操作数进行运算的计算器类。

多态的优点：
代码组织结构清晰；
可读性强；
利用前期和后期的扩展以及维护；

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

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

//普通写法
class Calculator
{
public:
    int getResult(string oper)
    {
        if (oper == "+")
        {
            return m_Num1 + m_Num2;
        }
        else if (oper == "-")
        {
            return m_Num1 - m_Num2;
        }
        else if (oper == "*")
        {
            return m_Num1 * m_Num2;
        }
        //如果想扩展新的功能，需求修改源码
        //在真是开发中 提倡 开闭原则
        //开闭原则：对扩展进行开发，对修改进行关闭

    }

    int m_Num1; //操作数1
    int m_Num2; //操作数2
};

void test01()
{
    //创建计算器对象
    Calculator c;
    c.m_Num1 = 10;
    c.m_Num2 = 10;

    cout << c.m_Num1 << "+" << c.m_Num2 << "=" << c.getResult("+") << endl;
    cout << c.m_Num1 << "-" << c.m_Num2 << "=" << c.getResult("-") << endl;
    cout << c.m_Num1 << "*" << c.m_Num2 << "=" << c.getResult("*") << endl;
}
//利用多态实现计算器

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

    int m_Num1;
    int m_Num2;
};

//加法计算器类
class AddCalculator :public AbstractCalculator
{
public:
    int getResult()
    {
        return m_Num1 + m_Num2;
    }
};

//减法计算器类
class SubCalculator :public AbstractCalculator
{
public:
    int getResult()
    {
        return m_Num1 - m_Num2;
    }
};

//乘法计算器类
class MulCalculator :public AbstractCalculator
{
public:
    int getResult()
    {
        return m_Num1 * m_Num2;
    }
};

void test02()
{
    //多态使用条件
    
    //父类指针或者引用指向子类对象
    AbstractCalculator* abc = new AddCalculator;
    abc->m_Num1 = 10;
    abc->m_Num2 = 10;

    cout << abc->m_Num1 << "+" << abc->m_Num2 << "=" << abc->getResult() << endl;
    //用完后记得销毁
    delete abc;

    //减法运算
    abc = new SubCalculator;
    cout << abc->m_Num1 << "-" << abc->m_Num2 << "=" << abc->getResult() << endl;
    delete abc;

    //乘法运算
    abc = new MulCalculator;
    abc->m_Num1 = 100;
    abc->m_Num2 = 100;

    cout << abc->m_Num1 << "*" << abc->m_Num2 << "=" << abc->getResult() << endl;
    delete abc;
}

int main()
{
    test01();
    test02();
    system("pause");
}