C++类的继承关系

最新推荐文章于 2024-05-29 21:55:00 发布

一声梧桐

最新推荐文章于 2024-05-29 21:55:00 发布

阅读量1k

点赞数

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

本文链接：https://blog.csdn.net/m0_58495729/article/details/127467447

版权

C++ 专栏收录该内容

23 篇文章 0 订阅

订阅专栏

继承的好处

父类所有书信与方法的访问权限都被子类继承了,提高了代码的复用性。

子类可以添加独有的新特性,提高了代码的拓展性。

语法

class + 子类类名  :  继承权限  父类类名
{
    //子类的类体
}

继承权限

内存空间关系

同名属性隐藏

1.子类中有与父类同名属性或函数名是,父类中的属性与函数将自动隐藏在父类的类域之中

2.调用父类属性/方法：子类名 . 父类名 : : 属性/方法

注: 如果父类中没有默认构造时,需要在子类的初始化列表中指定对父类进行初始化.

析构时机

1.当派生类对象被构建时,编译器会自动调用父类的默认构造,然后再调用子类相应的实参构造

2.当派生类对象被析构时,编译器会先调用子类的析构,当子类被析构后,父类的析构也将会自动调用

简单继承演示：

定义一个父类：

#include <iostream>
using namespace std;

class Car
{
private:
    int weight;
public:
    Car (int w)
    {
        this->weight = w;
        cout << "Car的构造" << endl;
        cout << "Car的地址" << this << endl;
    }
    ~Car()
    {
        cout << "Car的析构" << endl;
    }
    void run()
    {
        cout << "车子正在行驶中" << endl;
    }
};

定义两个子类：用public继承

class BMW : public Car
{
public:
    BMW():Car(100)  //可在子类给父类初始化
    {
        cout << "BMW的构造" << endl;
    }
    ~BMW()
    {
        cout << "BMW的析构" << endl;
    }

    //子类独有方法
    void happy_cry()
    {
        //错误,public继承不能访问父类私有成员,
        //若想访问,需在父类定义外部接口
        //cout << this->weight << endl;

        cout << "幸福的泪水" << endl;
    }
    
    //与父类同名方法
    void run()
    {
        cout << "高速行驶" << endl;
    }
};


class BNZ : public Car
{
public:

    BNZ():Car(100)
    {
        cout << "BNZ的构造" << endl;
    }
    ~BNZ()
    {
        cout << "BNZ的析构" << endl;
    }
};

主函数：

int main()
{
    BMW bmw;
    bmw.happy_cry();    //子类方法
    bmw.run();          //父类同名属性隐藏,结果是子类方法
    bmw.Car::run();     //可使用::域名访问调用父类方法
    cout << "bmw的地址" << &bmw << endl;
    cout << "--------------" << endl;

    BNZ bnz;
    cout << "bnz的地址" << &bnz << endl;
    cout << "---------------" << endl;
}

运行结果：

BNZ类与BMW类地址相差一个4个字节，证明子类继承了父类的属性，并占用相应的空间。

父子指针类型转换

1.使用父类指针或引用，可以指向或引用子类的对象，是安全的，无需进行转型

2.子类指针强转成父类指针是安全的

2.当使用父类指针指向子类对象时，如果使用父类指针强转为子类类型时，要保证子类对象内存确定被开辟了才行，否则是不安全的。

代码演示：

父类和子类代码：

#include <iostream>
using namespace std;
class A
{
private:
    int a;
public:
    A():a(10)
    {
        cout << "A的构造" << endl;
    }
    ~A()
    {
        cout << "A的析构" << endl;
    }
    int getA()
    {
        return this->a;
    }
};
class B : public A
{
private:
    int b;
public:
    B():b(200)
    {
        cout << "B的构造" << endl;
    }
    ~B()
    {
        cout << "B的析构" << endl;
    }
    int getB()
    {
        return this->b;
    }
};

主函数：

int main()
{
    //父类转子类,要确保子类空间已开辟
    A* a = new B;
    cout << a->getA() << endl;
    cout << ((B*)a)->getB() << endl;
    cout << static_cast<B*>(a)->getB() << endl;
    delete a;
    cout << "-------------" << endl;

    //子类转父类
    B* b = new B;
    cout << ((A*)b)->getA() << endl;
    cout << static_cast<A*>(b)->getA() << endl;
    delete b;
    return 0;
}

