Ausführungsreihenfolge im Operator <

Ich habe Schwierigkeiten, die Reihenfolge der Aufrufe im folgenden Code zu verstehen. Ich hatte erwartet, die Ausgabe unten zu sehen

    A1B2

Während ich sehen kann, dass die Ausgabe, die ich bekomme, ist

    BA12

Ich dachte, dass der Anruf std::cout<< b->fooA() << b->fooB() << std::endl war gleichbedeutend mit Anruf

  std::cout.operator<<( b->fooA() ).operator<< ( b->fooB() )

aber ich sehe, dass dem nicht so ist. Können Sie mir helfen, besser zu verstehen, wie das funktioniert und wie das mit dem Globalen zusammenhängt? operator<<? Wird das letzte jemals in dieser Reihenfolge aufgerufen?

#include <iostream>

struct cbase{
    int fooA(){
        std::cout<<"A";
        return 1;
    }
    int fooB(){
        std::cout <<"B";
        return 2;
    }
};

void printcbase(cbase* b ){
    std::cout << b->fooA() << b->fooB() << std::endl;
}

int main(){
    cbase b;
    printcbase( &b );
}

Der Compiler kann die Funktion auswerten printcbase() so:

void printcbase(cbase* b ){
    int a = b->FooA();    // line 1
    int b = b->FooB();    // line 2
    std::cout << a;       // line 3
    std::cout << b;       // line 4
    stc::cout << std::endl;
}

oder einige der vielen Permutatinen von Zeilen, die als 1 – 4 gekennzeichnet sind. Sie können nur garantieren, dass Zeile 1 vor Zeile 3 und Zeile 2 vor Zeile 4 (und natürlich Zeile 3 vor Zeile 4) ausgeführt wird. Mehr sagt der Standard nicht aus und tatsächlich kann man mit unterschiedlichen C++-Compilern unterschiedliche Ergebnisse erwarten.

Die Reihenfolge der Ausführung von << ist gut definiert, aber die Reihenfolge der Auswertung von Unterausdrücken ist in C++ nicht definiert. Dieser Artikel und das C-Codebeispiel verdeutlicht das von dir angesprochene Problem.

BA12 und AB12 sind beide richtig. Im folgenden Code:

std::cout<< b->fooA() << b->fooB()

1 wird vorher erscheinen 2 aber A kann vorher oder nachher auftreten B seit der Compiler verspricht nicht ob es bewertet wird fooA oder fooB Erste.

Die Verschiebungsoperatoren sind linksassoziativ; a << b << c wird gelesen als (a << b) << c, was bedeutet, dass wenn a ist von einem Typ mit benutzerdefiniertem Mitglied operator<< (und gibt diesen Typ zurück), dann liest sich der Ausdruck als a.operator<<(b).operator<<(c). Wenn stattdessen eine kostenlose operator<< verwendet wird, dann liest sich dies als operator<<(operator<<(a, b), c).

Also die Bewertung von a << b vor der Auswertung sequenziert wird (a << b) << c, aber es gibt keine Sequenzierungsabhängigkeit zwischen der Auswertung von b und c:

a << b << c[1]
|         |
a << b[2] |
|    |    c[5]
a[3] b[4]

Wenn wir die Nebenwirkungen wie oben nummerieren, dann können die Nebenwirkungen wie folgt geordnet werden:

54321
53421
45321
43521
43251
35421
34521
34251