c++继承：公有、私有、保护（对应p12访问限制）

公有继承(public)、私有继承(private)、保护继承(protected)是常用的三种继承方式。

1. 公有继承(public)

公有继承的特点是基类的公有成员和保护成员作为派生类的成员时，它们都保持原有的状态，而基类的私有成员仍然是私有的，不能被这个派生类的子类所访问。

2. 私有继承(private)

私有继承的特点是基类的公有成员和保护成员都作为派生类的私有成员，并且不能被这个派生类的子类所访问。

3. 保护继承(protected)

保护继承的特点是基类的所有公有成员和保护成员都成为派生类的保护成员，并且只能被它的派生类成员函数或友元访问，基类的私有成员仍然是私有的。

下面列出三种不同的继承方式的基类特性和派生类特性。

	public	proteced	private
公有继承	public	protected	不可见
私有继承	private	private	不可见
保护继承	protected	protected	不可见

在上图中：

1. 基类成员对派生类都是：公有和保护的成员是可见的，私有的的成员是不可见的。
2. 基类成员对派生类的对象来说：要看基类的成员在派生类中变成了什么类型的成员。如：私有继承时，基类的公有成员和保护成员都变成了派生类中的私有成员，因此对于派生类中的对象来说基类的公有成员和保护成员就是不可见的。

对于公有继承方式

1. 基类成员对其对象的可见性：公有成员可见，其他不可见。这里保护成员同于私有成员。
2. 基类成员对派生类的可见性：公有成员和保护成员可见，而私有成员不可见。这里保护成员同于公有成员。
3. 基类成员对派生类对象的可见性：公有成员可见，其他成员不可见。

　　所以，在公有继承时，派生类的对象可以访问基类中的公有成员；派生类的成员函数可以访问基类中的公有成员和保护成员。这里，一定要区分清除派生类的对象和派生类中的成员函数对基类的访问是不同的。

对于私有继承方式

1. 基类成员对其对象的可见性：公有成员可见，其他不可见。
2. 基类成员对派生类的可见性：公有成员和保护成员是可见的，而私有成员是不可见的。
3. 基类成员对派生类对象的可见性：所有成员都是不可见的。

　　所以，在私有继承时，基类的成员只能由直接派生类访问，而无法再往下继承。

对于保护继承方式

　　这种继承方式与私有继承方式的情况相同。两者的区别仅在于对派生类的成员而言，对基类成员有不同可见性。

　　上述所说的可见性也就是访问性。

　　关于访问性还有另一种说法。这种规则中，称派生类的对象对基类访问为水平访问，称派生类的派生类对基类的访问为垂直访问。

代码说明：

#include <iostream>
using namespace std;
class A        //父类
{
private:
    int privatedateA;
protected:
    int protecteddateA;
public:
    int publicdateA;
};
///////////////////////////////////////////////////////
class B : public A        //基类A的派生类B(公有继承)
{
public:
    void func()
    {
        int b;
        //b=privatedateA;        //error:基类中私有成员在派生类中是不可见的
        b=protecteddateA;    //ok:基类的保护成员在派生类中为保护成员
        b=publicdateA;        //ok:基类的公有成员在派生类中为公有成员
    }
};
//////////////////////////////////////////////////////
class C : private A
{
public:
    void func()
    {
        int c;
        //c=privatedateA;        //error:基类中私有成员在派生类中是不可见的
        c=protecteddateA;    //ok:基类的保护成员在派生类中为私有成员
        c=publicdateA;        //ok:基类的公有成员在派生类中为私有成员
    }
};
//////////////////////////////////////////////////////
class D : protected A
{
public:
    void func()
    {
        int d;
        //d=privatedateA;        //error:基类中私有成员在派生类中是不可见的
        d=protecteddateA;    //ok:基类的保护成员在派生类中为保护成员
        d=publicdateA;        //ok:基类的公有成员在派生类中为保护成员
    }
};

int main()
{
    int a;

    B objB;
    //a=objB.privaredateA;    //error:基类中私有成员在派生类中是不可见的，对对象不可见
    //a=objB.protecteddateA;    //error:基类的保护成员在派生类中为保护成员，对对象不可见
    a=objB.publicdateA;        //ok:基类的公共成员在派生类中为公共成员，对对象可见

    C objC;
    //a=objC.privatedateA;    //error:基类中私有成员在派生类中是不可见的，对对象不可见
    //a=objC.protecteddateA;    //error:基类的保护成员在派生类中为私有成员，对对象不可见
    //a=objC.publicdateA;        //error:基类的公有成员在派生类中为私有成员，对对象不可见

    D objD;
    //a=objD.privatedateA;    //error:基类中私有成员在派生类中是不可见的，对对象不可见
    //a=objD.protecteddateA;    //error:基类中保护成员在派生类中是保护成员，对对象不可见
    //a=objD.publicdateA;        //error:基类中公有成员在派生类中是保护成员，对对象不可见
　　return 0;
}

目录

1. c++(翁恺浙大公开课) 笔记0
2. static在c\c++中的作用（翁恺c++公开课[28-29]学习笔记）
3. c++对象初始化（翁恺c++公开课[10]）
4. c++构造函数的初始化列表（翁恺c++公开课[13]）
5. c++继承：公有、私有、保护
6. c++子类父类关系（翁恺c++公开课[15-16]学习笔记）
7. c++拷贝构造函数（翁恺c++公开课[26-27]学习笔记）
8. c++多态性及多态的内部实现(翁恺c++公开课[23-24])
9. c++中的运算符重载operator1(翁恺c++公开课[30]学习笔记)
10. c++中的运算符重载operator2(翁恺c++公开课[31-33]学习笔记)
11. c++模板(翁恺c++公开课[34-35]学习笔记)
12. 最好不要在头文件中写函数定义