¿Cómo son mejores los delegados en C# que los punteros de función en C/C++?

Question

Los delegados en C# ofrecen una funcionalidad similar a los punteros de función en C. Escuché a alguien decir "los delegados de C# en realidad son mejores que los punteros de función en C". ¿Cómo? Por favor explique con un ejemplo.

Answer 1

"mejor" es subjetiva - pero las principales diferencias son:

• Seguridad de tipos. No solo se garantiza que un delegado se refiera a un método válido, sino que se garantiza que se referirá a un método con la firma correcta.
• Es un puntero de método enlazado, es decir, el delegado puede señalar a un objeto específico al que llamar al delegado. Por lo tanto, un delegado Action<string> podría consultar alice.GetName o bob.GetName en lugar de solo Person.GetName. Este podría ser ser similar a C++ "puntero a miembro" - No estoy seguro.

Además, el lenguaje C# admite cierres a través de delegados a métodos anónimos y expresiones lambda, es decir, capturar variables locales del procedimiento de declaración, que el delegado puede consultar cuando se ejecute posteriormente. Esto no es estrictamente una característica de los delegados, está habilitado por el compilador de C# que hace algo de magia en métodos anónimos y expresiones lambda, pero vale la pena mencionarlo porque habilita muchos de los modismos funcionales en C#.

EDIT: Como señala CWF en los comentarios, otra posible ventaja de delegados C# es que las declaraciones de tipo delegado son más fáciles de leer para mucha gente. Esto puede ser una cuestión de familiaridad y experiencia, por supuesto.

Answer 2

Los punteros siempre pueden señalar el lugar equivocado :) Es decir, puede apuntar a un lugar no funcional o arbitrario en la memoria.

Pero en términos de funcionalidad, los punteros a las funciones pueden hacer cualquier cosa que los delegados puedan hacer.

Answer 3

Una cosa que un delegado proporciona que un puntero de función C/C++ no es tipo seguridad. Es decir, en C/C++, puede insertar un puntero de función en una variable de puntero de función declarada con la firma de función incorrecta (o incluso una int a doble o peor con un engatillado apropiado), y el compilador estará feliz de producir el código que llama la función completamente incorrecta. En C#, la firma de tipo de la función debe coincidir con la firma de tipo del delegado y también la forma en que finalmente se llama al delegado.

Answer 4

Muchas personas se refieren a delegados de C# como más "seguro en cuanto a tipos" que los punteros de función de C++ y realmente me parece engañoso. En realidad, no son más seguros con respecto a los tipos que los punteros de función de C++. Un ejemplo código C++ (compilado por 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; 
} 

Así como se ve en el ejemplo anterior si no se utiliza "trucos sucios" que "se calle" el compilador es fácil de detectar el tipo de desajuste y el compilador de el mensaje es fácil de entender Entonces eso es seguridad de tipo tal como lo entiendo.

En cuanto a la "encuadernación" de los punteros de funciones miembro. De hecho, en C++ puntero-a-miembro no está vinculado, el puntero de función miembro debe aplicarse a una variable de tipo que coincida con la firma del puntero miembro. Un ejemplo:

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 
} 

Nuevamente, todo es perfectamente seguro.