Return only functions of different types, how to implement overloading in C + +?

C + + supports function overloading, so-called overloads are within the same namespace, function names are the same, functions with different parameters (number of arguments or different parameter types) can coexist. However, if the parameters and function names are the same, the compiler will not overload the error. But in reality, sometimes it just needs to return a different type of function, and in this case C + + does not support overloading, such as:

[CPP]View PlainCopy

2. typedef struct Tdata {
4. int A;
6. int b;
8. } Tdata;
12. Class CTest {
14. Public
16. Tdata &getdata ()
18. {
20. return data;
22. }
24. Const Tdata &getdata ()
26. {
28. return data;
30. }
32. Private
34. Tdata data;
36. };

When you need to read data only, call the const tdata &getdata (), call Tdata &getdata () when the data needs to be changed, and now because C + + does not support this situation, then we can only take a compromise, the first method is, Tdata &getdata () is used in both reading and writing, which destroys the program's original intent in places where only the reading is needed; the second approach is to call the Const Tdata &getdata () in a read-only place, so that, where it needs to be written, You have to force type conversions, such as:

[HTML]View PlainCopy

1. CTest test;
2. Tdata *pData = (Tdata *) &test.getdata ();

As above, it is better to convert the data into the form of a pointer so that it can be modified in a way that is relatively the first practice. So is there a way to Tdata &getdata () and const tdata &getdata (), like a function overload, to coexist at the same time? The answer is yes, here's a way to bypass the compiler's limitations, such as:

[HTML]View PlainCopy

1. #define  GET_DATA ()  \  
2.      public:\  
3.     tdata &getdata ()  {  return data; } \  
4.     const TData & GetData ()  const { return data; }  
5.   
6. typedef struct tdata {  
7.     int a;   
8.     int b;  
9. } tdata;   
10.   
11. CLASS CTEST {  
12.      get_data ()   
13. PRIVATE:  
14.     tdata  data;  
15. };  

As above through the way of macro definition, so that you can bypass the compiler check, to achieve the coexistence of two situations, the following look at the use of examples, as follows:

[HTML]View PlainCopy

2. int main (int argc, char *argv[])
4. {
6. Qapplication app (argc, argv);
8. CTest test;
10. /* Write */
12. Tdata &data = test.getdata ();
14. data.a = 1;
16. data.b = 2;
18. /* Read */
20. Const Tdata &data1 = test.getdata ();
22. Qdebug () << data1.a << data1.b;
24. return App.exec ();
26. }

Isn't it cool, then let's see if writing and reading are really two functions, or a function that looks at the disassembly of the above code, as follows:

[HTML]View PlainCopy

2. CTest test;
4. Tdata &data = test.getdata ();
6. 0x004013e5 <+43;: lea-0x24 (%EBP),%eax
8. 0x004013e8 <+46;: mov%eax, (%ESP)
10. 0x004013eb <+49: Call 0x406440 <_zn5ctest7getdataev>
12. 0x004013f0 <+54;: mov%eax,-0x10 (%EBP)
16. DATA.A = 1;
18. 0x004013f3 <+57;: mov-0x10 (%EBP),%eax
20. 0x004013f6 <+60;: Movl $0x1, (%eax)
24. DATA.B = 2;
26. 0X004013FC <+66;: mov-0x10 (%EBP),%eax
28. 0X004013FF <+69;: Movl $0x2,0x4 (%eax)
32. Const Tdata &data1 = test.getdata ();
34. 0x00401406 <+76;: lea-0x24 (%EBP),%eax
36. 0x00401409 <+79;: mov%eax, (%ESP)
38. 0x0040140c <+82: Call 0x406440 <_zn5ctest7getdataev>
40. 0x00401411 <+87;: mov%eax,-0xc (%EBP)

From the disassembly above we see that the functions of the two calls are the same, all 0x406440 <_zn5ctest7getdataev> This is left to the reader to solve? Welcome everyone to actively answer?

http://blog.csdn.net/rabinsong/article/details/9708529

Return only functions of different types, how to implement overloading in C + +?