基类和派生类之间的同名函数，存在重载吗？

下面有关派生类与基类中存在同名函数fn：

class A
{
public:
    void fn()
    {}

    void fn(int a)
    {}
};

class B : public A
{
public:
    void fn()
    {}
};

int main()
{
    B b;
    b.fn(3);
    return 0;
}

他的疑问是：

 1、以上代码编译为什么不能通过？ （问题在第21行，编译器会报怨说，B中，并不存在fn(int)的函数）。

 2、编译器这样做（即不允许通过这样的代码）的好处是什么?

 

相信这是一个非常之普遍的问题了，在众多经典的C++书籍中，都会将之列为一个重要C++问题，详细地深入地讲解。我这里仅能简单回答，可能对有同样疑问的同学，有个快速了解的作用。由于出差在外，非常不方便，回答问题时既不能详细调试，也不能做必要的查经求典的动作（手头没书），犯错的地方，请大家指正，我会及时修订。

回答如下：

你涉及到一个C++中的重要的知识点。即：同名函数的重载动作，只发生在自由函数（即非成员），及同一个class/struct内部的函数之间。而不能跨越基类和派生类。当派生类写一个和基类同名（无论参数列表相同或不相同）的函数时，此时发生的动作叫“覆盖”。覆盖的意思，就是基类的同名函数，在派生类内，将变得无法直接调用（但可以间接调用）。

首先，我们还是针对问题的本质，简化一下代码，抛弃无直接相关的枝节。

struct A
{
    void foo(int d)
    {
        cout << "A::foo - int" << endl;
        cout << d << endl;
    }
};

struct B : public A
{
    void foo(double d) //覆盖了A::foo(int d);
    {
        cout << "B::foo - double" << endl;
        cout << d << endl;
    }
};

int main()
{
    A a;
    a.foo(10);

    B b;
    b.foo(10.2);
    b.foo(2); //调用的仍然是B::foo，虽然2明显是个整数

    return 0;
}

以上代码，运行之后输出结果大致如下：（注释为后加内容）
A::foo - int
10
B::foo - double
10.2
B::foo - double //调用的仍然是B::foo，虽然2明显是个整数
2

那么，要如何才能调用基类的foo(int )呢？

方法有两种，其一为“临时法”：

B b;
b.A::foo(2); //显式调用A范围内的foo

其二就该叫“终身法”，哈哈这名字又是我瞎起的，更好的叫法，应叫“引狼入室法”，别掰了。回忆一下 namespace 的三种用法，其中一种称为“using declaration/使用声明”， 这里可以用上类似的代码（很多情况下，class/struct域，和一个namespace有相同的功能）。请看代码：
 

struct B : public A
{
    using A::foo; //通过“使用声明”，引入了A::foo……

    void foo(double d)
    {
        cout << "B::foo - double" << endl;
        cout << d << endl;
    }
};

现在要调用时：

int main(void)
{
   B b;

   b.A::foo(3); //调用的……当然是A::foo(int)
   b.foo(2);    //调用的……也是A::foo(int)

   b.foo(10.234); //调用的……B::foo(double)

   return 0;
}

接下回答“编译器这样做的好处是什么?”

这是为了避免“非恶意性的错误”。这也是C++语言设计中的一个重要原则：语法规则，会尽量让程序员避免“无意的错误”，但并不去管“有意，恶意，不怀好意的错误”（点击看本站一此类例子）。

以A，B代码为例，想像一下，如果我是A的作者，你是B的作者。

由于foo并不是“virtual/虚”函数，所以二者之间可能是各写各的。如果一开始我没有在A内写那个foo(int)函数，而你因为需要，在B中写了一个foo(double)函数，并且用起来很爽----因为此时基类中没有同名函数，所以你无论写 foo(2)也好，还是写foo(2.0)也好，由于int 到 double的转换是安全的，所以，两次都非常爽地调用了B自己的foo(double) 。通常这也是我们所要的。

接着有一天，作为开发小组成员，我在修改A时，我觉得需要一个 void foo(int)；于是我在A中加了这个函数。并且由于它不是virtual，最主要是： 由于我是基类的作者，我哪管得了天下到底有几个人派生了我的A类呢？ 所以我才懒得告诉你A类中多了一个很普通的函数。但现在情况如何呢？如果按派生类和基类的普通同名函数也可以构成重载关系，完了完了，当你拿到A的新版，重新编译项目，一切正常，编译器不报任何错，可是你前面所说的那段代码却突然改为调用基类的那个，我刚刚写的同名函数，这还了得！

通常，基类的作者，都是比较牛逼的人，为什么？因为他肩负着更多的责任。当一个类，以“基类”的形式提供出去以后，通常，它就不应该——有同学抢话说：“它就不应该再修改”——那倒不是（我们又不是在写COM组件），基类也要发展，也有版本升级，否则类库如何取得进步？ 正确要求是：通常，它所做的改动，都应该是向前兼容的。即基类的修改，可以为派生类提供更多的新功能，但不应该影响了派生类原来已有的功能。在此要求下，如果C++的在本例中的规则是：写基类的人只是根据自己需要，写了一个普普通通的成员函数，结果就造成了派生类的原有行为被偷偷地修改，那这也太为难基类作者，他最终会每写一个函数，都使劲猜测会不会存在一个亚洲的，美洲的，南极大陆上的某个派生类的作者，在过去，或现在，或将来的时间写的某个函数正好同名，这太累了！基类的作者再牛，但你也不该把他逼到这份上啊！

C++之父是英明的！OH Yeah~~~