Anruf Lambda ohne es auf eine Kennung

Question

Browsing einige Internet-Board Bindung traf ich diese kleine Herausforderung:

„Implementieren einer rekursiven anonyme Funktion in Ihrer bevorzugten Sprache“

Offensichtlich ist dies einfach ein mit std :: function/Funktionszeiger.

Was mich wirklich interessiert ist, wenn das möglich ist, ohne den Lambda an eine Kennung zu binden?

So etwas wie (die offensichtliche unendliche Rekursion zu ignorieren):

[](){ this(); }(); 

Answer 1

Natürlich in C++, rufen jede Funktion können Sie es auf eine Kennung irgendwo zu binden zu nennen, einfach zu Syntax Zwänge zurückzuführen ist. Aber wenn Sie Parameter als ausreichend ungenannt akzeptieren, dann ist es möglich, eine Version des y-Kombinators in C++ zu erstellen, die gut rekursiert, ohne "benannt" zu sein.

Nun, das ist wirklich hässlich, weil ich nicht weiß, wie man eine typedef for a recursive lambda macht. Es benutzt also nur eine Menge Missbrauch. Aber es funktioniert, und druckt FLY!!, bis es wegen Stack-Überlauf segregiert.

#include <iostream> 

typedef void(*f0)(); 
typedef void(*f)(f0); 

int main() { 
    [](f x) { 
     x((f0)x); 
    } ([](f0 x) { 
     std::cout<<"FLY!!\n"; 
     ((f)x)(x); 
    }); 
} 

Die beiden Lambda-Ausdrücke sind im Sinne unbenannte, dass weder explizit Namen überall zugeordnet ist. Das zweite Lambda ist das eigentliche Arbeitspferd, und es nennt sich im Grunde genommen das erste Lambda, um sich in Form des Parameters auf sich selbst zu beziehen.

Hier ist, wie Sie diese nutzen würde etwas „nützlich“ zu tun:

#include <iostream> 

typedef int param_t; 
typedef int ret_t; 

typedef void(*f0)(); 
typedef ret_t(*f)(f0, param_t); 

int main() { 
    /* Compute factorial recursively */ 
    std::cout << [](f x, param_t y) { 
     return x((f0)x, y); 
    } ([](f0 x, param_t y) { 
     if(y == 0) 
      return 1; 
     return y*((f)x)(x, y-1); 
    }, 10) << std::endl; 
} 

Answer 2

Sind Sie zu betrügen erlaubt?

void f(){ 
    []{ f(); }(); 
} 

Es ist rekursiv - indirekt, atleast.

Ansonsten, nein, es gibt keine Möglichkeit, auf das Lambda selbst zu verweisen, ohne ihm einen Namen zu geben.

Answer 3

Keine Kennung für Funktionen/Methoden, Nah genug oder nicht!?

struct A 
{ 
    void operator()() 
    { 
     [&]() 
     { 
      (*this)(); 
     }(); 
    } 
}; 

Um

A{}(); // Thanks MooningDuck 

Answer 4

Ich scheine mit einer Lösung meines eigenen zu haben kommen:

#include <iostream> 

int main() 
{ 
    std::cout<<"Main\n"; 
    [&](){ 
     std::cout<<"Hello!\n"; 
     (&main+13)(); 
     }(); 
} 

Erster Aufruf zu cout ist nur um zu zeigen, dass es nicht main anruft.

Ich kam mit der 13 Offset durch Versuch und Irrtum, wenn jemand erklären könnte, warum es diesen Wert wäre es toll.