【C++】继承

XYN61

已于 2024-08-03 00:19:54 修改

阅读量483

点赞数 8

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

于 2024-08-02 23:58:34 首次发布

本文链接：https://blog.csdn.net/weixin_60546365/article/details/140879892

版权

C++ 专栏收录该内容

25 篇文章 0 订阅

订阅专栏

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

一、继承的基本语法

class 子类（派生类） : 继承方式父类（基类）

派生类包括：①从基类继承过来（共性） ②自己增加的成员（特性）

//公共页面类
class BasePage
{
public:
    void header()
    {
        cout << "首页、登录、注册...." << endl;
    }

    void footer()
    {
        cout << "帮助中心、设置、交流区域...." << endl;
    }

    void left()
    {
        cout << "C、C++、Java、Python、...." << endl;
    }
};

//C++页面
class Cpp:public BasePage
{
public:
    void content()
    {
        cout << "C++学科视频" << endl;
    }

};

//Python页面
class Python:public BasePage
{
public:
    void content()
    {
        cout << "Python学科视频" << endl;
    }

};

//Java页面
class Java:public BasePage
{
public:
    void content()
    {
        cout << "Java学科视频" << endl;
    }

};

void test01()
{
    cout << "[C++]相关页面如下:" << endl;
    Cpp C;
    C.header();
    C.footer();
    C.left();
    C.content();

    cout << "------------------" << endl;
    cout << "[Python]相关页面如下:" << endl;
    Python py;
    py.header();
    py.footer();
    py.left();
    py.content();
    
    cout << "------------------" << endl;
    cout << "[Java]相关页面如下:" << endl;
    Java ja;
    ja.header();
    ja.footer();
    ja.left();
    ja.content();
}

好处：减少重复代码

二、继承方式

//父类
class A
{
public:
    int a;
protected:
    int b;
private:
    int c;
};

①公共继承【public】：类里可以访问，类外也可以访问

//子类
class B: public A
{
//可访问
public:
    int a;
protected:
    int b;
//不可访问
private:
    int c;
};

②保护继承【protected】：类里可以访问，类外不可以访问，父的内容子可以访问

//子类
class B: public A
{
//可访问    
protected:
    int a;
    int b;
//不可访问
private:
    int c;
};

③私有继承【private】：类里可以访问，类外不可以访问，父的内容子不可以访问

//子类
class B: public A
{
//可访问    
private:
    int a;
    int b;
//不可访问
private:
    int c;
};

三、对象模型

【本小结有三个补充知识在文末】

//父类
class Base
{
public:
    int a;
protected:
    int b;
private:
    int c;
};

class son :public Base
{
public:
    int d;
};

void test()
{
    //大小为16 = 4+4+4+4
    //父类中所有非静态成员属性都会被子类继承下去
    //父类中私有属性被编译器隐藏所以访问不到 但是也被继承下去了
    cout << "sizeof son =" << sizeof(son) << endl;
}

四、构造和析构的顺序

子类继承父类后，在创建子类对象时，函数调用顺序：

①父类构造函数

②子类构造函数

③子类析构函数

④父类析构函数

** 先进后出 [类似栈式存储] **

** 创建子类对象会创建父类对象 **

五、同名成员处理

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

解决方式：

* 访问子类同名成员，直接访问【.操作符】

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

class Base
{
public:

    Base()
    {
        m_A = 100;
    };    

    void func()
    {
        cout << "Base下func()" << 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();
}

注意：如果子类中出现和父类同名的成员函数，子类的同名成员会隐藏掉父类所有同名函数（重载的所有版本）如果需要访问父类就要加作用域！！

六、同名静态成员处理

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

解决方式：

* 访问子类同名成员，直接访问【.操作符】

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

class Base
{
public: 

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

    static int m_A;
};
int Base::m_A = 100;


class Son : public Base
{
public:

    static void func()
    {
        cout << "Son下static-func()" << endl;
    };
    
    static int m_A
};
int Son::m_A = 100;

//同名属性处理方法：
void test01()
{
    //方法一：通过对象访问
    Son s;
    cout << "Son m_A = " << s.m_A << endl;
    cout << "Base m_A = " << s.Base::m_A << endl;

    //方法二：通过类名访问
    cout << "通过类名访问" << Son::m_A << endl;
    //通过父类名访问数据
    cout << "通过类名访问" << Base::m_A << endl;
    //通过子类名访问 父类作用域下 的属性
    cout << "通过类名访问" << Son::Base::m_A << endl;
}

//同名成员函数处理方法：
void test02()
{
    //方法一：通过对象访问
    Son s;
    s.func();
    s.Base::func();

    //方法二：通过类名访问
    Son::func();
    Son::Base::func();
}

注意：如果子类中出现和父类同名的成员函数，子类的同名成员会隐藏掉父类所有同名函数（重载的所有版本）如果需要访问父类就要加作用域！！

七、多继承语法

允许一个类继承多个类【实际开发中不建议使用】

语法：class 子类 :: 继承方法父类a ，继承方法父类b.....

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

class Base1
{
public:

    Base1()
    {
        m_A = 100;
    };    

    int m_A;
};

class Base2
{
public:

    Base2()
    {
        m_A = 200;
    };    

    int m_A;
};

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 << "sizeof Son" << sizeof(s) << endl;//16

    //当父类中出现重名参数时，需要加作用域
    cout << "m_A = " << s.Base1::m_A << endl;
    cout << "m_A = " << s.Base2::m_A << endl;
    
}

八、菱形继承问题以及解决方法

概念：两个派生类（子类A、子类B）继承同一个基类（父类1），又有某个类（子类C）同时继承两个派生类（子类A、子类B），该继承称为菱形继承或钻石继承

菱形继承出现问题：

1、子类C使用数据时会出现二义性【加作用域解决该问题】

2、子类C继承子类A、B会出现数据重复

虚继承：virtual

底层逻辑：使用virtual后，继承虚基类时会产生vbptr [virtual base pointer]（虚基类指针）指向vbtable(虚基类表)，表中有偏移量最终指向唯一的数据

//动物类
//虚基类
class Animal 
{
public:
    int m_Age;
};

//利用虚继承解决菱形继承问题

//羊类
class Sheep : virtual public Animal
{

};

//驼类
class Tuo: virtual public Animal
{

};

//羊驼类
class SheepTuo: public Sheep. public Tuo
{

};

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

    //以上两行代码导致数据出现多份，内存资源浪费
    //利用虚继承后，数据只有一份，最后修改为多少就是多少
    cout << "st.m_Age = " << st.m_Age << endl; // 28
    
    
}