We know that C + + is very important: 1. Global function, 2. Ordinary member function, 3. Static member function.  

The overloads of member functions in a class are as follows:

1. Overload of constructor.

2. Overload of common member function.

3. Overload of static member function.

Example:

 1 #include <stdio.h>
 2 
 3 class Test
 4 {
 5     int i;
 6 public:
 7     Test()
 8     {
 9         printf("Test::Test()\n");
10         this->i = 0;
11     }
12     
13     Test(int i)
14     {
15         printf("Test::Test(int i)\n");
16         this->i = i;
17     }
18     
19     Test(const Test& obj)  // Among the three constructors, there are also overloads, which are copy constructors;
20     {
21         printf("Test(const Test& obj)\n");
22         this->i = obj.i;
23     }
24     
25     static void func()
26     {
27         printf("void Test::func()\n");
28     }
29     
30     void func(int i)  // And the static member functions above constitute an overload;
31     {
32         printf("void Test::func(int i), i = %d\n", i);
33     }
34     
35     int getI()
36     {
37         return i;
38     }
39 };
40 
41 void func()
42 {
43     printf("void func()\n");
44 }
45 
46 void func(int i)
47 {
48     printf("void func(int i), i = %d\n", i);
49 }
50 
51 int main()
52 {
53     func();
54     func(1);
55     
56     Test t;        // Test::Test()；
57     Test t1(1);    // Test::Test(int i)；
58     Test t2(t1);   // Test(const Test& obj)；
59     
60     func();        // void func()；
61     Test::func();  // void Test::func()；
62     
63     func(2);       // void func(int i), i = 2；
64     t1.func(2);    // void Test::func(int i), i = 2；
65     t1.func();     // void Test::func()；
66     
67     return 0;
68 }

Be careful:

The essence of the three functions is different.

Overload can be formed between normal member functions and static member functions.

Normal member functions and static member functions are in the same scope (not memory class sensitive).

Class member functions and global functions cannot form overloads and are not in the same scope.

Conclusion:

1. Class member functions can be overloaded;

2. Overload must occur in the same scope;

3. Global function and member function can't form overload relation;

4. The significance of overloading is to extend existing functions;