Wie kommt es Zeiger auf eine Funktion ohne dereferencing genannt werden?

Question

Ich habe eine seltsame typedef-Anweisung in einem C ++ Programm, erzeugt durch Py ++.

double radius(int);  // function to be wrapped
typedef double (*radius_function_type)(int);    
bp::def("radius", radius_function_type(&radius));   // bp::def is a function for wrapping

Was dachte ich, ist so weit aus, dass die oben typedef statemnt nicht von der Art ist, die meisten von uns sind vertraut mit,

typedef complex_type simple_alias;

Es ist vielmehr ein Weg, Zeiger auf eine Funktion zu deklarieren, die int als Argument verwendet und Doppel (gleiche wie der Prototyp). So jetzt meine Frage ist, dass, wie kommen Zeiger auf eine Funktion (ohne dereferencing) sein Namen mit der Adresse einer Funktion als Argument? Dies ist auch nicht mit dem Prototyp übereinstimmen. Jemand bitte erklären!

Answer 1

Ihre Frage ist verwirrend. Sind Sie fragen, was das bedeutet:

radius_function_type(&radius)"

Dies ist nur ein C ++ Typumwandlung, ein bisschen wie:

radius (int (42));

aber da Radius ist bereits vom Typ radius_function_type dann können Sie genauso einfach tun:

bp::def("radius", radius);

aber wie dieser Code ist, erzeugt durch Py ++, ist es wahrscheinlich, besonders vorsichtig mit dem Ausgang zu sein.

Answer 2

Es ist nicht eine Funktion Zeigervariable deklariert aber einen Funktionszeiger TYPEDEF radius_function_type genannt. radius_function_type(&radius) ist nur ein (redundant) abgegeben für die Funktion Zeiger selbst. (Die unären & Adressoperator ist auch überflüssig;. Für eine Funktion, radius und &radius sind die gleiche Sache)

Auf einem niedrigen Niveau, ruft eine Funktion nur die Argumente irgendwo platzieren entsprechend der zugrunde liegenden Aufrufkonvention (in der Regel auf dem Stapel) und dann auf eine Speicheradresse zu springen. So kann der Compiler mit nur einem Zeiger eine Funktion aufrufen, wenn sie die Funktion Zeigertyp (Funktionssignatur) und den Zeigerwert selbst kennt.

Answer 3

Nun ja ... Es ist ein bisschen ähnlich, wie Arrays auf Zeiger bezogen, in C und C ++. Der Name einer Funktion ist im Grunde ein Zeiger, auch. Unter diesem Gesichtspunkt ist es nicht allzu überraschend, dass eine Definition gegeben:

int foo(int a, int b)
{
  return a + b;
}

Sie können den Anruf tun, entweder direkt, durch den Zeiger, der den Namen der Funktion lautet:

foo(1, 2);

oder von diesem Wert in einem separaten Variable zu speichern, die als ein Zeiger deklariert werden müssen:

int (*pointer)(int, int) = foo;
pointer(1, 2);

In diesem Fall können wir durch die Zeigervariable direkt anrufen, und es gibt auch keine Notwendigkeit, explizit „nehmen Sie die Adresse“ die Funktion von &foo zu schreiben.

Answer 4

Dereferenzieren (in Art und Weise denken Sie) eine Funktion Zeiger bedeutet: a. CODE Speicher zugreifen, da es ein Datenspeicher sein würde

Funktionszeiger ist wohl auf diese Weise nicht dereferenziert werden. Stattdessen sie aufgerufen wird.

würde ich einen Namen „dereferenzieren“ Seite an Seite mit „Anruf“ verwenden. Es ist in Ordnung.

Wie dem auch sei: C ist so ausgelegt, dass beide Funktionsnamen Identifikator sowie variable Haltefunktion des Zeigers bedeuten das gleiche: Adresse Speicher CODE. Und es ermöglicht durch die Verwendung call () Syntax entweder auf einer Kennung oder Variable auf diesen Speicher zu springen.

Answer 5

Funktionszeiger sind im Grunde die Adresse der Funktion, die aufgerufen werden muss. So rufen Sie wies die Funktion durch einen Funktionszeiger, können Sie den Funktionszeiger betrachten, als ob es der Name der Funktion waren, die Sie anrufen möchten. Der Akt der nannte es selbst führt die dereferenzieren; gibt es keine Notwendigkeit für explizite Dereferenzierung.

Funktionszeiger Syntax wie Zeiger aussehen kann (mit & und *) oder das kann auch weggelassen werden. Wie @unwind bereits wies darauf hin, ist es ähnlich, wie Arrays behandelt werden, wo nackte Array ähnelt Zeiger und optional können Sie das Array mit & bekommen die Adresse Präfix.