thinking in c++读书笔记－－－－－－－－－继承与组合

名字隐藏：

 

class  A
... {
public :
   void func ();
   void func (int );
   float func (float);    
}
class  B:  public   class  A 
... {
public :
int func (double);

}

 在上面这段程序中，只是普通的继承，B类中，有一个函数func，这个函数将掩盖基类A中所有同名的函数，不论返回值和参数类型，都无法调用。如：

B b;

b.func(1)是错误的，只能这么调用：b.A::func(1);

这叫名字隐藏，不同与虚函数。

假设上面基类中的函数都是虚函数，则又有不同，

 

// : C15:NameHiding2.cpp
//  Virtual functions restrict overloading
#include  < iostream >
#include  < string >
using   namespace  std;
class  Base  ... {
public:
virtual int f() const ...{
cout << "Base::f() ";
return 1;
}
virtual void f(string) const ...{}
virtual void g() const ...{}
} ;
class  Derived1 :  public  Base  ... {
public:
void g() const ...{}
} ;
class  Derived2 :  public  Base  ... {
public:
// Overriding a virtual function:
int f() const ...{
cout << "Derived2::f() ";
692 Thinking in C++ www.BruceEckel.com
return 2;
}
} ;
class  Derived3 :  public  Base  ... {
public:
// Cannot change return type:
//! void f() const{ cout << "Derived3::f() ";}
} ;
class  Derived4 :  public  Base  ... {
public:
// Change argument list:
int f(int) const ...{
cout << "Derived4::f() ";
return 4;
}
} ;
int  main()  ... {
string s("hello");
Derived1 d1;
int x = d1.f();
d1.f(s);
Derived2 d2;
x = d2.f();
//! d2.f(s); // string version hidden
Derived4 d4;
x = d4.f(1);
//! x = d4.f(); // f() version hidden
//! d4.f(s); // string version hidden
Base& br = d4; // Upcast
//! br.f(1); // Derived version unavailable
br.f(); // Base version available
br.f(s); // Base version abailable
}   /**/ ///:~

 

可以看出，相同之处在于：派生类中定义的同名函数将隐藏基类中  的同名函数，但有一个限制，派生类中定义的同名函数不能改变返回值类型，只可以改变参数类型。

实际编程过程中要尽量避免这种东西，尽量避免重名，重写的虚函数要和基类中的声明完全一样。避免模糊。