Warum funktioniert Postfix fehlgeschlagen und Präfix funktioniert gut, wenn ein Iterator als Argument übergeben und an der Endposition rekursiv?

Question

Ich stoße zufällig auf dieses Problem.

Ich habe gedacht, dass Google es sicher lösen kann, aber nachdem ich mehrere Schlüsselwörter durchsucht habe, kann ich noch keine Antworten finden, die mich sehr verwirrt haben.

Wenn ich Präfix an Schwanz Position verwenden, Codes funktioniert:

template<class ContinerIterator, class F> 
constexpr auto fun(ContinerIterator IteratorBegin, ContinerIterator IteratorEnd, F f) 
{ 
    switch (IteratorBegin == IteratorEnd) 
    { 
    case true: return; 
    case false: f(*IteratorBegin); 
    } 
    return fun(++IteratorBegin, IteratorEnd, f); 
} 
int main() 
{ 
    std::vector<int> a = { 1, 2, 3, 4 }; 
    fun(std::begin(a), std::end(a), [](auto &a)->auto{a *= 2; }); 
    for (auto v : a) 
    { 
     std::cout << v << std::endl; 
    } 
    return 0; 
} 

Drücken Sie eine beliebige Taste, um fortzufahren . . .

---

Howerer, wenn ich postfix verwenden, kommt IteratorBegin Nerven iteratorEnd und geht weit und weit weg, so segmentfault.

template<class ContinerIterator, class F> 
constexpr auto fun(ContinerIterator IteratorBegin, ContinerIterator IteratorEnd, F f) 
{ 
    switch (IteratorBegin == IteratorEnd) 
    { 
    case true: return; 
    case false: f(*IteratorBegin); 
    } 
    return fun(IteratorBegin++, IteratorEnd, f); 
} 
void test() 
{ 

} 
int main() 
{ 
    std::vector<int> a = { 1, 2, 3, 4 }; 
    fun(std::begin(a), std::end(a), [](auto &a)->auto{a *= 2; }); 
    for (auto v : a) 
    { 
     std::cout << v << std::endl; 
    } 
    return 0; 
} 

Ich habe versucht auf MSVC, G ++, Clang, alles scheitert. Hier ist Fehlerliste des gcc:

Segmentation fault (core dumped)

Hier Clang ist:

Fehler aufgetreten ist (Timeout). Versuchen Sie es später noch einmal.

Answer 1

Diese Aussage

return fun(IteratorBegin++, IteratorEnd, f); 

mit einigen Ausnahmen können wie

fun(IteratorBegin, IteratorEnd, f); 
++IteratorBegin; 
return; 

So ist die Funktion mit dem gleichen Wert von IteratorBegin aufgerufen wird immer in Betracht gezogen werden.

Aus dem C++ Standard (5.2.6 Inkrement- und Dekrement)

1 Der Wert eines Ausdrucks ++ Postfix ist der Wert des Operanden. [ Hinweis: der erhaltene Wert ist eine Kopie des ursprünglichen Wertes -Ende note ] ...

Betrachten Sie das folgende einfache Programm

#include <iostream> 

void f(int x) 
{ 
    std::cout << "Inside f(x): x = " << x << std::endl; 
} 

int main() 
{ 
    int x = 0; 

    std::cout << "Before f(x): x = " << x << std::endl; 
    f(x++); 
    std::cout << "After f(x): x = " << x << std::endl; 

    return 0; 
} 

Sein Ausgang ist

Before f(x): x = 0 
Inside f(x): x = 0 
After f(x): x = 1 

Auch wird es nützlich sein, das folgende einfache Programm

zu betrachten

#include <iostream> 

int x = 0; 

void f(int x) 
{ 
    std::cout << "Local (parameter) x = " << x << std::endl; 
    std::cout << "Global variable ::x = " << ::x << std::endl; 
} 

int main() 
{ 
    f(x++); 

    return 0; 
} 

Sein Ausgang ist

Local (parameter) x = 0 
Global variable ::x = 1 

Answer 2

Die Vorsilbe Fall:

return fun(++IteratorBegin, IteratorEnd, f); 

sagt ersten Inkrement IteratorBegin nach dem anderen, und rufen dann die Funktion fun. Danach zurück.

Auf der anderen Seite, der Postfix Fall:

return fun(IteratorBegin++, IteratorEnd, f); 

sagt, rufen Sie zunächst fun(), erhöhen Sie dann den Iterator, und dann zurück.

Das bedeutet, dass fun() immer mit dem nicht inkrementierten Iterator aufgerufen wird.

Answer 3

Wenn Sie Postfix-Inkrement im Tail-Aufruf verwenden, erhält der rekursive Aufruf nicht den inkrementierten Wert des Iterators. Er ruft den Wert des Iterators ab, bevor das Inkrement angewendet wird. Daher ist die Rekursion unendlich. Das verursacht Stapelüberlauf.