What is the relationship between the C ++ function pointer and the C # Delegate?

In C #, there is an application method called delegation. Its application methods and implementation functions are quite similar to the C ++ function pointers we have previously introduced. In this articleArticle.

Both the delegate and function pointer describe the method/function signature and call different implementations through a unified interface. However, the two have obvious differences. Simply put, the delegate object is the real object, and the function pointer variable is only the function entry address. For high-level applications, the flexibility and applicability of delegation are better than those of C ++ function pointers. However, for underlying applications, function pointers are irreplaceable. The following are examples of delegate type and function pointer type definitions:

1. Delegate int FN (int A, int B) // C # Delegate
2. Typedef int (* fN) (int A, int B) // C ++ function pointer

In terms of form, both the parameter list and return values are the same, but one uses the keyword delegate and the other uses the pointer symbol *. It seems that the "similar" statement is more confident, but it would be too urgent if the two are immediately given an equal sign. Let's verify the difference first:

2. // C #
4. Delegate int FN (int A, int B );
6. Class adder {
8. Private intC=0;
10. Public int add (int A, int B ){
12. Return A + B + C;
14. }
16. Public adder (INT c ){This. c= C ;}
18. }
20. Class multiplier {
22. Private intC=0;
24. Public int multiple (int A, int B ){
26. Return a * B * C;
28. }
30. Public multiplier (INT c ){This. c= C ;}
32. }
34. AdderAdder=NewAdder (1 );
36. MultiplierMultiplier=NewMultiplier (2 );
38. FNFN=Adder. Add;
40. FN (1, 2); // The result is 4
42. FN=Multiplier. Multiple;
44. FN (2, 3); // The result is 12

From aboveCodeTwo problems are described:

1. The delegate object can point to different classes of methods, as long as they comply with the delegate signature;

2. The delegate object is stateful (stored in the object to which it points). The delegate behavior is not only affected by the input parameters, but also by the status of the target object.

2. // C ++
4. Typedef int (* fN) (int A, int B );
6. Int add (int A, int B ){
8. Return A + B;
10. };
12. Int multiple (int A, int B ){
14. Return a * B;
16. };
18. Class adder {
20. Public:
22. Adder (INT c ){
24. This->CC= C;
26. }
28. Int add (int A, int B ){
30. Return A + B + C;
32. }
34. PRIVATE:
36. Int C;
38. };
40. Typedef int (adder: * FM) (int A, int B );
42. Int _ tmain (INT argc, _ tchar * argv [])
44. {
46. FNFN=Add;
48. STD: cout<< FN(1, 2)<< STD: Endl;
50. FN=Multiple;
52. STD: cout<< FN(1, 2)<< STD: Endl;
54. Adder adder (1 );
56. FMF= & Adder: Add;
58. STD: cout<<(Adder. * f) (1, 2)<< STD: Endl;
60. Return 0;
62. }

The delegate in C # is a special object that supports the () operator. This is essentially different from the C/C ++ function pointer, because the C/C ++ function pointer variable does not have the object nature, it is just a simple function entry address. The above FN can only point to the ADD and multiple common functions, and cannot point to the add method of the adder class. Because the signature of the add method of the adder class is not int (*) (int A, int B), the compiler automatically adds an implicit this pointer parameter, therefore, its signature is similar to int (*) (adder * const this, int A, int B.

If you want to direct the pointer to a member function, you need to add a type qualifier in the form of typedef int (adder: * FM) (int A, int B. Therefore, the C ++ function pointer cannot direct to different classes of methods like the C # Delegate; it does not have the State nature of the object; in use, the function pointer is not as flexible as the delegate. Therefore, when we hear the saying "delegate is similar to the C/C ++ function pointer", we should understand its similarities and differences.