三种继承中，不会影响派生类对基类的访问权限，派生类能否访问基类的成员方法主要由基类中的访问控制符决定的。
三种继承方式主要是对使用派生类的用户进行访问权限的控制，体现在对父类中原本为 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;
};
