Function overloading and const keyword

　　

　　

　　Predict the output of following C++ program.

 1 #include<iostream>
 2 using namespace std;
 3
 4 class Test
 5 {
 6 protected:
 7     int x;
 8 public:
 9     Test (int i):x(i)
10     {
11     }
12
13     void fun() const
14     {
15         cout << "fun() const called " << endl;
16     }
17     void fun()
18     {
19         cout << "fun() called " << endl;
20     }
21 };
22
23 int main()
24 {
25     Test t1 (10);
26     const Test t2 (20);
27     t1.fun();
28     t2.fun();
29     return 0;
30 }

　　Output: The above program compiles and runs fine, and produces following output.

　　fun() called
　　fun() const called
　　

　　The two methods ‘void fun() const’ and ‘void fun()’ have same signature except that one is const and other is not. Also, if we take a closer look at the output, we observe that, ‘const void fun()’ is called on const object and ‘void fun()’ is called on non-const object.
　　C++ allows member methods to be overloaded on the basis of const type. Overloading on the basis of const type can be useful when a function return reference or pointer. We can make one function const, that returns a const reference or const pointer, other non-const function, that returns non-const reference or pointer. See this for more details.

　　What about parameters?
　　Rules related to const parameters are interesting. Let us first take a look at following two examples. The program 1 fails in compilation, but program 2 compiles and runs fine.

 1 // PROGRAM 1 (Fails in compilation)
 2 #include<iostream>
 3 using namespace std;
 4
 5 void fun(const int i)
 6 {
 7     cout << "fun(const int) called ";
 8 }
 9 void fun(int i)
10 {
11     cout << "fun(int ) called " ;
12 }
13 int main()
14 {
15     const int i = 10;
16     fun(i);
17     return 0;
18 }

　　Output:

　　Compiler Error: redefinition of 'void fun(int)'

 1 // PROGRAM 2 (Compiles and runs fine)
 2 #include<iostream>
 3 using namespace std;
 4
 5 void fun(char *a)
 6 {
 7   cout << "non-const fun() " << a;
 8 }
 9
10 void fun(const char *a)
11 {
12   cout << "const fun() " << a;
13 }
14
15 int main()
16 {
17   const char *ptr = "GeeksforGeeks";
18   fun(ptr);
19   return 0;
20 }

　　Output:

　　const fun() GeeksforGeeks
　　

　　C++ allows functions to be overloaded on the basis of const-ness of parameters only if the const parameter is a reference or a pointer.

　　That is why the program 1 failed in compilation, but the program 2 worked fine. This rule actually makes sense. In program 1, the parameter ‘i’ is passed by value, so ‘i’ in fun() is a copy of ‘i’ in main(). Hence fun() cannot modify ‘i’ of main(). Therefore, it doesn’t matter whether ‘i’ is received as a const parameter or normal parameter. When we pass by reference or pointer, we can modify the value referred or pointed, so we can have two versions of a function, one which can modify the referred or pointed value, other which can not.

　　As an exercise, predict the output of following program.

 1 #include<iostream>
 2 using namespace std;
 3
 4 void fun(const int &i)
 5 {
 6     cout << "fun(const int &) called ";
 7 }
 8 void fun(int &i)
 9 {
10     cout << "fun(int &) called " ;
11 }
12 int main()
13 {
14     const int i = 10;
15     fun(i);
16     return 0;
17 }

　　Output：

　　fun(const int &) called

　　

　　Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

　　转载请注明：http://www.cnblogs.com/iloveyouforever/

　　2013-11-25　　22:33:28