C++ public, protected, private 继承

三种继承中，不会影响派生类对基类的访问权限，派生类能否访问基类的成员方法主要由基类中的访问控制符决定的。
三种继承方式主要是对使用派生类的用户进行访问权限的控制，体现在对父类中原本为 public 或 protected 权限的修改。

class Base {
public:
    Base(int base_mem = 0) : base_mem_(base_mem) {}
    virtual ~Base() { }

    int GetBaseMem() const { return base_mem_; }
    int SetBaseMem(const int base_mem) { base_mem_ = base_mem; }

protected:
    void P() { cout << "P: " << base_mem_ << endl; }

private:
    int base_mem_;
};

public 继承：

不会改变父类的成员访问权限，也是我们常用的一种。

class Foo: public Base {
public:
    Foo() { }
    ~Foo() { }

    void FooP() { P(); }    //派生类可以访问父类的保护方法
};

// main.cpp
Foo foo;
foo.SetBaseMem(12);   //父类 public 方法可以被派生类用户使用。
foo.FooP();

protected 继承：

会将父类中的 public 成员方法变成 protected。

class FooA: protected Base {
public:
    FooA() { }
    ~FooA() { }

    void FooAP() { SetBaseMem(13); P(); }   //即使是 protected 继承也不影响派生类对父类 protected 成员和public 成员的访问权限。
};

// main.cpp
FooA fooa;
//fooa.SetBaseMem(13);  错误的，在 FooA 中该方法由于 protected 继承已经变为 protected，用户没有访问权限。
fooa.FooAP();

private 继承：

若未指定继承访问控制符的话，默认是 private 继承，会将父类中的 protected 方法成员和 public 方法成员变为 private。

class FooB: private Base {
public:
    FooB() { }
    ~FooB() { }

    void FooBP() { P(); }
};

或
class FooB: Base {
public:
    FooB() { }
    ~FooB() { }

    void FooBP() { P(); }
};

子类到父类转换的访问权限：

C++ 用子类如果用了 protected 或 private 继承的话，就无法使用父类的指针去指向子类了。

FooA fooa;
Base *basep = &fooa; //错误

无论何种情况继承的父类，子类的成员函数和友元都能使用子类到父类的转换。

class FooPro: protected Base {
    friend void SetBaseMemOut(FooPro &foo, int base_mem);
public:
    FooPro() { }
    ~FooPro() { }

    void FooAP() { P(); }

    void SetBaseMemPro(int base_mem) {
        Base *base = this;                                     //这里虽然是多余的, 但是是正确的.
        base->SetBaseMem(base_mem);
    }
};

void SetBaseMemOut(FooPro &foo, int base_mem) {
    Base &base = foo;                        //这里也是多余的, 但是还是正确的.
    base.SetBaseMem(base_mem);
}

子类通过 public 和 protected 继承的父类, 那么子类的派生类的成员和友元可以使用子类到父类的转换.

所有总结起来就是, 在特定的作用域节点中, 如果子类可以访问父类的公有成员的话, 就可以使用子类到父类的转换.

using 声明

使用 using 可以单独改变成员名字的可访问权限, 前提是只能为那些派生类有权访问的方法成员.

class FooPro2: private Base {
public:
    FooPro2() { }
    ~FooPro2() { }

    using Base::SetBaseMem;
    using Base::P;
};