C ++ - Ausführungsreihenfolge in der Methodenverkettung

Die Ausgabe dieses Programms:

#include <iostream> 
class c1
{   
  public:
    c1& meth1(int* ar) {
      std::cout << "method 1" << std::endl;
      *ar = 1;
      return *this;
    }
    void meth2(int ar)
    {
      std::cout << "method 2:"<< ar << std::endl;
    }
};

int main()
{
  c1 c;
  int nu = 0;
  c.meth1(&nu).meth2(nu);
}

Ist:

method 1
method 2:0

Warum ist nunicht 1, wenn meth2()startet?

Weil die Bewertungsreihenfolge nicht angegeben ist.

Sie sehen nuin mainder Auswertung, 0bevor überhaupt meth1aufgerufen wird. Dies ist das Problem bei der Verkettung. Ich rate davon ab.

Machen Sie einfach ein schönes, einfaches, klares, leicht zu lesendes und leicht verständliches Programm:

int main()
{
  c1 c;
  int nu = 0;
  c.meth1(&nu);
  c.meth2(nu);
}

Ich denke, dieser Teil des Standardentwurfs bezüglich der Reihenfolge der Bewertung ist relevant:

1.9 Programmausführung

...

15. Sofern nicht anders angegeben, werden Auswertungen von Operanden einzelner Operatoren und von Unterausdrücken einzelner Ausdrücke nicht sequenziert. Die Wertberechnungen der Operanden eines Operators werden vor der Wertberechnung des Ergebnisses des Operators sequenziert. Wenn eine Nebenwirkung auf ein Skalarobjekt in Bezug auf eine andere Nebenwirkung auf dasselbe Skalarobjekt oder eine Wertberechnung unter Verwendung des Werts desselben Skalarobjekts nicht sequenziert wird und sie möglicherweise nicht gleichzeitig auftreten, ist das Verhalten undefiniert

und auch:

5.2.2 Funktionsaufruf

...

8. [Hinweis: Die Auswertungen des Postfix-Ausdrucks und der Argumente sind relativ zueinander nicht sequenziert. Alle Nebenwirkungen von Argumentauswertungen werden vor Eingabe der Funktion sequenziert - Endnote]

Überlegen Sie sich also für Ihre Zeile c.meth1(&nu).meth2(nu);, was im Operator in Bezug auf den Funktionsaufrufoperator für den letzten Aufruf von geschieht meth2, damit wir die Aufteilung in den Postfix-Ausdruck und das Postfix-Argument deutlich sehen nu:

operator()(c.meth1(&nu).meth2, nu);

Die Auswertungen des Postfix-Ausdrucks und des Arguments für den endgültigen Funktionsaufruf (dh des Postfix-Ausdrucks c.meth1(&nu).meth2und nu) sind gemäß der obigen Funktionsaufrufregel relativ zueinander nicht sequenziert . Daher ist der Nebeneffekt der Berechnung des Postfix-Ausdrucks auf das arSkalarobjekt relativ zur Argumentauswertung von nuvor dem meth2Funktionsaufruf nicht sequenziert . Nach der obigen Programmausführungsregel ist dies ein undefiniertes Verhalten.

Mit anderen Worten, der Compiler muss das nuArgument für den meth2Aufruf nach dem meth1Aufruf nicht auswerten. Es ist frei, keine Nebenwirkungen anzunehmen, die sich meth1auf die nuAuswertung auswirken .

Der oben erzeugte Assembler-Code enthält die folgende Sequenz in der mainFunktion:

1. Die Variable nuwird auf dem Stapel zugewiesen und mit 0 initialisiert.
2. Ein Register ( ebxin meinem Fall) erhält eine Kopie des Wertes vonnu
3. Die Adressen von nuund cwerden in Parameterregister geladen
4. meth1 wird genannt
5. Das Rückgabewert - Register und der zuvor zwischengespeicherte Wert des nuin dem ebxRegister werden in Parameterregister geladen
6. meth2 wird genannt

Entscheidend ist, dass der Compiler in Schritt 5 oben zulässt, dass der zwischengespeicherte Wert nuvon Schritt 2 im Funktionsaufruf an wiederverwendet wird meth2. Hier wird die Möglichkeit außer Acht gelassen, die nudurch den Aufruf von meth1"undefiniertes Verhalten" in Aktion geändert wurde .

HINWEIS: Diese Antwort hat sich im Wesentlichen von ihrer ursprünglichen Form geändert. Meine anfängliche Erklärung in Bezug auf die Nebenwirkungen der Operandenberechnung, die nicht vor dem letzten Funktionsaufruf sequenziert wurden, war falsch, weil sie es sind. Das Problem ist die Tatsache, dass die Berechnung der Operanden selbst unbestimmt sequenziert ist.

Im C ++ - Standard von 1998, Abschnitt 5, Abs. 4

Sofern nicht anders angegeben, ist die Reihenfolge der Auswertung von Operanden einzelner Operatoren und Unterausdrücke einzelner Ausdrücke sowie die Reihenfolge, in der Nebenwirkungen auftreten, nicht angegeben. Zwischen dem vorherigen und dem nächsten Sequenzpunkt soll der gespeicherte Wert eines Skalarobjekts höchstens einmal durch Auswertung eines Ausdrucks geändert werden. Darüber hinaus darf nur auf den vorherigen Wert zugegriffen werden, um den zu speichernden Wert zu bestimmen. Die Anforderungen dieses Absatzes müssen für jede zulässige Reihenfolge der Unterausdrücke eines vollständigen Ausdrucks erfüllt sein. Andernfalls ist das Verhalten undefiniert.

(Ich habe einen Verweis auf Fußnote 53 weggelassen, der für diese Frage nicht relevant ist.)

&nuMuss im Wesentlichen vor dem Anruf ausgewertet c1::meth1()werden und numuss vor dem Anruf ausgewertet werden c1::meth2(). Es gibt jedoch keine Anforderung, nudie zuvor ausgewertet werden muss &nu(z. B. ist es zulässig, dass nuzuerst ausgewertet &nuwird und dann c1::meth1()aufgerufen wird - was möglicherweise Ihr Compiler tut). Es ist daher nicht garantiert, dass der Ausdruck *ar = 1in c1::meth1()ausgewertet wird, bevor nuin main()ausgewertet wird, um an übergeben zu werden c1::meth2().

Spätere C ++ - Standards (die ich derzeit nicht auf dem PC habe, den ich heute Abend verwende) haben im Wesentlichen dieselbe Klausel.

Ich denke, beim Kompilieren wurden die Parameter an sie übergeben, bevor die Funktionen meth1 und meth2 wirklich aufgerufen werden. Ich meine, wenn Sie "c.meth1 (& nu) .meth2 (nu);" Der Wert nu = 0 wurde an meth2 übergeben, daher spielt es keine Rolle, ob "nu" später geändert wird.

Sie können dies versuchen:

#include <iostream> 
class c1
{
public:
    c1& meth1(int* ar) {
        std::cout << "method 1" << std::endl;
        *ar = 1;
        return *this;
    }
    void meth2(int* ar)
    {
        std::cout << "method 2:" << *ar << std::endl;
    }
};

int main()
{
    c1 c;
    int nu = 0;
    c.meth1(&nu).meth2(&nu);
    getchar();
}

es wird die Antwort bekommen, die Sie wollen