作用域分辨符

如果派生类中存在和基类中完全相同的函数，将发生同名覆盖。如果在派生类中存在一个和基类某数据成员同名的数据成员，或者和基类某成员函数的名称和参数表都相同的成员函数，则派生类中的新成员就覆盖了基类成员，不管是在派生类内还是在派生类外部只能通过成员名访问到派生类的成员，而访问不到基类成员。
如果需要在派生类中访问基类中的同名成员怎么办呢？
可以通过基类名和作用域分辨符来访问基类中的同名成员。作用域分辨符就是“::”。

• 在派生类内部访问基类同名成员的语法形式是：

基类名::数据成员名;           // 数据成员
基类名::函数成员名(参数表);   // 函数成员

• 在派生类外通过派生类对象访问的话，前面还要加上“派生类对象名.”：

派生类对象名.基类名::数据成员名;                  // 数据成员
派生类对象名.基类名::函数成员名(参数表);   // 函数成员

这里的基类名就限定了后面的成员属于哪个类。

如果多个基类具有同名成员，派生类也新增了同名成员，则派生类成员会覆盖所有基类中的同名成员。通过成员名只能访问到派生类的成员，要访问各基类的同名成员就需要使用作用域分辨符。而如果派生类中不存在同名成员，访问多个基类的同名成员也需要使用作用域分辨符，因为从不同基类继承过来的同名成员具有相同的作用域，通过成员名无法唯一标识成员，所以也需要作用域分辨符来分辨。

1. 多继承情况下同名覆盖的例子

#include <iostream>
using namespace std;
class Base1                // 基类Base1的声明
{
public:
     int x;
     void show()        { cout<<"x of Base1: "<<x<<endl; } 
};
class Base2                // 基类Base2的声明
{
public:
     int x;
     void show()        { cout<<"x of Base2: "<<x<<endl; } 
};
class Child : public Base1, public Base2    // 派生类Child的声明
{
public:
    int x;
    void show()        { cout<<"x of Child: "<<x<<endl; } 
};
int main()
{
     Child child;
     child.x = 5;          // 访问派生类数据成员
     child.show();         // 调用派生类函数成员
     child.Base1::x = 7;   // 使用作用域分辨符访问基类Base1的数据成员
     child.Base1::show();  // 使用作用域分辨符调用基类Base1的函数成员
     child.Base2::x = 8;   // 使用作用域分辨符访问基类Base2的数据成员
     child.Base2::show();  // 使用作用域分辨符访问基类Base2的函数成员
     return 0;
}

• 主函数main中声明了派生类Child的对象child，因为同名覆盖，所以通过成员名只能访问派生类Child的成员，要访问基类Base1和Base2的同名成员就需要像上面那样使用作用域分辨符访问。如果在派生类Child的成员函数show中访问基类Base1的同名成员，比如x，则可以将Child的show函数修改为：void show() { cout<<"x of Child: "<<Base1::x<<endl; }。

2. 多继承情况下无同名覆盖的例子
   将上例中派生类Child的新增同名成员去掉，改为：

class Child : public Base1, public Base2
{
};

程序其余部分不变，则主函数main中的语句child.x = 5;和child.show();就会编译报错，因为这两个标识符具有二义性，系统无法唯一标识它们，不知道该访问哪个成员。只能通过作用域分辨符来访问。

3. 如果派生类的全部或者部分基类有共同的基类，也就是说派生类的这些基类是从同一个基类派生出的，那么派生类的这些直接基类从上一级基类继承的成员都具有相同的名称，即都是同名成员，要访问它们就必须通过直接基类限定，使用作用域分辨符访问。

#include <iostream>
using namespace std;
class Base0                    // 基类Base0的声明
{
public:
     int x;
     void show()      { cout<<"x of Base0: "<<x<<endl; }
};
class Base1 : public Base0     // 由Base0派生的类Base1的声明
{
};
class Base2 : public Base0     // 由Base0派生的类Base2的声明
{
};
class Child : public Base1, public Base2
{
};
int main()
{
      Child child;
      child.Base1::x = 3;      // 通过直接基类Base1限定成员
      child.Base1::show();
      child.Base2::x = 5;      // 通过直接基类Base2限定成员
      child.Base2::show();
      return 0;
}

