为什么不允许成员函数和非成员函数之间的函数重载？

Question

In the following code:

void overload() {}
struct Struct {
    void overload(int arg1) {}
    void member() {
        overload(1); //compiles
        overload(); //error: too few arguments [...] did you mean '::overloaded'?
    }
};

If I change struct to namespace I get similar results, just with a slightly different error message.

Why can the compiler not select the non-member function via operator overloading when there is a member function with the same name?

For reference, all of the following cases work as expected:

• choosing between two non-members from a non-member (obviously)
• choosing between two members from a member
• choosing between two non-members from a member

Answer 1

You're mostly asking why so rather than saying "because the language says so", lets show an example where your suggestion causes everything to fail.

Suppose I have a handy class in my github repo:

struct HandyClass {
    void display(short c) {
        std::cout << c;
    }
    void doStuff() {
        display(3);
    }
};

And then some other developer in a different github repro makes a handy set of display functions:

void display(double v) {
    showWindowsPopup("Your score was %f", v);
}
void display(int v) {
    showWindowsPopup("Your score was %d", v);
}

You download both repros, and suddenly, HandyClass doesn't work right anymore:

#include "displays.h"
#include "handyclass.h"

int main() {
    HandyClass a;
    a.doStuff(); //Why does this show a windows popup!?!?
}

Because you included the display headers first, then display(3) matched to ::display(int) instead of ::HandyClass::display(short) , because 3 is an int . And much sadness occurs.

But with the official C++ lookup rules, this doesn't happen. Since my class has display functions, it will ignore functions outside the class, to prevent mistakes, so that HandyClass always does the same thing for everyone.

Answer 2

Because the name overload in global scope can't be found by name lookup , it's hidden by Struct::overload . It has no chance to participate in overload resolution which happens later.

(emphasis mine)

name lookup examines the scopes as described below, until it finds at least one declaration of any kind, at which time the lookup stops and no further scopes are examined .