Whimsy and disappointment in implicit type conversion

In C ++, if a type conversion operator or a single parameter constructor without explicit keyword is defined for a custom type (class, the compiler automatically performs implicit type conversion. This is common sense. Whether implicit conversions require rules defined in the compiler is difficult to see, but I understand that one of the meanings of "yes" should be, if no implicit type conversion is performed, the corresponding overload function cannot be found. If yes, the compiler should perform implicit type conversion.

When I saw the "delegate" mode that day, I suddenly had a whimsy and thought of using implicit type conversion to implement a very simple and elegant delegate C ++.

Generally, Class B is responsible for Class A delegation. The code is written in this way, and the constructor is omitted:

1. Class
2. {
3. Public:
4. F ();
5. };
7. Class B
8. {
9. A * pA;
10. Public:
11. F () {pa-> F ();}
12. };

However, if Class B wants to proxy many or even all public functions of Class A, repeatedly write functions such as F () {pa-> F ();} function definition is very tiring.

My thoughts at the time were:

1. # Include <iostream>
3. Using namespace STD;
5. Class
6. {
7. Public:
8. Void a_func ()
9. {
10. Cout <"A's a_func () is called .";
11. }
12. };
14. Class B
15. {
16. A * pA;
17. Public:
18. B (): Pa (new ){}
19. ~ B () {Delete Pa; Pa = 0 ;}
20. Operator A () const {return * pA ;}
21. };
24. Int main ()
25. {
26. B;
27. B. a_func ();
29. Return 0;
30. }

Theoretically, the compiler should find that Class B does not have a member function a_func, and that if implicit type conversion is performed, Class A's a_func can be called to perform implicit type conversion. In this way, the "complete" delegation is very lightweight, or the inheritance is not inherited. Of course, this is purely a kind of hack and certainly not the code style that should be recommended in practice.

Unfortunately, GCC and VC 2005 + cannot even compile the above program. This is because the compiler is not smart enough, or because I have incorrect understanding of the C ++ standard. It's a pity that when this sudden whim came, I was so excited that such code could be carried forward for a kind of metaprogramming, in this way, the concept similar to the meta table in Lua is implemented to deal with situations such as method not found.

Unfortunately, I still really want the C ++ standard to clarify the implicit type conversion rules. It is better to add this situation and some more interesting situations ~ P.s., eager to C ++ 0x .....