我们先声明一个基类Base0，Base0中有数据成员x和函数成员show，再声明类Base1和Base2，它们都由Base0公有继承而来，最后从Base1和Base2共同派生出类Child。这时Base0的成员经过到Base1和Base2再到Child的两次派生过程，出现在Child类中时，实际上Base0的数据成员x已经是两个不同的成员，只是名称相同但是在内存中是两份，函数成员show也是两个不同的成员，只是名称相同但是函数体可能不同。这就需要使用作用域分辨符访问了，但是不能用基类Base0来限定，因为这样还是不能说明成员是从Base1还是Base2继承而来，所以必须使用直接基类Base1或者Base2来限定，达到唯一标识成员的目的。
上面的主函数main中定义了派生类Child的对象child，如果只通过成员名访问成员x和show，系统就不能确定访问哪个x和哪个show，这就需要使用直接基类Base1或者Base2和作用域分辨符来访问它们。
数据成员x在内存中有两份拷贝，可以存放不同的数值，但是一般我们只需要一个这样的拷贝，那多出来的那个就是对内存的浪费。解决这个问题就需要后面讲的虚基类技术。

虚基类

概念及用法

• 场景：如果派生类的全部或者部分基类有共同的基类，那么派生类的这些直接基类从上一级基类继承的成员都具有相同的名称，定义了派生类的对象后，同名数据成员就会在内存中有多份拷贝，同名函数也会有多个映射。
• 解决方案：访问这些同名成员时，为了唯一标识它们可以使用作用域分辨符，也可以使用虚基类技术。

虚基类：将派生类直接基类的共同基类声明为虚基类后，派生类从不同的直接基类继承来的同名数据成员在内存中就会只有一份拷贝，同名函数也会只有一个映射，这样不仅实现了唯一标识同名成员，而且也节省了内存空间。（赋值时只能赋一个值，若不用虚基类则占用多个内存，可以赋多个值）
虚基类声明的语法形式为：

class 派生类名:virtual 继承方式 基类名

• 这里关键字virtual跟继承方式一样，只限定紧跟在它后面的基类。比如，声明了类A为虚基类，类B为A的派生类，类C也是A的派生类，类D是由类B和C共同继承而来，则类B和类C从A继承的同名数据成员在类D的对象中只有一份拷贝，同名函数成员也只有一个函数体。(声明了那个基类是虚基类，那么和其有关的派生类对象调用该基类中的数据成员和函数成员时只会在内存中拷贝一份，不管有多少重继承关系和什么继承途径)

#include <iostream>
using namespace std;
class Base0                    // 基类Base0的声明
{
public:
     int x;
     void show()      { cout<<"x of Base0: "<<x<<endl; }
};
class Base1 : virtual public Base0     // Base0为虚基类，公有派生Base1类
{
};
class Base2 : virtual public Base0     // Base0为虚基类，公有派生Base2类
{
};
class Child : public Base1, public Base2
{
};
int main()
{
    Child child;
    child.x = 5;
    child.show();
    return 0;
}

声明虚基类只需要在它的派生类声明时使用关键字virtual修饰。

我们对作用域分辨符和虚基类技术进行对比分析可知，使用作用域分辨符唯一标识同名成员时，派生类中有同名成员的多个拷贝，可以存放不同的数据，进行不同的操作，而使用虚基类时派生类的同名成员只有一份拷贝，更节省内存。我们在软件开发中可以根据实际情况自己做出选择。

虚基类派生类的构造函数

如果虚基类定义了带参数表的非默认构造函数，没有定义默认形式的构造函数，那么情况会有些复杂。因为由虚基类直接或间接继承的所有派生类，都必须在构造函数的成员初始化列表中给出对虚基类成员的初始化。

#include <iostream>
using namespace std;
class Base0                    // 基类Base0的声明
{
public:
      Base0(int y)     { x=y; }
      int x;
      void show()      { cout<<"x of Base0: "<<x<<endl; }
};
class Base1 : virtual public Base0     // Base0为虚基类，公有派生Base1类
{
public:
      Base1(int y):Base0(y)    { }
};
class Base2 : virtual public Base0     // Base0为虚基类，公有派生Base2类
{
public:
      Base2(int y):Base0(y)    { }  
};
class Child : public Base1, public Base2
{
public:
      Child(int y):Base0(y),Base1(y),Base2(y)   { }
};
int main()
{
    Child child(3);
    child.show();
    return 0;
}

