How are delegates in C# better than function pointers in C/C++?

Question

The delegates in C# offer similar functionality as function pointers in C. I heard someone saying \"C# delegates are actually better than function pointers in C\". How come?

Answer 1

Pointers can always point to the wrong place :) I.e it can point to a non-function or an arbitrary place in memory.

But in terms of functionality, function pointers can do anything that delegates can do.

Answer 2

"Better" is subjective -- but the main differences are:

• Type safety. A delegate is not only guaranteed to refer to a valid method, it is guaranteed to refer to a method with the correct signature.
• It's a bound method pointer -- that is, the delegate can point to a specific object on which to call the delegate. Thus, an Action<string> delegate could refer to alice.GetName or bob.GetName rather than just Person.GetName. This might be similar to C++ "pointer to member" -- I'm not sure.

In addition, the C# language supports closures through delegates to anonymous methods and lambda expressions -- i.e. capturing local variables of the declaring procedure, which delegate can reference when it later gets executed. This isn't strictly speaking a feature of delegates -- it's enabled by the C# compiler doing some magic on anonymous methods and lambda expressions -- but it's still worth mentioning because it enables a lot of the functional idioms in C#.

EDIT: As CWF notes in comments, another possible advantage of C# delegates is that the delegate type declarations are easier for many people to read. This may be a matter of familiarity and experience, of course.

Answer 3

One thing that a delegate provides that a C/C++ function pointer doesn't is type safety. That is, in C/C++, you can shove a function pointer into a function pointer variable declared with the wrong function signature (or even an int a double or worse with appropriate coaxing), and the compiler will be happy to produce code that calls the function completely incorrectly. In C#, the type signature of the function must match the type signature of the delegate and also the way the delegate is ultimately called.

Answer 4

Many people refer to C# delegates as more "type-safe" than C++ function pointers and I really find it misleading. In reality they are no more type-safe that C++'s function pointers are. An example C++ code (compiled by MSVS 2005 SP1):

typedef int (*pfn) (int);

int f (int) {
   return 0;
}

double d (int) {
   return 1;
}

int main()
{
   pfn p=f; // OK
   p=d; // error C2440: '=' : cannot convert from 'double (__cdecl *)(int)' to 'pfn'
   p=(pfn)d;
}

So as is seen from the example above unless one uses "dirty hacks" to "shut up" the compiler the type mismatch is easily detected and the compiler's message is easy to understand. So that is type-safety as I understand it.

Regarding the "boundness" of the member function pointers. Indeed, in C++ pointer-to-member is not bound, the member function pointer has to be applied to a type variable that matches the member pointer's signature. An example:

class A {
public:

   int f (int) {
      return 2;
   }

};

typedef int (A::*pmfn) (int);

int main()
{
   pmfn p=&(A::f);
   // Now call it.
   A *a=new A;
   (a->*p)(0); // Calls A::f
}

Again, everything is perfectly type safe.