C++继承方式

C++继承一般语法：

class 派生类名:［继承方式］ 基类名{
    派生类新增加的成员
};

继承方式限定了基类成员在派生类中的访问权限，包括 public（公有的）、private（私有的）和 protected（受保护的）。此项是可选项，如果不写，默认为 private（成员变量和成员函数默认也是 private）。

public、protected、private 修饰类的成员

1. 类成员的访问权限由高到低依次为 public –> protected –> private，public成员可以通过对象及派生类来访问，private 成员不能通过对象访问。
2. protected 成员和 private 成员类似，也不能通过对象访问。但是当存在继承关系时：基类中的 protected 成员可以在派生类中使用，而基类中的 private 成员不能在派生类中使用。

public、protected、private 指定继承方式

不同的继承方式会影响基类成员在派生类中的访问权限。

不同的继承方式，基类不同类型成员在派生类中的属性汇总如下：

继承方式/基类成员	public成员	protected成员	private成员
public继承	public	protected	不可见
protected继承	protected	protected	不可见
private继承	private	private	不可见

在上图中：1）基类成员对派生类都是：公有和保护的成员是可见的，私有的的成员是不可见的。

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

---

为了进一步理解三种不同的继承方式在其成员的可见性方面的区别，下面从三种不同角度进行讨论。

对于公有继承方式

(1) 基类成员对其对象的可见性：

• 公有成员可见，其他不可见。这里保护成员同于私有成员。

(2) 基类成员对派生类的可见性：

• 公有成员和保护成员可见，而私有成员不可见。这里保护成员同于公有成员。

(3) 基类成员对派生类对象的可见性：

• 公有成员可见，其他成员不可见。

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

对于私有继承方式

(1) 基类成员对其对象的可见性：

• 公有成员可见，其他成员不可见。

(2) 基类成员对派生类的可见性：

• 公有成员和保护成员是可见的，而私有成员是不可见的。

(3) 基类成员对派生类对象的可见性：

• 所有成员都是不可见的。

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

对于保护继承方式

(1) 基类成员对其对象的可见性：

• 公有成员可见，其他成员不可见。

(2) 基类成员对派生类的可见性：

• 公有成员和保护成员是可见的，而私有成员是不可见的。这里公有成员等同于保护成员。

(3) 基类成员对派生类对象的可见性：

• 所有成员都不可见。

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

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

---

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

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

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

---

注意
我们这里说的是基类的 private 成员不能在派生类中使用，并没有说基类的 private 成员不能被继承。实际上，基类的private 成员是能够被继承的，并且（成员变量）会占用派生类对象的内存，它只是在派生类中不可见，导致无法使用罢了。private成员的这种特性，能够很好的对派生类隐藏基类的实现，以体现面向对象的封装性。

#include <iostream>  

class base{  
public:  
    base(){  
        a = 0;  
        b = 1;  
        c = 2;  
    }  
    int a;  
protected:  
    int b;  
private:  
    int c;  
};  

class derived1 : public base{//public继承  
public:  
    void fun(){//derived class可以访问public和protected member  
        std::cout<<base::a<<base::b<<std::endl;  
    //  std::cout<<base::c;//不能访问  
    }  
};  
class derived2 : protected base{//protected继承  
public:  
    void fun(){//derived class可以访问public和protected member  
        std::cout<<base::a<<base::b<<std::endl;  
     // std::cout<<base::c;//不能访问  
    }  
};  
class derived3 : private base{//private继承  
public:  
    void fun(){//derived class可以访问public和protected member  
        std::cout<<base::a<<base::b<<std::endl;  
     // std::cout<<base::c;//不能访问  
    }  
};  
class derived4 : public derived3{//base的member不能被private继承的派生类的子类访问  
public:  
    void fun(){  
    //  std::cout<<a;  
    }  
};  
class derived5 : base{//默认private继承  
    void fun(){//derived class可以访问public和protected member  
        std::cout<<base::a<<base::b;  
        // std::cout<<base::c;//不能访问  
    }     
};  
int main(void)  
{  
    base b1;  
    derived1 d1;  
    derived2 d2;  
    derived3 d3;  
    d1.fun();  
    d2.fun();  
    d3.fun();  
    std::cout<<b1.a;//base class Object只能访问public member  
    std::cout<<d1.a;//public继承时 derived class Object只能访问base class的public member  
    //std::cout<<d1.b<<d1.c;//不能访问  
    //std::cout<<d2.a<<d2.b;//protected继承时 derived class Object不能问访base class的member  
    //std::cout<<d3.a;//private继承时 derived class Object不能问访base class的member  
    return 0;  
}  

在派生类中访问基类 private 成员的唯一方法就是借助基类的非 private 成员函数，如果基类没有非 private 成员函数，那么该成员在派生类中将无法访问（除非使用下面讲到的 using 关键字）。

在private或者protected继承时，基类成员的访问级别在派生类中更受限：

class Base {
public:
    std::size_t size() const { return n; }
protected:
    std::size_t n;
};

class Derived : private Base { . . . };

在这一继承层次中，成员函数 size 在 Base 中为 public，但在 Derived 中为 private。为了使 size 在 Derived 中成为 public，可以在 Derived 的 public部分增加一个 using 声明。如下这样改变 Derived 的定义，可以使 size 成员能够被用户访问，并使 n 能够被 Derived的派生类访问：

class Derived : private Base {
public:
    using Base::size;
protected:
    using Base::n;
// ...
};