• 如果不是虚基类，那么Base0这个基类的构造函数将被调用3次，这里采用虚基类，编译器在遇到这种情况时会进行特殊处理：如果构造的对象中有从虚基类继承来的成员，那么虚基类成员的初始化由而且只由最远派生类的构造函数调用虚基类的构造函数来完成。
• 最远派生类就是声明对象时指定的类，上面例子中构造对象child时，类Child就是最远派生类。除了最远派生类，它的其他基类对虚基类构造函数的调用会被忽略。上例中就只会由Child类的构造函数调用虚基类Base0的构造函数完成成员x的初始化，而Child类的基类Base1和Base2对虚基类Base0构造函数的调用会被忽略。

赋值兼容规则

派生类如果是从基类公有继承的，则它会包含基类中除构造函数和析构函数外的所有成员，基类的公有成员也成为派生类的公有成员，又因为对象只能访问类的公有成员，所以基类对象具有的功能，派生类对象都有。这样就引出了赋值兼容规则
***赋值兼容规则就是指在基类对象可以使用的地方都可以用公有派生类对象来代替。***注意必须是公有派生类。
赋值兼容规则中的代替有三种方式：

1. 派生类的对象可以赋值给基类的对象。
2. 派生类对象的地址可以赋值给基类类型的指针。
3. 派生类对象可以用来初始化基类的引用。

class Base
{
       ...
};
class Child : public Base
{
    ...
};
Base base, *pBase;
Child child;

base = child;     //赋值
pBase = &child；  //指针
Base &b = child;  //引用

作用：
因为有了赋值兼容规则，有了上述三种赋值方式，所以函数的参数中有基类对象或者基类指针又或者基类引用时，我们可以直接传入派生类对象或者派生类对象的地址作为实参来执行相同的操作。这样的好处是什么呢？那就是我们想对基类及派生类的对象做相同的操作时，只要定义一个函数就行了，它的参数为基类对象或者基类指针也或者是基类引用。这样就大大提高了软件开发的效率。
公有派生类对象可以代替基类对象使用，但是我们只能使用它从基类继承的成员，而无法使用它的新添成员。

#include <iostream>
using namespace std;
class Base           // 基类Base的声明
{
public:
     void show()    { cout << "Base::show()" << endl; }      // 公有成员函数show
};
class Child0 : public Base     // 类Base的公有派生类Child0的声明
{
public:
     void show()    { cout << "Child0::show()" << endl; }    // 公有成员函数show
};
class Child1 : public Child0   // 类Child0的公有派生类Child1的声明
{
public:
     void show()    { cout << "Child1::show()" << endl; }    // 公有成员函数show
};
void CallShow(Base *pBase)     // 一般函数，参数为基类指针
{
     pBase->show();
}
int main()
{
     Base base;                 // 声明Base类的对象
     Base *pBase;             // 声明Base类的指针
     Child0 ch0;                 // 声明Child0类的对象
     Child1 ch1;                 // 声明Child1类的对象
     pBase = &base;        // 将Base类对象base的地址赋值给Base类指针pBase
     CallShow(pBase);
     pBase = &ch0;            // 将Child0类对象ch0的地址赋值给Base类指针pBase
     CallShow(pBase);
     pBase = &ch1;            // 将Child1类对象ch1的地址赋值给Base类指针pBase
     CallShow(pBase);
     return 0;
}

• 针对基类中函数的操作，可以直接从公有派生类的对象进行赋值来操作。不用再对派生类单独创建操作函数
• 我们首先定义了一个函数CallShow，其参数pBase为基类Base类型的指针，根据赋值兼容规则，我们可以用公有派生类对象的地址为基类指针赋值，那么CallShow函数就可以处理这个类族的所有对象。在主函数中我们就分别把基类对象base的地址、派生类对象ch0的地址和派生类对象ch1的地址赋值给基类指针pBase，然后将pBase作为实参调用CallShow，在CallShow中调用了成员函数show。
• 将派生类对象的地址赋值给pBase以后，通过pBase只能访问派生类从基类继承的成员。所以即使指针pBase指向的是派生类对象ch0或者ch1，在CallShow中通过pBase也只能调用从基类Base继承的成员函数show，而不会调用Child0类或者Child1类的成员函数show。因此主函数中三次调用CallShow函数，都是访问的基类Base的成员函数show，输出都是Base::show()。

即使派生类对象代替了基类对象，它也只能产生基类的功能，自己的新功能无法体现。要想在代替以后同样能够实现自己的功能，就要用到面向对象设计的另一个特性–多态性。