C++继承方式

类成员的访问权限由高到低依次为：public --> protected --> private，public成员在类外可以访问，private成员只能在类的成员函数中访问。

如果不考虑继承关系，protected成员和private成员一样，类外不能访问。但是，当存在继承关系时，protected和private就不一样了。基类中的protected成员可以在派生类中访问，而基类中的 private成员不能在派生类中访问。

继承方式有三种：public（公有的）、protected（受保护的）和private（私有的）。它是可选的，如果不写，那么默认为private。不同的继承方式决定了在派生类中成员函数中访问基类成员的权限。

     

1）基类成员在派生类中的访问权限不得高于继承方式中指定的权限。例如，当继承方式为protected时，那么基类成员在派生类中的访问权限最高也为protected，高于protected的会降级为protected，但低于protected不会升级。再如，当继承方式为public时，那么基类成员在派生类中的访问权限将保持不变。

也就是说，继承方式中的public、protected、private是用来指明基类成员在派生类中的最高访问权限的。

2) 不管继承方式如何，基类中的private成员在派生类中始终不能使用（不能在派生类的成员函数中访问或调用）。

3) 如果希望基类的成员能够被派生类继承并且毫无障碍地使用，那么这些成员只能声明为public 或protected；只有那些不希望在派生类中使用的成员才声明为private。

4) 如果希望基类的成员既不向外暴露（不能通过对象访问），还能在派生类中使用，那么只能声明为 protected。

由于private和protected继承方式会改变基类成员在派生类中的访问权限，导致继承关系复杂，所以，在实际开发中，一般使用public。

在派生类中，可以通过基类的公有成员函数间接访问基类的私有成员。

使用 using 关键字可以改变基类成员在派生类中的访问权限。

注意：using只能改变基类中public和protected成员的访问权限，不能改变private成员的访问权限，因为基类中的private成员在派生类中是不可见的，根本不能使用。

#include <iostream>

// 基类
class Base {
public:
    int publicMember;
protected:
    int protectedMember;
private:
    int privateMember;

public:
    Base() : publicMember(1), protectedMember(2), privateMember(3) {}

    // 公有成员函数，可以访问私有成员
    int getPrivateMember() const {
        return privateMember;
    }
};

// 公有继承
class PublicDerived : public Base {
public:
    void display() {
        std::cout << "PublicDerived - publicMember: " << publicMember << std::endl;
        std::cout << "PublicDerived - protectedMember: " << protectedMember << std::endl;
        // 无法访问 privateMember
        // std::cout << "PublicDerived - privateMember: " << privateMember << std::endl;
    }
};

// 受保护继承
class ProtectedDerived : protected Base {
public:
    void display() {
        std::cout << "ProtectedDerived - publicMember: " << publicMember << std::endl;
        std::cout << "ProtectedDerived - protectedMember: " << protectedMember << std::endl;
        // 无法访问 privateMember
        // std::cout << "ProtectedDerived - privateMember: " << privateMember << std::endl;
    }
};

// 私有继承
class PrivateDerived : private Base {
public:
    void display() {
        std::cout << "PrivateDerived - publicMember: " << publicMember << std::endl;
        std::cout << "PrivateDerived - protectedMember: " << protectedMember << std::endl;
        // 无法访问 privateMember
        // std::cout << "PrivateDerived - privateMember: " << privateMember << std::endl;
    }
};

// 使用 using 关键字改变访问权限
class UsingDerived : public Base {
public:
    using Base::protectedMember; // 将 protected 成员提升为 public

    void display() {
        std::cout << "UsingDerived - publicMember: " << publicMember << std::endl;
        std::cout << "UsingDerived - protectedMember: " << protectedMember << std::endl;
        // 无法访问 privateMember
        // std::cout << "UsingDerived - privateMember: " << privateMember << std::endl;
    }
};

int main() {
    PublicDerived pub;
    ProtectedDerived prot;
    PrivateDerived priv;
    UsingDerived use;

    pub.display();
    // 公有继承允许外部访问 public 成员
    std::cout << "main - PublicDerived publicMember: " << pub.publicMember << std::endl;
    // 无法访问 protected 成员
    // std::cout << "main - PublicDerived protectedMember: " << pub.protectedMember << std::endl;

    prot.display();
    // 受保护继承不允许外部访问 public 成员
    // std::cout << "main - ProtectedDerived publicMember: " << prot.publicMember << std::endl;

    priv.display();
    // 私有继承不允许外部访问 public 成员
    // std::cout << "main - PrivateDerived publicMember: " << priv.publicMember << std::endl;

    use.display();
    // 使用 using 关键字提升的成员可以外部访问
    std::cout << "main - UsingDerived protectedMember: " << use.protectedMember << std::endl;

    return 0;
}

这个示例代码展示了以下几点：

1. 公有继承允许派生类访问基类的 public 和 protected 成员，但不能访问 private 成员。
2. 受保护继承允许派生类访问基类的 public 和 protected 成员，但它们在派生类外部不可访问。
3. 私有继承允许派生类访问基类的 public 和 protected 成员，但它们在派生类外部不可访问。
4. 使用 using 关键字可以提升基类成员的访问权限。