Kann ich eine Funktion deklarieren, die Zeiger auf sich selbst als Argument nehmen kann?

Question

Beim Lesen einer Frage im Stackoverflow habe ich mich gefragt, ob es möglich ist, eine Funktion zu deklarieren, die einen Zeiger auf sich selbst nimmt. I.e.

foo(foo); 

Die einfachste Idee auf eine andere Funktion Zeiger Gießen (kann nicht gegossen void*, da es kleiner sein kann), so die Funktionsdeklaration: solche Erklärung von foo, für die folgende wäre richtig zu machen sieht wie folgt aus:

void foo(void (*)()); 

Während das in C OK ist (und wird mit dem Gießen in C++ arbeiten), frage ich mich, ob es ohne eine solche harte „umdeuten“ Gießen oder verlieren Typinformationen durchgeführt werden kann.

Mit anderen Worten, ich möchte folgende Erklärung ab:

void foo(void (*)(void (*)(void (*) (...)))); 

aber natürlich sind unbegrenzt Erklärungen unmöglich. Naive typedef Ing hilft auch nicht.

C++ - Vorlagen sind willkommen, auch wenn sie den aufrufenden Code (foo(foo)) etwas weniger prägnant aussehen lassen, aber immer noch endlich.

C-style Antworten, die zeigen, wie man Typinformationen ohne Casting oder andere Tricks dieser Art fallen lassen kann, sind natürlich interessant, werden aber nicht akzeptiert.

Answer 1

Generell stimme ich mit Dario überein - dies auf Typenebene scheint unmöglich.

Aber Sie können Klassen verwenden ("Strategie-Muster"):

class A { 
    void evil(A a) {  // a pointer to A is ok too 
    } 
}; 

Sie können sogar operator() hinzufügen:

void operator()(A a) { return evil(a); } 

Im Allgemeinen sind solche Dinge besser in FP Sprachen erfolgen. Haskell-Version ist einfach:

data Evil = Evil (Evil -> Integer) 

Dieses verwendet einen Wrapper (Evil), die mit einer Klasse entspricht.

Aus dem Frager: was diese Antwort fehlte, war die Fähigkeit, mehrere verschiedene Funktionen als ein Argument von einem von ihnen zu übergeben. Dies kann entweder dadurch gelöst werden, dass evil() virtuell gemacht wird oder indem explizit im Objekt ein Funktionszeiger gespeichert wird, der es implementiert (was im Wesentlichen derselbe ist).

Mit dieser Klarstellung ist die Antwort gut genug, um akzeptiert zu werden.

Answer 2

Offensichtlich nicht - siehe this thread. Der hier benötigte Typ wäre immer unendlich.

Answer 3

Dies ist eine vollkommen gültige Verwendung von void *.

Answer 4

Wenn eine Funktion sich selbst als Argument nehmen könnte, könnte sie anonyme Rekursion durchführen, indem sie sich selbst aufruft. Aber Rekursion ist unmöglich im einfach typisierten Lambda-Kalkül (das ist im Grunde, was Sie hier haben, mit Funktionstypen).Sie müssen einen Fixpunktkombinator implementieren, der rekursive Funktionen oder rekursive Typen verwendet, um eine anonyme Rekursion durchzuführen.

Answer 5

Ein verwandtes Problem gibt einen Funktionszeiger des gleichen Typs zurück. Es kommt bei der Implementierung von State Machines auf, so dass es seine eigene entry in the C FAQ bekam.

Die gleichen Problemumgehungen können auf Ihr Problem angewendet werden.

Answer 6

Ich glaube nicht, dass Sie eine Funktion haben können, die sich als ein Argument in C++ ohne irgendeine Art von Trickery nehmen kann, wie Ihre Funktion in eine Klasse zu bringen und die Funktion diese Klasse als Argument zu nehmen.

Eine andere Möglichkeit, die möglich ist, sobald der neue C++ - Standard auftrifft, ist die Verwendung von Lambdas und die Erfassung des Lambda selbst. Ich denke, es würde so etwas gehen:

auto recursive_lambda = [&recursive_lambda] { recursive_lambda(); }; 

Seien Sie gewarnt, dass eine solche Aussage in jedem Compiler, der lambdas unterstützt, völlig ungetestet ist. Ihre Laufleistung kann variieren.

Answer 7

JA

Es ist eine Variante von "Can you write a function that returns a pointer to itself?", mit der Ausnahme, dass in Ihrem Fall wird der Funktionstyp rekursiv als argumkent, nicht als Rückgabetyp. Die Antwort von Herb Sutters ist jedoch wiederverwendbar: Umschließen Sie den Zeiger in einer nach vorne deklarierten Proxy-Klasse.

Answer 8

Ein weiterer schmutziger Trick.

void Foo(...) 
{ 
} 

int main() 
{ 
Foo(Foo); 
} 

Das obige Programm kompiliert ohne Fehler. Aber es ist nicht rekursiv. Folgende modifizierte Funktion ist rekursive Version mit einem Begrenzer.

#define RECURSIVE_DEPTH (5) 

typedef void (*FooType)(int, ...); 

void Foo(int Depth, ...) 
{ 
void (*This)(int, ...); 

va_list Arguments; 

va_start(Arguments, Depth); 

if(Depth) 
{ 
    This = va_arg(Arguments, FooType); 

    This(Depth - 1, This); 
} 

va_end (Arguments); 
} 

int main() 
{ 
Foo(RECURSIVE_DEPTH, Foo); 
}