Why class member functions shadow free functions with same name?
===

[It recently came to my attention](http://stackoverflow.com/a/11695164/1554020) that member functions **completely _shadow_** free functions with the same name when inside the class. And by completely i mean that every free function with the same name is not considered for overload resolution at all. I can understand why it's done with somwthing like this:

    void f();

    struct S
    {
        void f();
        
        void g()
        {
            f(); // calls S::f instead of ::f
        }
    };

where the functions have identical signatures, its only natural as variable scoping works the same way. But why prohibit unambigious calls where free function has different signature like this:

    void f();

    struct S
    {
        void f(int x);
        
        void g()
        {
            f(); // fails to compile attempting to call S::f, which has wrong signature
        }
    };

I am not asking how to call a _shadowed_ free function from inside the class. What i want to know is the rationale behind this design. 