C++基础知识(六:继承)

本文详细解释了C++中的继承概念,包括继承的格式、权限、构造函数(透传构造、继承构造、委托构造)、析构的时机,以及解决父子类同名成员和菱形继承问题的虚继承。
摘要由CSDN通过智能技术生成

目录

首先我们应该知道C++的三大特性就是封装、继承和多态。

【1】继承的格式

【2】继承的权限

【3】继承时类中的特殊成员函数

i)透传构造

ii)继承构造

iii)委托构造

iv)拷贝构造

【4】继承时构造和析构的时机

​编辑

【5】父子类中存在同名成员问题

【1】格式

【2】当多个父类中包含同名成员

【1】格式

【2】菱形继承存在的问题

【3】虚继承(virtual)


首先我们应该知道C++的三大特性就是封装、继承和多态。

此篇文章将详细的讲解继承的作用和使用方法。

  • 继承

一个类,继承另一个已有的类,创建的过程

父类(基类)派生出子类(派生类)的过程

继承提高了代码的复用性

【1】继承的格式

class 类名:父类名
{};

【2】继承的权限

class 类名:继承的权限 父类名
{};

如果不写继承方式,默认是私有继承
父类中的权限      public|private|protected  public|private|protected   public|private|protected              
继承方式                 public                    private                   protected
子类中的权限      public|不能访问|protected  private|不能访问|private    protected|不能访问|protected

【3】继承时类中的特殊成员函数

特殊的成员函数不会被继承

构造函数:

  • 需要在子类中显性调用父类的构造函数(初始化列表中)(透传构造)
  • 透传构造
  • 继承构造
  • 委托构造

需要在子类中显性调用父类构造函数的场合:

父类中只有有参构造  ----->子类在创建类对象时,必须手动调用父类的构造函数

#include <iostream>

using namespace std;

class Father
{
public:
    int age;
    char c;
    Father(int a,char c):age(a),c(c){cout << "Father有参" << endl;}
};

class Child:public Father    //----->私有继承
{
    int high;
public:
    void show()
    {
        cout << c << endl;
    }
};

int main()
{
    //Child c1;  //error,因为父类只有有参构造,而子类中没有提供能够调用父类有参构造的构造函数,不能成功创建父类的空间
    //Father f1;
    c1.age;
    cout << sizeof (Father) << endl;
    cout << sizeof (Child) << endl;
    return 0;
}

i)透传构造

在子类构造函数的初始化列表中,显性调用父类的构造函数

ii)继承构造

C++支持

不用在子类中再写一遍父类的构造函数

使用:using Father::Father; ----->在子类中使用父类的构造函数

直接使用继承构造的方式,不能对子类成员初始化

继承构造本质上并不是把父类中的构造函数继承给子类,编译器自动根据父类中构造函数的格式,提供出派生的构造函数(个数和参数都和父类中的构造函数一致),主要还是通过透传构造创建父类的空间

#include <iostream>
using namespace std;

class Father
{
public:
    int age;
    char c;
//    Father(){cout << "Father无参" << endl;}
    Father(int a,char c):age(a),c(c){cout << "Father有参两个参数" << endl;}
    Father(char c):c(c){cout << "Father有参一个参数的" << endl;}
    Father(Father &other):age(other.age),c(other.c)
    {cout << "Father拷贝" << endl;}
};

class Child:public Father    //----->私有继承
{
private:
    int high;
    //父类中的public成员age,通过公有继承,仍然是public
    using Father::age;   //把父类中公有继承下来的age成员,在子类中改成私有权限
public:
    void show()
    {
        cout << c << endl;
    }
    //子类的无参构造,但是显性调用父类的有参构造还给了默认值
    //透传构造
//    Child():Father(12,'a'){cout << "Child无参构造" << endl;}
//    Child(int a,char c,int h):Father(a,c),high(h)
//    {cout << "Child有参构造" << endl;}

    //父类中的所有构造函数,都被继承到了子类中
    using Father::Father;   //更高效一些
};

int main()
{
    Child c1(10);
    Child c2(20,'z');
    Child c3 = c2;
    //Father f1;
    //c1.age;
    cout << sizeof (Father) << endl;
    cout << sizeof (Child) << endl;
    return 0;
}

iii)委托构造

一个类的情况,并不直接通过无参构造实例化对象,而是无参构造委托了有参构造,实例化对象

继承时的情况

    Child():Child(10){cout << "Child无参构造" << endl;}   //Child c1
    Child(int a):Father(12,'a'),high(a)
    {cout << "Child有参构造一个参数" << endl;}

iv)拷贝构造

