Was sind die evaluation, um Garantien eingeführt, die von der C++17?

Einige häufige Fälle, in denen die Auswertung, um bisher unbekannter, angegeben werden und gültig mit C++17. Einige Undefiniertes Verhalten ist jetzt statt, nicht angegeben.

Was über Dinge wie

i=1;
f(i++, i)

war undefiniert, aber ist jetzt nicht angegeben. Speziell, was nicht angegeben ist, ist die Reihenfolge, in der jedes argument f bewertet wird im Verhältnis zu den anderen. i++ könnten ausgewertet werden, bevor i oder vice-versa. In der Tat, es könnte bewerten, der zweite Aufruf in einer anderen Reihenfolge, obwohl Sie unter dem gleichen compiler.

Jedoch die Bewertung der einzelnen Argumente ist erforderlich vollständig ausführen, mit allen Nebenwirkungen, vor der Ausführung von einem anderen argument. So könnte man f(1, 1) (zweites argument zuerst ausgewertet) oder f(1, 2) (erstes argument zuerst ausgewertet). Aber Sie werden nie wieder f(2, 2) oder irgendetwas anderes in der Natur.

std::cout << f() << f() << f() ;

Wurde nicht spezifiziert, aber werden kompatibel mit operator-Vorrang, so dass die erste Bewertung von f kommt zuerst in den Bach. (Beispiele unten).

f(g(),h(),j());

noch unbekannter Bewertung Reihenfolge g, h, j. Beachten Sie, dass für getf()(g(),h(),j()) die Regeln besagen, dass getf() werden ausgewertet, bevor g,h,j.

Beachten Sie auch das folgende Beispiel aus dem Vorschlag text:

 std::string s = "but I have heard it works even if you don't believe in it" 
 s.replace(0, 4, "").replace(s.find("even"), 4, "only")
  .replace(s.find(" don't"), 6, "");

Beispiel kommt aus Die C++ - Programmiersprache, 4. Auflage, Stroustrup, und verwendet werden, um unspezifische Verhalten, aber mit C++17 es wird wie erwartet funktionieren. Es gab ähnliche Probleme mit fortsetzbare Funktionen (.then( . . . )).

Als weiteres Beispiel betrachten wir die folgenden:

#include <iostream>
#include <string>
#include <vector>
#include <cassert>

struct Speaker{
    int i =0;
    Speaker(std::vector<std::string> words) :words(words) {}
    std::vector<std::string> words;
    std::string operator()(){
        assert(words.size()>0);
        if(i==words.size()) i=0;
        //pre- C++17 version:
        auto word = words[i] + (i+1==words.size()?"\n":",");
        ++i;
        return word;
        //Still not possible with C++17:
        //return words[i++] + (i==words.size()?"\n":",");

    }   
};

int main() {
    auto spk = Speaker{{"All", "Work", "and", "no", "play"}};
    std::cout << spk() << spk() << spk() << spk() << spk() ;
}

Mit C++14 und bevor wir können (und werden) die Ergebnisse erhalten wie

play
no,and,Work,All,

statt

All,work,and,no,play

Beachten Sie, dass die oben ist in der Tat das gleiche wie

(((((std::cout << spk()) << spk()) << spk()) << spk()) << spk()) ;

Aber noch, bevor C++17 gab es keine Garantie, dass die ersten Aufrufe kommen würde, zuerst in den stream.

Referenzen: Von der akzeptiert Vorschlag:

Postfix-Ausdrücke werden von Links nach rechts ausgewertet. Dies beinhaltet
Funktionen fordert, und die Elementauswahl Ausdrücken.

Zuweisung Ausdrücke werden ausgewertet, von rechts nach Links. Diese
umfasst zusammengesetzte Zuweisungen.

Operanden in den shift-Operatoren werden von Links nach rechts ausgewertet. In
Zusammenfassung die folgenden Ausdrücke werden in der Reihenfolge ausgewertet, dann
b, dann c, dann d:

1. ein.b
2. a->b
3. a->*b
4. a(b1, b2, b3)
5. b @= a
6. ein[b]
7. a << b
8. a >> b

