Tail-Rekursion in C++

Einem einfachen tail-rekursive Funktion:

unsigned int f( unsigned int a ) {
   if ( a == 0 ) {
      return a;
   }
   return f( a - 1 );   //tail recursion
}

Tail recursion ist im Grunde, wenn:

• es gibt nur einen einzigen rekursiven Aufruf
• dieser Aufruf ist die Letzte Anweisung in der Funktion

Und es ist nicht "besser", außer in dem Sinne, dass ein guter compiler kann das entfernen der Rekursion transformiert es in eine Schleife. Dies kann schneller sein, und wird sicherlich sparen auf stack-Nutzung. Der GCC-compiler kann dies tun-Optimierung.

InformationsquelleAutor der Antwort

Tail-Rekursion ist ein Spezialfall einer tail-call. Eine tail-call ist, wo der compiler sehen kann, dass es keine Operationen, die getan werden müssen, nach der Rückkehr von einer aufgerufenen Funktion, im wesentlichen drehen die aufgerufene Funktion die Rückkehr in seine eigene. Der compiler kann oft noch ein paar stack-Update-Operationen und dann springen (lieber als anrufen), um die Adresse der ersten Anweisung der aufgerufenen Funktion.

Einer der großen Dinge über diese neben der Ausschaltung einige Anrufe zurück ist, dass Sie auch reduzieren auf die stack-Nutzung. Auf manchen Plattformen im OS-code der stack kann Recht begrenzt zu sein und auf modernen Maschinen wie die x86-CPUs in unseren desktops Verringerung der stack-Nutzung, wie dies verbessert die Daten-cache-performance.

Tail recursion ist, wo die Funktion ist die gleiche wie die aufrufende Funktion. Dies kann sich in Schleifen, das ist genau das gleiche wie der Sprung in die tail-call-Optimierung die oben erwähnt werden. Denn dies ist die gleiche Funktion (angerufene und Anrufer) gibt es weniger stack-Korrekturen, die getan werden müssen, bevor Sie den Sprung.

Das folgende Beispiel zeigt eine Allgemeine Weise ein rekursiver Aufruf, die wäre schwieriger für einen compiler in eine Schleife:

int sum(int a[], unsigned len) {
     if (len==0) {
         return 0;
     }
     return a[0] + sum(a+1,len-1);
}

Dies ist einfach genug, dass viele Compiler könnte wahrscheinlich heraus es sowieso, aber wie Sie sehen können gibt es eine Ergänzung, die passieren muss, um nach der Rückkehr von der genannten Summe eine Zahl zurück, so dass eine einfache tail-call-Optimierung ist nicht möglich.

Wenn Sie nicht:

static int sum_helper(int acc, unsigned len, int a[]) {
     if (len == 0) {
        return acc;
     }
     return sum_helper(acc+a[0], len-1, a+1);
}
int sum(int a[], unsigned len) {
     return sum_helper(0, len, a);
}

Würden Sie in der Lage sein, um die Vorteile der Anrufe in beiden Funktionen sein Schwanz fordert. Hier die sum-Funktion die Hauptaufgabe ist das verschieben einer Wert-und klar, ein register oder stack-position. Die sum_helper hat alle von der math.

Da Sie erwähnten C++ in Ihrer Frage, die ich nennen werde, einige spezielle Dinge über, die.
C++ verbirgt einige Dinge von Ihnen, die C nicht. Diese Destruktoren sind die wichtigste Sache, die Sie erhalten, in die Art und Weise der tail-call-Optimierung.

int boo(yin * x, yang *y) {
    dharma z = x->foo() + y->bar();
    return z.baz();
}

In diesem Beispiel den Aufruf von baz nicht wirklich einen Schwanz nennen, weil z sein muss, zerstört nach der Rückkehr von baz. Ich glaube, dass die Regeln von C++ kann die Optimierung eher schwierig, selbst in Fällen, in denen die variable ist nicht notwendig für die Dauer des Gesprächs, wie zum Beispiel:

int boo(yin * x, yang *y) {
    dharma z = x->foo() + y->bar();
    int u = z.baz();
    return qwerty(u);
}

z möglicherweise zerstört nach der Rückkehr von qwerty-hier.

Eine andere Sache wäre, implizite Typ-Umwandlung, die passieren können in C, aber kann mehr kompliziert und Häufig in C++.
Zum Beispiel:

static double sum_helper(double acc, unsigned len, double a[]) {
     if (len == 0) {
        return acc;
     }
     return sum_helper(acc+a[0], len-1, a+1);
}
int sum(double a[], unsigned len) {
     return sum_helper(0.0, len, a);
}

Hier Summe nennen zu sum_helper ist kein Schwanz nennen, weil sum_helper gibt ein double zurück und Summe benötigen, zu konvertieren, die in einer int.

In C++ ist es durchaus üblich, ein Objekt wieder Anhaltspunkte, die haben alle Arten von verschiedenen Interpretationen, von denen jede könnte eine andere Art der Konvertierung
Zum Beispiel:

bool write_it(int it) {
      return cout << it;
}

Hier gibt es einen Aufruf cout.operator<< wie die Letzte Anweisung. cout gibt eine Referenz auf sich selbst (das ist, warum Sie können string viele Dinge, die zusammen in einer Liste, getrennt durch " << ), die Sie dann zwingen bewertet werden als bool, die endet Aufruf ein weiteres cout Methoden, operator bool(). Diese cout.operator bool() aufgerufen werden könnte, als einen tail-call in diesem Fall, aber operator<< konnte nicht.

EDIT:

Eine Sache, erwähnenswert ist, dass ein wesentlicher Grund, dass die tail-call-Optimierung in C möglich ist, ist, dass der compiler weiß, dass die aufgerufene Funktion speichern den Rückgabewert in der gleichen Stelle wie die aufrufende Funktion, um sicherzustellen, dass Ihr Rückgabewert wird gespeichert.

InformationsquelleAutor der Antwort nategoose

Wikipedia hat eine anständige Artikel über die tail-Rekursion. Im Grunde, tail recursion ist besser als reguläre Rekursion, denn es ist trivial zu optimieren, in einer iterativen Schleife, und iterative Schleifen sind in der Regel effizienter als rekursive Funktionen. Dies ist besonders wichtig bei funktionalen Sprachen, in denen Sie nicht Schleifen.

Für C++, ist es doch gut, wenn Sie können schreiben Sie Ihre rekursive loops mit tail-Rekursion, da Sie besser optimiert, aber in solchen Fällen, können Sie in der Regel tun Sie es einfach iterativ in Erster Linie, so dass der Gewinn ist nicht so groß, wie es sein würde, in einer funktionalen Sprache.

InformationsquelleAutor der Antwort Jonathan M Davis