C++基类和派生类私有、保护、公有成员访问控制以及动态绑定、三种继承

1.类的一个特征就是封装，public和private作用就是实现这一目的。所以：

用户代码（类外）可以访问public成员而不能访问private成员；private成员只能由类成员（类内）和友元访问。private不能被继承，不能被子类的成员函数访问。

2.类的另一个特征就是继承，protected的作用就是实现这一目的。所以：

protected成员可以被类成员和友元访问，也可以被派生类对象访问，不能被用户代码（类外）访问。

3，virtual函数

    在设计一个基类的时候，如果发现一个函数需要在派生类里有不同的表现，那么它就应该是虚的。
   从设计角度讲，出现在基类中的虚函数是接口，出现在派生类中的虚函数是接口的具体实现。通过
   这样的方法，就可以将对象的行为抽象化。即，虚函数在子类中被重新定义。

4.C++中的静态绑定和动态绑定

C++在面向对象编程中，存在着静态绑定和动态绑定的定义，本节即是主要讲述这两点区分。

我是在一个类的继承体系中分析的，因此下面所说的对象一般就是指一个类的实例。

首先我们需要明确几个名词定义：
静态类型：对象在声明时采用的类型，在编译期既已确定；
动态类型：通常是指一个指针或引用目前所指对象的类型，是在运行期决定的；
静态绑定：绑定的是静态类型，所对应的函数或属性依赖于对象的静态类型，发生在编译期；
动态绑定：绑定的是动态类型，所对应的函数或属性依赖于对象的动态类型，发生在运行期；

从上面的定义也可以看出，非虚函数一般都是静态绑定，而虚函数都是动态绑定（如此才可实现多态性）。

先看代码和运行结果：

1 class A
2 {
3 public:
4     /*virtual*/ void func(){ std::cout << "A::func()\n"; }
5 };
6 class B : public A
7 {
8 public:
9     void func(){ std::cout << "B::func()\n"; }
10 };
11 class C : public A
12 {
13 public:
14     void func(){ std::cout << "C::func()\n"; }
15 };

下面逐步分析测试代码及结果，

1 C* pc = new C(); //pc的静态类型是它声明的类型C*，动态类型也是C*；
2 B* pb = new B(); //pb的静态类型和动态类型也都是B*；
3 A* pa = pc;      //pa的静态类型是它声明的类型A*，动态类型是pa所指向的对象pc的类型C*；
4 pa = pb;         //pa的动态类型可以更改，现在它的动态类型是B*，但其静态类型仍是声明时候的A*；
5 C *pnull = NULL; //pnull的静态类型是它声明的类型C*,没有动态类型，因为它指向了NULL；

如果明白上面代码的意思，请继续， 

1 pa->func();      //A::func() pa的静态类型永远都是A*，不管其指向的是哪个子类，都是直接调用A::func()；
2 pc->func();      //C::func() pc的动、静态类型都是C*，因此调用C::func()；
3 pnull->func();   //C::func() 不用奇怪为什么空指针也可以调用函数，因为这在编译期就确定了，和指针空不空没关系；

 如果注释掉类C中的func函数定义，其他不变，即

1 class C : public A
2 {
3 };
4
5 pa->func();      //A::func() 理由同上；
6 pc->func();      //A::func() pc在类C中找不到func的定义，因此到其基类中寻找；
7 pnull->func();   //A::func() 原因也解释过了；

如果为A中的void func()函数添加virtual特性，其他不变，即

1 class A
2 {
3 public:
4     virtual void func(){ std::cout << "A::func()\n"; }
5 };
6
7 pa->func();      //B::func() 因为有了virtual虚函数特性，pa的动态类型指向B*，因此先在B中查找，找到后直接调用；
8 pc->func();      //C::func() pc的动、静态类型都是C*，因此也是先在C中查找；
9 pnull->func();   //空指针异常，因为是func是virtual函数，因此对func的调用只能等到运行期才能确定，然后才发现pnull是空指针；

分析：

在上面的例子中，

1. 如果基类A中的func不是virtual函数，那么不论pa、pb、pc指向哪个子类对象，对func的调用都是在定义pa、pb、pc时的静态类型决定，早已在编译期确定了。

    同样的空指针也能够直接调用no-virtual函数而不报错（这也说明一定要做空指针检查啊！），因此静态绑定不能实现多态；

2. 如果func是虚函数，那所有的调用都要等到运行时根据其指向对象的类型才能确定，比起静态绑定自然是要有性能损失的，但是却能实现多态特性；

 本文代码里都是针对指针的情况来分析的，但是对于引用的情况同样适用。