Darüber hinaus empfehlen wir die folgenden zusätzlichen Regel: die Reihenfolge der
Auswertung eines Ausdrucks mit einem überladenen operator ist
durch die Reihenfolge bestimmt, verbunden mit den entsprechenden built-in
Betreiber, nicht die Regeln für Funktionsaufrufe.

Bearbeiten Hinweis: Meine ursprüngliche Antwort falsch interpretiert a(b1, b2, b3). Die Reihenfolge der b1, b2, b3 ist noch nicht spezifiziert. (danke @KABoissonneault, alle Kommentatoren.)

Allerdings, (wie @Yakk Punkte), und das ist wichtig: Auch wenn b1, b2, b3 sind nicht-triviale Ausdrücke, jeder von Ihnen sind vollständig ausgewertet und gebunden an die jeweilige Funktion parameter, bevor die andere gestartet werden ausgewertet. Der standard besagt dies wie folgt:

§5.2.2 - Funktion aufrufen 5.2.2.4:

. . .
Der postfix-Ausdruck ist sequenziert, die vor jedem Ausdruck in die
Ausdruck-Liste und alle Standard-argument. Jeder Wert-Berechnung und
Nebenwirkungen im Zusammenhang mit der Initialisierung der parameter und der
die Initialisierung selbst ist sequenziert, die vor jedem Wert-Berechnung und
Nebenwirkungen im Zusammenhang mit der Initialisierung von späteren
parameter.

Jedoch einer dieser neuen Sätze fehlen github Entwurf:

Jeden Wert, der die Berechnung und die Nebenwirkungen im Zusammenhang mit der
Initialisierung der parameter und die Initialisierung selbst ist
sequenziert vor jedem Wert die Berechnung und die Nebenwirkungen im Zusammenhang
mit der Initialisierung der alle nachfolgenden parameter.

Beispiel ist es. Es löst eine Jahrzehnte-alte Probleme (Wie bereits erklärt, von Herb Sutter) mit Ausnahme der Sicherheit, wo Dinge wie

f(std::unique_ptr<A> a, std::unique_ptr<B> b);

f(get_raw_a(),get_raw_a()); 

würde Auslaufen, wenn der ruft get_raw_a() werfen würde, bevor die anderen
raw-pointer gebunden war, um es in den smart-pointer-parameter.
edit: wie bereits von T. C. das Beispiel ist fehlerhaft, da unique_ptr Bau von raw-pointer explizit ist, zu verhindern das kompilieren.

Beachten Sie auch diese klassische Frage (tagged C, nicht C++):

int x=0;
x++ + ++x;

ist noch nicht definiert.

Ich habe festgestellt, dass einige Notizen über die Auswertung eines Ausdrucks um:

• Kurze Frage: Warum nicht c++ haben eine festgelegte Reihenfolge für die Bewertung
  Funktion Argumente?

  Einige der Reihenfolge der Bewertung garantiert umliegenden überladen von Operatoren und komplett-argument-Regeln Hinzugefügt, die in C++17. Aber es bleibt, dass das argument zuerst geht, ist nicht angegeben. In C++17, es wird jetzt angegeben,, die dem Ausdruck geben, was zu nennen (der code auf der linken Seite des ( der Funktionsaufruf) geht, bevor die Argumente, und welches argument zuerst ausgewertet wird vollständig ausgewertet, bevor die nächste gestartet wird, und im Fall von ein-Objekt-Methode der Wert des Objekts ausgewertet, bevor die Argumente der Methode sind.

• Reihenfolge der Auswertung
  

  21) Jeder Ausdruck in eine Komma-getrennte Liste von Ausdrücken in Klammern-Initialisierer ausgewertet wird, als wenn für einen Funktionsaufruf (indeterminately-sequenziert)

• Mehrdeutige Ausdrücke
  

  Der Sprache C++ übernimmt keine Garantie für die Reihenfolge, in der die Argumente für einen Funktionsaufruf ausgewertet werden.

In P0145R3.Die Verfeinerung der Auswertung eines Ausdrucks, Um für die Idiomatischen C++ die ich gefunden habe:

Den Wert-Berechnung und die damit verbundenen Nebenwirkungen der postfix-Ausdruck sequenziert, bevor diese der Ausdrücke in den Ausdruck-Liste. Die Initialisierung der deklarierten Parameter sind indeterminately sequenziert ohne interleaving.