运行结果：

多继承

语法

class 子类 : 继承权限1  父类1, 继承权限2  父类2,继承权限3  父类3, ....
{
    //多重继承类类体
};

优势：提高的代码的复用性。

缺点: 代码冗余，重名问题。

重名问题:通过作用域：：的形式来访问具体某个父类中的属性或方法。

代码冗余：多继承时，继承多个抽象类（一般不写属性，只写抽象方法（纯虚函数）。）

多继承代码演示：

#include <iostream>
using namespace std;
class Phone
{
public:
    int power;
public:
    void mail()
    {
        cout << "通信功能" << endl;
    }
    void playGame()     //两个父类有同名方法
    {
        cout << "手机游戏功能" << endl;
    }
};
class Computer
{
public:
    int power;
public:
    void playGame()     //两个父类有同名方法
    {
        cout << "电脑游戏功能" << endl;
    }
};
class NotePad : public Phone, public Computer
{
public:
    void getPower()
    {
        cout << this->Computer::power << endl;
    }
    void play()
    {
        //this->playGame();     //此写法错误，编译器识别到两个同名方法。
        this->Computer::playGame(); //可通过域名访问
    }
};
int main()
{
    NotePad note;
    note.play();
    note.mail();    //不重名方法可直接调用
    note.Phone::playGame(); //同名方法可用域名调用
    
    cout << sizeof(note) << endl;   //8,    两个父类的int属性大小
    return 0;
}

运行结果：

菱形继承

知识拓展：

虚继承：

1.当在类中使用virtual声明一个成员函数为虚函数时，在编译时，编译器会自动在基类中默默地安插一个虚函数表指针，同时的.rodata段为这类生成一张虚函数表，用来保存类中的虚函数的地址。

2.当继承关系发生时，父类中的虚基表指针就被子类给继承了下来，所以他的类对象空间就增大了一个指针的大小。（并非是虚基表被继承）

菱形继承关系图：

菱形继承代码演示：（非vritual版）

远端父类：

#include <iostream>
using namespace std;

class A
{
public:
    int ma[9];  //这里用9个int，方便等会介绍内存图
    A()
    {
        cout << "A的构造" << endl;
    }
    ~A()
    {
        cout << "A的析构" << endl;
    }
};

中间父类:

class B : public A
{
public:
    int mb = 200;
    B()
    {
        cout << "B的构造" << endl;
    }
    ~B()
    {
        cout << "B的析构" << endl;
    }
};

class C : public A
{
public:
    int mc = 300;
    C()
    {
        cout << "C的构造" << endl;
    }
    ~C()
    {
        cout << "C的析构" << endl;
    }
};

子类及主函数：

class D :  public B, public C
{
public:
    int md  = 400;
    D()
    {
        cout << "D的构造" << endl;
    }
    ~D()
    {
        cout << "D的析构" << endl;
    }
};


int main()
{
    D d;
    cout << "sizeof(A)" << sizeof(A) << endl;
    cout << "sizeof(B)" << sizeof(B) << endl;
    cout << "sizeof(C)" << sizeof(C) << endl;
    cout << "sizeof(D)" << sizeof(D) << endl;
    cout << "---------------" << endl;
    cout << "sizeof(d)" << sizeof(d) << endl;
    return 0;
}

运行结果：

内存图：

可见，A类属性被拷贝了两次，若远端父类占用内存很大，则会浪费很多空间。

因此，在继承时，加上vritual关键字，则编译器会进行优化，A类属性只被引用一次，大大节省了空间，但会产生一个虚基表指针，64位机中占8字节，是可以接受的。

对菱形继承升级：（vritual版）

仅改变中间父类的继承方式即可：

class B :virtual public A
{
public:
    int mb = 200;
    B()
    {
        cout << "B的构造" << endl;
    }
    ~B()
    {
        cout << "B的析构" << endl;
    }
};

class C :virtual public A
{
public:
    int mc = 300;
    C()
    {
        cout << "C的构造" << endl;
    }
    ~C()
    {
        cout << "C的析构" << endl;
    }
};

运行结果：