至此总结一下静态绑定和动态绑定的区别：
1. 静态绑定发生在编译期，动态绑定发生在运行期；

2. 对象的动态类型可以更改，但是静态类型无法更改；

3. 要想实现动态，必须使用动态绑定；

4. 在继承体系中只有虚函数使用的是动态绑定，其他的全部是静态绑定；

 建议：

绝对不要重新定义继承而来的非虚(non-virtual)函数（《Effective C++ 第三版》条款36），因为这样导致函数调用由对象声明时的静态类型确定了，而和对象本身脱离了关系，没有多态，也这将给程序留下不可预知的隐患和莫名其妙的BUG；

 

另外，在动态绑定也即在virtual函数中，要注意默认参数的使用。当缺省参数和virtual函数一起使用的时候一定要谨慎，不然出了问题怕是很难排查。

看下面的代码：

1 class E
2 {
3 public:
4     virtual void func(int i = 0)
5     {
6         std::cout << "E::func()\t"<< i <<"\n";
7     }
8 };
9 class F : public E
10 {
11 public:
12     virtual void func(int i = 1)
13     {
14         std::cout << "F::func()\t" << i <<"\n";
15     }
16 };
17
18 void test2()
19 {
20     F* pf = new F();
21     E* pe = pf;
22     pf->func(); //F::func() 1  正常，就该如此；
23     pe->func(); //F::func() 0  哇哦，这是什么情况，调用了子类的函数，却使用了基类中参数的默认值！
24 }

为什么会有这种情况，请看《Effective C++ 第三版》 条款37。

这里只给出建议：
绝对不要重新定义一个继承而来的virtual函数的缺省参数值，因为缺省参数值都是静态绑定（为了执行效率），而virtual函数却是动态绑定。

 
5，三种继承

C++对父类（也称基类）的继承有三种方式，分别为：public继承、protected继承、private继承。三种继承方式的不同在于继承之后子类的成员函数的“可继承性质”。

在说三种继承方式导致的子类成员函数可继承性质改变之前，先说一下在定义类的成员（包括函数和属性）的时候，在其前面添加public 或 protected 或 private对成员的可继承性的影响。其中，public类型的成员，在被继承的时候，能直接被子类使用，注意，如果成员属性是public的话，子类则可直接调用该成员属性。例如：

class A  // 父类  

{  

public：  

      A();  

      int size;  

}  

class B:public A   // 子类  

{  

public:  

    change(const int x)  

   {  

      size = x;  

    }  

}  

我这里写了个很简单的例子，其中父类A具有一个public类型的成员函数A()和一个public类型的成员属性size（int）。因为size是public的，所以在A的子类B中，B的成员函数可以直接调用size进行修改。因为size也是B的属性并且是可见也是可修改的。

如果成员是protected的话，表明只有这个类的继承类（子女）或者友好的类（friend）能购使用（直接调用）这些成员，否则不能使用。然后private成员的话固然是只有自己本身这个类可用，对其他任何类都不可见，也不可用，引用百度百科上的一段话概括这三者就是：

“1、public：public表明该数据成员、成员函数是对所有用户开放的，所有用户都可以直接进行调用

2、private：private表示私有，私有的意思就是除了class自己之外，任何人都不可以直接使用，私有财产神圣不可侵犯嘛，即便是子女，朋友，都不可以使用。

3、protected：protected对于子女、朋友来说，就是public的，可以自由使用，没有任何限制，而对于其他的外部class，protected就变成private。”

好，下面进入正题，就是三种对父类的不同继承方式对子类可继承方式的影响：

（1）public继承：

不改变父类成员的继承性质（public、protected、private），也就是说，父类public的成员在子类中仍然是public的，父类protected的成员在子类中仍然是protected的。派生类的成员函数可以访问基类的，公有，保护成员，但是不能访问的她的私有成员。基类的私有和保护成员对对象是不可见的，对象只能直接访问基类的公有对象。

（2）protected继承：

父类public类型的成员在子类中变为protected性质，protected的被继承依然是protected的。

派生类的成员函数可以访问基类的，公有，保护成员，但是不能访问的她的私有成员。基类的私有和保护成员，公有成员对对象是不可见的。

（3）private继承：

父类所有成员在被子类中都变成或者保留为private性质的。

派生类的成员函数可以访问基类的，公有，保护成员，但是不能访问的她的私有成员。基类的私有和保护成员，公有成员对对象是不可见的。