Aber ich fand es nicht in der standard -, statt in der Norm die ich gefunden habe:

6.8.1.8 Sequentielle Ausführung [intro.Ausführung]
Ein Ausdruck X wird gesagt, sequenziert werden, bevor ein Ausdruck Y, wenn jeder Wert-Berechnung und jede Nebenwirkung, die im Zusammenhang mit der Ausdruck X ist sequenziert vor jeder Berechnung und jeder Nebenwirkung, die mit der expression Y.

6.8.1.9 Sequentielle Ausführung [intro.Ausführung]
Jeder Wert Berechnung und Nebenwirkungen im Zusammenhang mit einem full-expression komplett sequenziert vor jedem Wert die Berechnung und die Nebenwirkungen im Zusammenhang mit der nächsten full-Ausdruck ausgewertet werden.

7.6.19.1 Komma-operator [expr.Komma]
Ein paar von Ausdrücken, die durch Komma getrennt ausgewertet wird von Links nach rechts;...

So, ich gegenüber entsprechend Verhalten in drei Compiler für 14-und 17-standards. Die erkundeten code:

#include <iostream>

struct A
{
    A& addInt(int i)
    {
        std::cout << "add int: " << i << "\n";
        return *this;
    }

    A& addFloat(float i)
    {
        std::cout << "add float: " << i << "\n";
        return *this;
    }
};

int computeInt()
{
    std::cout << "compute int\n";
    return 0;
}

float computeFloat()
{
    std::cout << "compute float\n";
    return 1.0f;
}

void compute(float, int)
{
    std::cout << "compute\n";
}

int main()
{
    A a;
    a.addFloat(computeFloat()).addInt(computeInt());
    std::cout << "Function call:\n";
    compute(computeFloat(), computeInt());
}

Ergebnisse (die mehr konsistent ist clang):

HTML:

<style type="text/css">
  .tg {
    border-collapse: collapse;
    border-spacing: 0;
    border-color: #aaa;
  }
  
  .tg td {
    font-family: Arial, sans-serif;
    font-size: 14px;
    padding: 10px 5px;
    border-style: solid;
    border-width: 1px;
    overflow: hidden;
    word-break: normal;
    border-color: #aaa;
    color: #333;
    background-color: #fff;
  }
  
  .tg th {
    font-family: Arial, sans-serif;
    font-size: 14px;
    font-weight: normal;
    padding: 10px 5px;
    border-style: solid;
    border-width: 1px;
    overflow: hidden;
    word-break: normal;
    border-color: #aaa;
    color: #fff;
    background-color: #f38630;
  }
  
  .tg .tg-0pky {
    border-color: inherit;
    text-align: left;
    vertical-align: top
  }
  
  .tg .tg-fymr {
    font-weight: bold;
    border-color: inherit;
    text-align: left;
    vertical-align: top
  }
</style>
<table class="tg">
  <tr>
    <th class="tg-0pky"></th>
    <th class="tg-fymr">C++14</th>
    <th class="tg-fymr">C++17</th>
  </tr>
  <tr>
    <td class="tg-fymr"><br>gcc 9.0.1<br></td>
    <td class="tg-0pky">compute float<br>add float: 1<br>compute int<br>add int: 0<br>Function call:<br>compute int<br>compute float<br>compute</td>
    <td class="tg-0pky">compute float<br>add float: 1<br>compute int<br>add int: 0<br>Function call:<br>compute int<br>compute float<br>compute</td>
  </tr>
  <tr>
    <td class="tg-fymr">clang 9</td>
    <td class="tg-0pky">compute float<br>add float: 1<br>compute int<br>add int: 0<br>Function call:<br>compute float<br>compute int<br>compute</td>
    <td class="tg-0pky">compute float<br>add float: 1<br>compute int<br>add int: 0<br>Function call:<br>compute float<br>compute int<br>compute</td>
  </tr>
  <tr>
    <td class="tg-fymr">msvs 2017</td>
    <td class="tg-0pky">compute int<br>compute float<br>add float: 1<br>add int: 0<br>Function call:<br>compute int<br>compute float<br>compute</td>
    <td class="tg-0pky">compute float<br>add float: 1<br>compute int<br>add int: 0<br>Function call:<br>compute int<br>compute float<br>compute</td>
  </tr>
</table>