C++中的成员函数是如何实现的？

Question

I read somewhere that member functions are just like normal function in C++ but with an additional implicit this argument.

So I thought this program would be unable to distinguish between two func . But the program ran successfully. So was the statement stated above is wrong?

#include <iostream>

class MyCls {
    public:
    void func(int i) {
        std::cout << "Member" << i << std::endl;
    }
};

void func(MyCls m, int i) {
    std::cout << "Outside" << i << std::endl;
}

int main() {
    MyCls m;
    // Thought both would have same signature void func(MyCls, int). But program compiled.
    m.func(4);
    func(m, 5);
    return 0;

Answer 1

Looking at this site , just to pick a tutorial among others if you google the exact same question, you'll find this

Member functions are the functions, which have their declaration inside the class definition and works on the data members of the class. The definition of member functions can be inside or outside the definition of class.

If the member function is defined inside the class definition it can be defined directly, but if its defined outside the class, then we have to use the scope resolution:: operator along with class name alng with function name.

As you can see, a member function is a function which belongs to an instance of a class, having access to object's members and to pointer-to-self-object this

Of course, in your example you're accessing

m.func(4)

which is member function defined inside object instance of class MyCls whilst writing

func(m, 5);

you're passing an object instance of class MyCls to the function in the global scope (by value which is a thing you should study about as well if it's the way you want to act as) without using it, just to verify the coherence of your thoughts.

I suggest you to start with a good C++ tutorial to learn about the language's OOP paradigm.

Answer 2

functions have different signatures, it can be seen inside list symbols of object file generated:

$ g++ -c my.cpp -o my.o
$ nm -s my.o

                 U __cxa_atexit
                 U __dso_handle
                 U _GLOBAL_OFFSET_TABLE_
00000000000000c7 t _GLOBAL__sub_I__Z4func5MyClsi
0000000000000046 T main
000000000000007e t _Z41__static_initialization_and_destruction_0ii
0000000000000000 T _Z4func5MyClsi
0000000000000000 W _ZN5MyCls4funcEi
                 U _ZNSolsEi
                 U _ZNSolsEPFRSoS_E
                 U _ZNSt8ios_base4InitC1Ev
                 U _ZNSt8ios_base4InitD1Ev
                 U _ZSt4cout
                 U _ZSt4endlIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_
0000000000000000 r _ZStL19piecewise_construct
0000000000000000 b _ZStL8__ioinit
                 U _ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc

so answering to your question, it is your second assumption which is wrong: sure, compilers always can distinguish normal functions from class members, by mechanism similar to namespaces (i guess).