如何在派生类中的隐藏基类的虚拟重载函数？

最新推荐文章于 2024-05-14 17:24:10 发布

转载最新推荐文章于 2024-05-14 17:24:10 发布 · 1.1k 阅读

文章标签：

#public继承 #继承重载函数 #如何在派生类中的隐藏基类的虚拟重载函数

本文详细解释了在C++中如何在派生类中既重载又改写基类中的虚拟函数，通过创建显式调用基类的函数或使用using关键字来解决函数冲突问题。并提供了不同解决方案及其适用场景的讨论。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

我创建了一个类，基类中有虚拟重载函数。我想在派生类中改写基类中的虚拟重载函数。代码如下：

   
   01.
   #include < iostream.h >
  
   02.
     
   03.
   classB { 
  
   04.
   private:
  
   05.
      intnNumber; 
  
   06.
   public:
  
   07.
       virtualvoid test() { 
  
   08.
          cout <<"B::test()\n";  }  
  
   09.
       virtualvoid test(intx) {   
  
   10.
          nNumber = x;// 将传入的参数赋值给私有成员 
  
   11.
          cout <<"B::test(int x)\n";   
  
   12.
       }
  
   13.
   };
  
   14.
     
   15.
   classD : public B { 
  
   16.
   public:
  
   17.
   //test(void) 隐藏 B::test(int)
  
   18.
       virtualvoid test() { 
  
   19.
          cout <<"D::test()\n"; 
  
   20.
       }
  
   21.
   };
  
   22.
     
   23.
   voidmain(int argc, char* argv[]) 
  
   24.
   {
  
   25.
     D d;         // 派生类的实例 
  
   26.
     d.test();      // OK 
  
   27.
     d.test(17);    // 产生编译错误的代码行 
  
   28.
   }

基类中有两个重载的test函数。当我在派生类中改写其中的一个函数时，我觉得另外一个应该在派生类中继承，但编译时出现一下错误信息：

... C2660 : ''test'' :function does not take 1 parameters

在不放弃多态行为的情况下，我能不能同时重载和改写某个函数？

许多C++程序员都对这个问题感到困惑，为了解开这个惑点，有两个概念你必须要了然于心。一个是重载，一个是名字空间。从重载的视角看，你可能觉得C++应该按照你所想象的方式工作；也就是如果派生类只修改其中的一个重载函数的行为，那么另外一个应该按照通常的方式被继承。但从名字空间的角度看，当C++试图解决某个符号名时，它以由近到远的顺序进行搜索，它首先找本地变量，然后是类成员名，接着是基类名，全局变量……。一旦编译器解析了名字，它便终止解析过程。如果在不同的名字空间范围碰到同一个符号名，那么它便没有了主意。在你的代码中，一旦编译器确定名字"test"出现在类D中，那么它的名字空间就为类D。不论你调用不带参数的test也好，还是调用带一个整型参数的test(17)也好，编译器都是遵循准这个规则来解决名字问题。对于有整型参数的test(int x)函数，一旦编译器确定函数名test生存在类D中，它便终止范围探查，然后查找与参数匹配的函数。由于它没有在类D中找到带整型参数的函数，所以报错。此时编译器认为函数D::test(void)隐藏了函数B::test(int)。你可能会问，为什么要按这种方式处理？问得好。想找到答案，请参考Bjarne Stroustrup 的C++注释参考手册（Section 13.1）。简单地说，在类层次深处搜索与某个签名匹配的重载函数比不搜索更可能导致混乱。

那么如何解决上面出现的问题呢？很容易。只要在派生类中创建另一个显式调用基类的test函数即可，如：

   
   1.
   classD : public B { 
  
   2.
   public:
  
   3.
     virtualvoid test(intx) { B::test(x); } 
  
   4.
     ……
  
   5.
   };

这样，D就有了两个test函数，问题也解决了。其实这个问题还有另外一个解法：那就是在派生类中使用"using"关键字。如：

   
   1.
   classD : public B { 
  
   2.
   public:
  
   3.
       usingB::test; 
  
   4.
       // 改写test 
  
   5.
       virtualvoid test() { 
  
   6.
            cout <<"D::test()\n"; 
  
   7.
       }
  
   8.
   };

这个关键字将B::test带入类D中。它的优点是当类B扩展更多的test重载函数时，你不用再去重写类D的代码。这样省了很多事。只要你使用using关键字，那么就意味着所有重载的 B::test函数都进入类D并且得到继承。这种特性可能对于某些人来说是优点，而对于另外一些人来说是缺点，依赖于你要做什么事情。如果你想要向类D的用户隐藏某些test函数，则可以用第一种方法（显式调用基类），或者让你想要隐藏的函数成为private 或 protected类型。如果你读过Scott的书《Effective C++》，还可以用第二种方法利用using关键字巧妙地保证基类的私隐。

   
   01.
   classB { 
  
   02.
   public:
  
   03.
       func1();
  
   04.
       func2(doubled); 
  
   05.
       virtualtest(); 
  
   06.
       virtualtest(int x); 
  
   07.
   };
  
   08.
     
   09.
   // D 从B中秘密派生
  
   10.
   classD : private B { 
  
   11.
   public:
  
   12.
       // 让所有 B::test 函数为 public类型
  
   13.
       usingB::test; 
  
   14.
   };