[.NET]Delegates - was ist daran eigentlich so typsicher...

[Gast]

... im Unterschied zu Funktionspointern aus native C/C++?

In native C++ macht z.B. folgendes:

typedef double (*FUNC)(double x);
//...
double func (double x)
{
double y;
//...
return y;
}
//...
// Funktionspointer deklarieren und zuweisen
FUNC pfunc = &func;
//...
// Funktion über Funktionspointer aufrufen
double x = 3.14, y;
y = (*pfunc)(x);

in .NET macht man das so:

class MyClass
{
public:
delegate double FUNC(double x);
//...
double func(double x)
{
double y;
//...
return y;
}
void SomeAction()
{
// Funktionspointer deklarieren und zuweisen
MyClass::FUNC pfunc += gcnew MyClass::FUNC(this, &MyClass::func);
// Funktion über Funktionspointer aufrufen:
double x = 3.14, y;
y = pfunc(x);
}
};

Die .NET-Lösung soll als im Unterschied zur nativen C++ Lösung typsicher gelten. Ich sehe aber wirklich nicht, wo da ein mehr an Typsicherheit sein soll?

[Novox]

Pointers in C++ are just integers that are a reference to a point in
memory which can be coerced into any other pointer type. This is not the
case in .NET. In .NET, references actually have a type associated with
them, and assignments to that are checked for validity (in other words, you
can not just cast around it).

Quelle: http://www.thescripts.com/forum/thread214122.html

[Expandable]

Quelle: http://www.thescripts.com/forum/thread214122.html

Mit anderen Worten: Der einzige Unterschied ist, dass .NET den Programmierer vor sich selbst schützt? Naja... man könnte auch sagen, die Flexibilität wird eingeschränkt (und nein, ich habe nichts gegen .NET, finde es sogar sehr gut. Wollte ich nur mal loswerden) ;)

[Gast]

dann geht es also allein darum, daß der native C++ Funktionspointer in einen beliebigen anderen Pointertyp (z.B. in einen Pointer auf eine andere Art von Funktion) gecastet werden kann?

[Kabelsalat]

Die .NET-Lösung soll als im Unterschied zur nativen C++ Lösung typsicher gelten. Ich sehe aber wirklich nicht, wo da ein mehr an Typsicherheit sein soll?

Die C(++) Lösung ist eben ganz und garnicht typsicher (Gründe bereits erwähnt) und außerdem kann man den Funktionspointer auch direkt verändern (z.B. inkrementieren). "Richtige" Pointerarithmetik ist aber auch in C# in entsprechenden unsafe Bereichen möglich, aber damit bewegen wir uns wieder weg von den Funktionspointern.

[Expandable]

Die C(++) Lösung ist eben ganz und garnicht typsicher (Gründe bereits erwähnt) und außerdem kann man den Funktionspointer auch direkt verändern (z.B. inkrementieren). "Richtige" Pointerarithmetik ist aber auch in C# in entsprechenden unsafe Bereichen möglich, aber damit bewegen wir uns wieder weg von den Funktionspointern.

Aber das ist doch alles nur ein Problem, wenn der Programmierer schlichtweg zu blöd ist, oder?

[tokugawa]

Aber das ist doch alles nur ein Problem, wenn der Programmierer schlichtweg zu blöd ist, oder?

Nein.

Selbst wenn Programmierer "gut" sind, ist gutes Design das Flüchtigkeitsfehler verhindert (und die passieren sogar den größten Programmiergenies) ein extrem hilfreiche Sache. Vor allem wenn man im Team entwickelt.

[maximAL]

Aber das ist doch alles nur ein Problem, wenn der Programmierer schlichtweg zu blöd ist, oder?
zu blöd sind meisstens gerade die, die glauben, sie hätten solche absicherungen eh nicht nötig.
die selben leute, die keine konstante benutzen, weil sie ja nicht so blöd sind einen wert zu ändern, der nicht geändert werden soll,
die selben leute, die globale variablen benutzen, weil sie ja nicht so blöd sind, nachträglich ihr design ändern zu müssen,
die selben leute, die keine assertions/exceptions benutzen, weil sie ja nicht so blöd sind, fehlerhaften code zu schreiben,
die selben leute, die keine kommentare schreiben, weil sie ja nicht zu blöd sind, ihren eigenen code zu lesen.

[Expandable]

zu blöd sind meisstens gerade die, die glauben, sie hätten solche absicherungen eh nicht nötig.
die selben leute, die keine konstante benutzen, weil sie ja nicht so blöd sind einen wert zu ändern, der nicht geändert werden soll,
die selben leute, die globale variablen benutzen, weil sie ja nicht so blöd sind, nachträglich ihr design ändern zu müssen,
die selben leute, die keine assertions/exceptions benutzen, weil sie ja nicht so blöd sind, fehlerhaften code zu schreiben,
die selben leute, die keine kommentare schreiben, weil sie ja nicht zu blöd sind, ihren eigenen code zu lesen.

Darum geht's nicht. Abgesehen davon soll der neue C++-Standard doch auch typsichere Funktionspointer enthalten, wenn ich mich recht entsinne.