C++中的继承

最新推荐文章于 2024-10-27 19:12:53 发布

shwanglp

最新推荐文章于 2024-10-27 19:12:53 发布

阅读量380

点赞数

分类专栏： C++

C++ 专栏收录该内容

2 篇文章

订阅专栏

本文详细解析了 C++ 中的继承机制，包括不同类型的继承（公有、受保护、私有），成员访问控制符的影响，以及如何通过虚函数实现多态。同时还介绍了虚析构函数的重要性及纯虚函数的应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

先上一段代码：

#include<iostream>

using namespace std;

class Base{

public:

    int a;

protected:

    int b;

private:

    int c;

};

struct Derived:public Base{

};

int main(){

    Derived
 inst;

    cout<<sizeof(Base)<<endl;

    cout<<sizeof(Derived)<<endl;

    cout<<sizeof(inst)<<endl;

    cout<<inst.a<<endl;

    return 0;

}

输出：

12
12
12
15487104

对应上面的代码，先啰嗦几个与“继承”无关的语法：struct可以继承自一个class；sizeof()可以施加在一个类型上面，也可以施加在一个对象上面；由于inst是局部变量，所以类中的普通类型数据成员是不被初始化的，所以输出a=15487104。

我们看到sizeof(Base)==sizeof(Derived)==12，可见Derived继承了Base的public、protected、private成员。

struct Derived:public Base{

public:

    void func(){

        cout<<b<<endl;

    }

};

int main(){

    Derived
 inst;

    inst.func();

    return 0;

}

一般在类外是不能访问protected成员的，所以在main()函数中调用cout<<inst.b;中会发生编译错误的，但是我们可以把对protected成员的访问封闭在一个public方法中，通过调用public方法来间接访问protected数据成员。

struct Derived:public Base{

public:

    void func(){

        cout<<c<<endl;

    }

};

上面代码会有编译错误，protected成员好歹在派生类中还可以访问，private成员在派生类中都不能访问。既然成员c在Derived中不能访问，那sizeof(Derived)又何苦要等于12呢？以Derived分配了3个int的空间，但其中一个int却是不可访问的，有什么意义呢？

（1）公有继承：基类成员保持自己的访问级别：基类的public成员在派生类中还是public，基类的protected成员在派生类中还是protected。

（2）受保护继承：基类的public和protected成员在派生类中成为protected成员。

（3）私有继承：基类的所有成员在派生类中成为private成员。

struct Derived:private Base{

};

class Grandson:public Derived{

public:

    void func(){

        cout<<a<<endl;

    }

};

上面的代码有编译错误，由于Derived私有继承自Base，所以a在Derived中已经是private了，在Grandson中不能访问Derived中的私有成员。

struct Derived:private Base{

public:

    using Base::b;

protected:

    using Base::a;

};

由于Derived私有继承自Base，按说a、b、c在Derived中应该都是私有的，但通过上述方式，在Derived中b中公有的，a中受保护的。

struct Derived:Base

Derived为struct时默认为公有继承。

class Derived:Base

Derived为class时默认为私有继承。

友元类可以访问private和protected成员数据，友元关系不能继承。

#include<iostream>

using namespace std;

class Base{

    friend class Frnd;

private:

    int a;

};

class Derived:public Base{

};

class Frnd{

public:

    void func(){

        Base
 base;

        cout<<base.a<<endl;　　　　//OK

        Derived
 derived;

        cout<<derived.a<<endl;　　　　//error

    }

};

虚函数

当父类中的某个函数标记为virtual时，子类中如果重载了该方法则自动也具有virtual属性，不管你是否使用了"virtual“关键字。比如下面的代码：

#include<iostream>

using namespace std;

class A{

public:

    virtual void func(){

        cout<<"A.func"<<endl;

    }

};

class B:public A{

public:

    void func(){           
//虽然没有显式写明virtual，但该函数依然是虚函数

        cout<<"B.func"<<endl;

    }

};

class C:public B{

public:

    virtual void func(){

        cout<<"C.func"<<endl;

    }

};

int main(){

    A
 *a=new A();

    A
 *b=new B();

    A
 *c=new C();

    a->func();

    b->func();

    c->func();

    return 0;

}

输出：

A.func
B.func
C.func

内部类可以访问外部类的所有成员。

class Base{

public:

    int a;

    class Inner{

    public:

        void func(){

            Base
 base;

            cout<<base.c<<endl;

        }

    };

protected:

    int b;

private:

    int c;

};

int main(){

    Base::Inner
 inst;

    inst.func();

    return 0;

}

注意在main函数中访问Inner类时要加Base::前缀，另外Inner只有定义在Base的public域下时，在Base之外才可以访问Inner。

#include<iostream>

using namespace std;

class Base{

public:

    Base(){

        cout<<"Base
 construct"<<endl;

    }

    virtual void foo(){

        cout<<"Base
 foo"<<endl;

    }

    ~Base(){

        cout<<"Base
 destruct"<<endl;

    }

};

class Derived:public Base{

public:

    Derived(){

        cout<<"Derived
 construct"<<endl;

    }

    virtual void foo(){

        cout<<"Derived
 foo"<<endl;

    }

    ~Derived(){

        cout<<"Derived
 destruct"<<endl;

    }

};

int main(){

    Base
 *inst=new Derived();      
//调用Derived的构造函数，在此之前会调用Base的构造函数

    inst->foo();
//调用Derived的foo方法

    delete inst;
//只调用了Base的析构函数

}

通常情况下Derived拥有比Base更多的数据成员，在Derived的析构函数中需要释放更多的资源，但是我们看到上面的代码中Base和Derived的构造函数都调用了，最后却只调用了Base的析构函数。解决方法：Base中使用虚的析构函数。

#include<iostream>

using namespace std;

class Base{

public:

    Base(){

        cout<<"Base
 construct"<<endl;

    }

    virtual void foo(){

        cout<<"Base
 foo"<<endl;

    }

    virtual ~Base(){

        cout<<"Base
 destruct"<<endl;

    }

};

class Derived:public Base{

public:

    Derived(){

        cout<<"Derived
 construct"<<endl;

    }

    virtual void foo(){

        cout<<"Derived
 foo"<<endl;

    }

    ~Derived(){

        cout<<"Derived
 destruct"<<endl;

    }

};

int main(){

    Base
 *inst=new Derived();　　//调用Derived的构造函数，在此之前会调用Base的构造函数

    inst->foo();
 　　//调用Derived的foo方法

    delete
 inst; 　　//调用Derived的析构函数，在此之后会调用Base的析构函数

}

最佳实践：即便析构函数不做任何工作，继承层次的根类也应该定义一个虚析构函数。

class Base{

public:

    double price(std::size_t)
const =0;

};

在函数形参表后面写上=0表示该函数为纯虚函数，含有一个或多个纯虚函数的类为抽象类，不能创建抽象类的实例。抽象类为后代提供了可以覆盖的接口。

void func(Base
 &base);

Derived
 inst;

func(inst);

当把基类对象传递给func()函数时，引用base直接绑定到inst对象，没有发生对象的复制，没有发生类型的转换，inst也没有发生任何改变不。

void func(Base
 base);

Derived
 inst;

func(inst);

此时情况完全不同，形参的类型是固定的，在编译和运行时都是基类类型对象，如果把派生类对象传递过去，则派生类对象中的基类部分会发生复制。

<pre name="code" class="cpp">