需要在初始化列表中显性调用父类的拷贝构造,传other对象到父类的拷贝构造中

Father(Father &other):age(other.age),c(other.c){cout << "Father的拷贝构造" << endl;}
Child(Child &other):Father(other),high(other.high){}

【4】继承时构造和析构的时机

继承关系,可以理解为包含关系

子类在继承父类时,会把父类中的成员保留一份,再来创建子类自己的成员

父类先构造,子类后构造

子类先析构,父类后析构

#include <iostream>

using namespace std;
class F
{
    int *p;
public:
    F():p(new int){cout << "F无参构造" << endl;}
    ~F()
    {
        delete p;
        cout << "F析构函数" << endl;
    }
};
class C:public F
{
    int *p;
public:
    C():p(new int){cout << "C无参构造" << endl;}
    ~C()
    {
        delete p;
        cout << "C析构函数" << endl;
    }
};

int main()
{
    C *p1 = new C;
    delete p1;   //空间释放时,会自动调用析构函数,无需手动调用
    p1 = nullptr;
    return 0;
}

【5】父子类中存在同名成员问题

访问时不会发生冲突,默认访问子类的

#include <iostream>
using namespace std;
class F
{
public:
    int *p;
    F():p(new int){cout << "F无参构造" << endl;}
    ~F()
    {
        delete p;
        cout << "F析构函数" << endl;
    }
};
class C:public F
{
public:
    int *p;
    C():p(new int){cout << "C无参构造" << endl;}
    ~C()
    {
        delete p;
        cout << "C析构函数" << endl;
    }
};

int main()
{
    C *p1 = new C;
    *(p1->p) = 90;
    cout << *(p1->p) << endl;   //子类成员和父类成员同名,默认优先访问子类成员
    cout << *(p1->F::p) << endl;  //通过域限定符访问父类的成员
    delete p1;   //空间释放时,会自动调用析构函数,无需手动调用
    p1 = nullptr;
    return 0;
}
  • 多重继承

一个子类,继承自多个基类

【1】格式

class 类名:继承权限 父类名,继承权限 父类名····
{}

【2】当多个父类中包含同名成员

多个父类中包含同名成员,通过域限定符访问指定的父类中成员

#include <iostream>

using namespace std;

class Room
{
public:
    void clean()
    {
        cout << "打扫房间" << endl;
    }
};
class BedRoom
{
public:
    void play()
    {
        cout << "可以玩游戏" << endl;
    }
    void clean()
    {
        cout << "打扫卧室" << endl;
    }
};

//Home类公共继承字Room和BedRoom类
class Home:public Room,public BedRoom
{
};

int main()
{
    Home h1;
    h1.play();
    h1.Room::clean();
    h1.BedRoom::clean();
    return 0;
}
  • 菱形继承(钻石继承)

【1】格式

     A                ----->公共基类
   /   \
  B     C             ------>中间子类
   \   /
     D                ------>汇集子类

汇集子类中,会包含两份公共基类中的内容

【2】菱形继承存在的问题

  1. 会发生二义性的问题(同一个变量或者函数,可以通过两种方法访问)
  2. 如果公共基类,过大,会造成汇集子类中的代码膨胀/冗余
#include <iostream>

using namespace std;
class A
{
public:
    int a;
    //A(int a):a(a){cout << "A" << endl;}
};

class B:public A
{
public:
    int c;
    //B(int a,int c):A(a),c(c){cout << "B" << endl;}
};

class C:public A
{
public:
    //C(int a):A(a){cout << "C" << endl;}
};

class D:public C,public B
{
public:
    //D(int a,int c):B(a,c),C(a),A(a){cout << "D" << endl;}
};

int main()
{
    D d1;
    d1.B::= 90;   //二义性,还可以直接通过中间子类访问,直接访问B中的a成员
    //cout << d1.C::A::a << endl;  //会发生二义性,因为访问A,但是有两条路径都访问到A
    return 0;
}

【3】虚继承(virtual)

虚继承指对公共基类的虚继承。

主要用于解决菱形继承问题,

采用虚继承后,公共基类中的内容,只会在汇集子类中存在一份,在汇集子类中,可以通过任意一条路径访问到公共基类中的成员

#include <iostream>

using namespace std;
class A
{
public:
    int a;
};

class B:virtual public A
{
public:
    int c;
};

class C:virtual public A
{

};

class D:public B,public C
{

};

int main()
{
    D d1;
    d1.B::A::= 90;
    cout << d1.C::A::<< endl;
    return 0;
}

  • 4
    点赞
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

笨笨小乌龟11

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值