C++学习练习之继承

最新推荐文章于 2024-04-07 20:41:53 发布

一个天才

最新推荐文章于 2024-04-07 20:41:53 发布

阅读量358

点赞数 1

分类专栏： C/C++ 文章标签： c++ 类继承

本文链接：https://blog.csdn.net/SunInThePalm/article/details/113041287

版权

C/C++ 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

C++学习练习
之继承

有时候我们写的类有一些相同的成员属性，那么为了方便就可以用继承的方式来简洁我们的代码。

标题

一、继承的基本语法
二、继承方式
三、继承中的对象模型
四、继承中的构造和析构顺序
五、继承中的同名成员处理
六、继承中的同名静态成员处理方式
七、多继承语法
八、菱形继承

一、继承的基本语法

语法： class 子类：继承方式父类
子类也称为派生类
父类也称为基类
例如：

class BasePage{
    public:
        void header(){
            cout << "首页、公开课、登录、注册...（公共头部）" << endl;
        }
        void footer(){
            cout << "帮助中心、交流合作、站内地图...（公共底部）" << endl;
        }
        void left(){
            cout << "Java、Python、C++ ...（公共分类列表）" << endl;
        }
};
class CPP : public BasePage{
    public:
        void content(){
            cout << "C++学科视频" << endl;
        }
};

这便是通过继承的方式让CPP类继承BasePage类的属性。

二、继承方式

继承方式有public、protected、private三种方式。

其中父类的private中的成员属性是父类的私有成员，子类和外部无法访问。

如果子类以public方式继承父类，那父类的public、protected的成员到子类中权限不变，而private成员，子类访问不到。

如果子类以protected方式继承父类，那父类中的public成员到子类中变为protected权限，protected不变，private成员，子类访问不到。

如果子类以private方式继承父类，那父类中的public、protected成员到子类中都变为private权限，而父类中的private成员，子类访问不到。

代码如下：

#include <iostream>
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;   //到Son1中，m_B是保护权限，类外访问不到
}

//保护继承
class Son2 : protected Base1{
    public:
        void func(){
            m_A = 100;    //父类中公共成员，到子类中变为保护权限
            m_B = 100;    //父类中保护成员，到子类中变为保护权限
            //m_C = 100;  //父类中私有成员 子类访问不到
        }
};

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

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

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

void test03(){
    Son3 s3;
    // s3.m_A = 1000;  //到Son3中变为私有成员，类外访问不到
    // s3.m_B = 1000;  //到Son3中变为私有成员，类外访问不到
}

int main(){
    system("pause");
    return 0;
}

三、继承中的对象模型

简而言之就是

父类中所有非静态成员属性都会被子类继承下去

父类中私有成员属性是被编译器给隐藏了，因此是访问不到，但是确实被继承下去

四、继承中的构造和析构顺序

继续简而言之就是：

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

代码如下：

#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");
    return 0;
}

五、继承中的同名成员处理

如果子类中的成员名称和父类中的相同，那么怎么进行处理呢？

答：在成员名称前加上作用域即可

//如果通过子类对象，访问到父类中同名成员，需要加作用域
    cout << "Base 中的 m_A = " << s.Base::m_A << endl;

成员函数同上

#include <iostream>
using namespace std;

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

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

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

        int m_A;
};

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

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

        int m_A;
};

//同名成员属性的处理方式
void test01(){
    Son s;
    cout << "Son 中的 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();
    test02();
    system("pause");
    return 0;
}

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

简而言之同上 加作用域

#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;
        }
};

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.Base::m_A << endl;
    cout << "=========通过类名访问=========" << endl;
    cout << "Son中m_A = " << Son::m_A << endl;
    //第一个::代表通过类名访问 ， 第二个::代表访问父类作用域下
    cout << "Base中m_A = " << Son::Base::m_A << endl;
}

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

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


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

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

七、多继承语法

所谓多继承就是一个子类继承多个父类
语法： class 子类 : 继承方式父类1 , 继承方式父类2 …

#include <iostream>
using namespace std;

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

class Base2{
    public:
        Base2(){
            m_A = 200;
        }
        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;
        int m_D;
};

void test01(){
    Son s;
    cout << "Size of 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();
    system("pause");
    return 0;
}

八、菱形继承

简而言之菱形继承就是两个子类继承同一个父类，然后另一个类继承这两个子类
但是菱形继承会出现二义性的问题，就是孙子辈的类如何继承那两个子类的共同成员。
如：

//动物类
class Animal{
    public:
        int m_Age;
};
//羊类
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.Tuo::m_Age =" << st.Tuo::m_Age << endl;
}

所以，st.m_Age 该如何继承。

那么，可以利用虚继承解决菱形继承问题

虚继承就是在继承前面加上virtual关键字

Animal类称为虚基类

使Sheep 和 Tuo 两个类所继承的m_Age变为虚基类指针（vbptr）

然虚基类指针会指向一个虚基类表（vbtable）

#include <iostream>
using namespace std;

//菱形继承
//动物类
class Animal{
    public:
        int m_Age;
};

//利用虚继承可以解决菱形继承问题 , 在继承前面加上virtual关键字
//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.Tuo::m_Age =" << st.Tuo::m_Age << endl;
    cout << "st.m_Age =" << st.m_Age << endl;

    //这份数据我们知道，只要有一份就可以，菱形继承导致数据有两份，资源浪费
}

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