继承与派生：作用域分辨符(转)

最新推荐文章于 2022-11-28 20:04:12 发布

weixin_30352645

最新推荐文章于 2022-11-28 20:04:12 发布

阅读量113

点赞数

原文链接：http://www.cnblogs.com/fuxianfeng1988/p/3273052.html

版权

原文地址：http://www.jizhuomi.com/software/104.html

鸡啄米在编程入门系列的前两节中讲了派生类的构造函数和析构函数，现在来讲讲通过作用域分辨符访问派生类成员的问题。

访问派生类的成员有可见性和唯一性两个问题，我们只能访问到具有唯一性的可见成员。

先说说可见性的问题。前面C++编程入门系列之十八的作用域和可见性中讲过，如果有两个以上具有包含关系的作用域，外层作用域中的标识符在内层作用域中没有同名标识符则它在内层作用域中也是可见的，但是如果在内层作用域中存在同名标识符则外层的标识符被屏蔽，这也叫做同名覆盖。派生类在继承时，基类的成员和派生类的新增成员都有类作用域，但是是两个具有包含关系的作用域，派生类作用域位于内层。如果在派生类中存在一个和基类某数据成员同名的数据成员，或者和基类某成员函数的名称和参数表都相同的成员函数，则派生类中的新成员就覆盖了基类成员，不管是在派生类内还是在派生类外部只能通过成员名访问到派生类的成员，而访问不到基类成员。如果需要在派生类中访问基类中的同名成员怎么办呢？

我们可以通过基类名和作用域分辨符来访问基类中的同名成员。作用域分辨符就是“::”，在派生类内部访问基类同名成员的语法形式是：

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

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

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

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

如果是多继承的话，要考虑派生类的基类有没有共同基类的问题。鸡啄米先讲多个基类之间没有继承关系也没有共同基类的情况。这种情况下如果多个基类具有同名成员，派生类也新增了同名成员，则派生类成员会覆盖所有基类中的同名成员。通过成员名只能访问到派生类的成员，要访问各基类的同名成员就需要使用作用域分辨符。而如果派生类中不存在同名成员，访问多个基类的同名成员也需要使用作用域分辨符，因为从不同基类继承过来的同名成员具有相同的作用域，通过成员名无法唯一标识成员，所以也需要作用域分辨符来分辨。

鸡啄米给大家一个多继承情况下同名覆盖的例子：

派生类Child由基类Base1和Base2公有继承而来，两个基类有同名数据成员x和同名函数成员show，派生类Child又新增了同名的数据成员 x和同名的函数成员show，这样派生类Child中就一共有6个成员，三个同名的数据成员和三个同名的函数成员。

       #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;
       }

程序运行结果：

        x of Child: 5
        x of Base1: 7
        x of Base2: 8

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

如果上例中的派生类Child中没有定义与基类成员同名的成员，则通过成员名就访问不到任何成员，因为继承的Base1和Base2的同名成员具有相同的作用域，系统无法唯一标识它们。如果要访问基类Base1或Base2的同名成员就需要使用作用域分辨符。

将上例中派生类Child的新增同名成员去掉，改为：

class Child : public Base1, public Base2
{

};

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

上面对于多继承的讨论都是假设多个基类之间没有继承关系也没有共同基类的情况，而如果派生类的全部或者部分基类有共同的基类，也就是说派生类的这些基类是从同一个基类派生出的，那么派生类的这些直接基类从上一级基类继承的成员都具有相同的名称，即都是同名成员，要访问它们就必须通过直接基类限定，使用作用域分辨符访问。

上面说的可能有些抽象，鸡啄米再给出个程序例子来说明这种情况吧。我们先声明一个基类Base0，Base0中有数据成员x和函数成员show，再声明类 Base1和Base2，它们都由Base0公有继承而来，最后从Base1和Base2共同派生出类Child。这时Base0的成员经过到Base1 和Base2再到Child的两次派生过程，出现在Child类中时，实际上Base0的数据成员x已经是两个不同的成员，只是名称相同但是在内存中是两份，函数成员show也是两个不同的成员，只是名称相同但是函数体可能不同。这就需要使用作用域分辨符访问了，但是不能用基类Base0来限定，因为这样还是不能说明成员是从Base1还是Base2继承而来，所以必须使用直接基类Base1或者Base2来限定，达到唯一标识成员的目的。程序例子如下：

        #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;
        }

程序运行结果：

 x of Base0: 3
 x of Base0: 5

上面的主函数main中定义了派生类Child的对象child，如果只通过成员名访问成员x和show，系统就不能确定访问哪个x和哪个show，这就需要使用直接基类Base1或者Base2和作用域分辨符来访问它们。上面鸡啄米说了，数据成员x在内存中有两份拷贝，可以存放不同的数值，但是一般我们只需要一个这样的拷贝，那多出来的那个就是对内存的浪费。解决这个问题就需要后面讲的虚基类技术。

转载于:https://www.cnblogs.com/fuxianfeng1988/p/3273052.html