关于c++:5分钟掌握C中的三种继承方式

public 形式继承

基类成员对派生类的可见性对 派生类 来说，基类的私有成员和爱护成员可见，基类的私有成员和爱护成员作为派生类的成员时，它们都放弃原有的状态; 基类的公有成员不可见，基类的公有成员依然是公有的，派生类不可拜访基类中的公有成员。

基类成员对派生类对象的可见性对 派生类对象 来说，基类的私有成员是可见的，其余成员是不可见的。

所以，在私有继承时，派生类的对象能够拜访基类中的私有成员，派生类的成员函数能够拜访基类中的私有成员和爱护成员。

简略来说，派生类能拜访基类的 public, protected 成员，继承过去权限不变，派生类对象只能拜访基类 public 成员。

测试代码如下:

class A
{
private:
    int m_data1;
    void print1() { cout << "private print1" << endl;}
protected:
    int m_data2;
    void print2() { cout << "protected print2" << endl;}
public:
    A(int x = 1, int y = 2, int z = 3) : m_data1(x), m_data2(y), m_data3(z) {}
    int m_data3;
    void print3() { cout << "protected print3" << endl;}
};

class B : public A
{
public:
    void test_public() {
        cout << m_data3 << endl;
        print3();}
    void test_protected() {
        cout << m_data2 << endl;
        print2();}
    void test_private() {
        // 上面两行编译不过，B 类内无法访问父类的公有成员
        // cout << m_data1 << endl;  
        // print1();}
};


int main(int argc, char const* argv[])
{
    B b;
    b.test_public();
    b.test_protected();
    b.test_private();
    cout << b.m_data3 << endl;
    // cout << b.m_data2 << endl;  // 编译不过，子类对象无法访问父类 protected 的成员
    // cout << b.m_data1 << endl;  // 编译不过，子类对象无法访问父类 private 的成员
    return 0;
}

private 形式继承

基类成员对其对象的可见性与个别类及其对象的可见性雷同，私有成员可见，其余成员不可见

基类成员对派生类的可见性对 派生类 来说，基类的私有成员和爱护成员是可见的，基类的私有成员和爱护成员都作为派生类的公有成员，并且不能被这个派生类的子类所拜访；基类的公有成员是不可见的，派生类不可拜访基类中的公有成员。

基类成员对派生类对象的可见性对 派生类对象 来说，基类的所有成员都是不可见的。所以，在公有继承时，基类的成员只能由间接派生类拜访, 而无奈再往下继承。

简略来说派生类能够拜访基类的 public, protected 成员，继承过去之后变成本人公有的。派生类的对象啥都不能拜访。

class A
{
private:
    int m_data1;
    void print1() { cout << "private print1" << endl;}
protected:
    int m_data2;
    void print2() { cout << "protected print2" << endl;}
public:
    A(int x = 1, int y = 2, int z = 3) : m_data1(x), m_data2(y), m_data3(z) {}
    int m_data3;
    void print3() { cout << "protected print3" << endl;}
};

class B : private A
{
public:
    void test_public() {
        cout << m_data3 << endl;
        print3();}
    void test_protected() {
        cout << m_data2 << endl;
        print2();}
    void test_private() {
        // 上面两行编译不过，B 类内无法访问父类的公有成员
        // cout << m_data1 << endl;  
        // print1();}
};


int main(int argc, char const* argv[])
{
    B b;
    b.test_public();
    b.test_protected();
    b.test_private();
    // cout << b.m_data3 << endl;  // // 编译不过，子类对象无法访问父类 public 的成员
    // cout << b.m_data2 << endl;  // 编译不过，子类对象无法访问父类 protected 的成员
    // cout << b.m_data1 << endl;  // 编译不过，子类对象无法访问父类 private 的成员
    return 0;
}

protected 形式继承

基类成员对派生类的可见性对 派生类 来说，基类的私有成员和爱护成员是可见的，基类的私有成员和爱护成员都作为派生类的爱护成员，并且不能被这个派生类的子类的对象所拜访，但能够被派生类的子类所拜访；基类的公有成员是不可见的，派生类不可拜访基类中的公有成员。

基类成员对派生类对象的可见性对派生类对象来说，基类的所有成员都是不可见的。

简略来说: 派生类能够拜访基类的 public, protected，继承过去都变成了 protected，派生类对象啥都不能拜访。

总结

对于这三种形式继承的 派生类 来说: 都能拜访基类的 public, protected 成员;

public 的形式继承到派生类，这些成员的权限和在基类里的权限保持一致;
protected 形式继承到派生类，成员的权限都变为 protected;
private 形式继承到派生类，成员的权限都变为 private;

对于三种形式 派生类的对象 来说: 只有 public 的形式继承后，派生来的对象只能拜访基类的 public 成员，protected 和 private 形式继承，派生类的对象都不能够拜访父类的成员。

例: 请思考标记为 A 到 J 的语句在编译时可能呈现的状况。

#include<iostream>
#include<cstdio>

class Parent
{
public:
    Parent(int var=-1) {
        m_nPub = var;
        m_nPtd = var;
        m_bPrt = var;
    }
    int m_nPub;
protected:
    int m_nPtd;
private:
    int m_nPrt;
};

class Child1 : public Parent
{
public:
    int GetPub() { return m_nPub;}
    int GetPtd() { return m_nPtd;}
    int GetPrt() { return m_nPrt;}
    // A
};

class Child2 : protected Parent
{
public:
    int GetPub() { return m_nPub;}
    int GetPtd() { return m_nPtd;}
    int GetPrt() { return m_nPrt;}
    // B
};

class Child3 : private Parent
{
public:
    int GetPub() { return m_nPub;}
    int GetPtd() { return m_nPtd;}
    int GetPrt() { return m_nPrt;}
    // C
};

int main(int argc, char const *argv[])
{
    Child1 cd1;
    Child2 cd2;
    Child3 cd3;

    int nVar = 0;

    // public inherited
    cd1.m_nPub = nVar; // D
    cd1.m_nPtd = nVar; // E
    nVar = cd1.GetPtd(); // F

    // protected inherited
    cd2.m_nPub = nVar; // G
    nVar = cd2.GetPtd(); // H

    // private inherited
    cd3.m_nPub = nVar; // I
    nVar = cd3.GetPtd();  // J
    return 0;
}

A, B, C 都谬误，因为 m_nPrt 是父类的 private 变量，子类不能拜访。

D 正确。cdl 是私有继承，能够拜访并扭转父类的私有变量。

E 谬误。m_nPtd 是父类 Parent 的爱护变量，不能够被私有继承的 cdl 拜访，更不能够被批改。尽管 m_nPtd 是父类 Parent 的爱护变量，通过私有继承后，m_nPtd 在子类中仍然是 protected, 而子类的对象 cdl 是不能拜访本身的 protected 成员，只能拜访 public 成员。

F 正确。派生类内能够拜访父类的爱护变量。

G 谬误。cd2 是爱护继承的，派生类对象不能拜访父类成员。

H 正确。派生类内能够拜访父类的爱护变量。

I 谬误。cd2 是公有继承的，派生类对象不能拜访父类成员。

J 正确。派生类内能够拜访父类的爱护变量。

你搞懂了吗？码字不易，点个赞再走吧！