Wie Postfix Inkrementoperator

Question

ich gelernt habe implementieren: Ein Benutzer definierte postfix Inkrementoperator sollte ein konstantes Objekt zurückkehren zu verhalten wie ein fundamentaler arithmetischer Typ:

int i = 0; 
i++ = 42; // error, i++ is pr-value 
++i = 42; // ok, ++i is l-value 

so für Klasse Widget sollte es wie deklariert werden

const Widget operator++(int); 
... 
Widget w1, w2; 
w1++ = w2; // error, fine, same as i++ = 42 

ohne const, würde es kompilieren. Aber mit dieser an Ort und Stelle, ist es nicht möglich, zu nennen

void f(Widget&&); 
f(w1++); // error, invalid initialization of Widget&& from expression const Widget 

was schade, denn w1 ++ ist ein r-Wert Ausdruck und es ist Konstantheit keinen Einfluss hat, weil es sich um eine vorübergehende ist, ist es nicht?

Nun, wie sollte Operator ++ (int) deklariert werden? Danke für die Beratung.

Answer 1

Ein Benutzer postfix Inkrementoperator definiert sollte ein konstantes Objekt zurückgeben wie eine grundlegende arithmetische Art zu verhalten:

Rückkehr const, Qualifizieren Typen Klasse nicht allgemein empfohlen, in C++ 11. Wie Sie bemerkt haben, verhindert es die Verwendung von Verschiebeoperationen. Um sich wie ein fundamentaler arithmetischer Typ zu verhalten, ist es ein einfacherer Ansatz, den = Operator auf rvalues ​​zu deaktivieren.

struct S { 
    S &operator=(const S &) & = default; 
    S &operator=(S &&) & = default; 
}; 
S f() { return {}; } 
int main() { 
    S s; 
    s = s; // okay 
    s = f(); // okay 
    f() = s; // error 
} 

Mit diesem können Sie Widget operator++(int); erklären, ablehnen w1++ = w2;, aber f(w1++); ermöglichen.

Answer 2

Widget operator++(int); ist die Standarddefinition.

Deklaration von Funktionen, die nach Wert zurückgeben, aber auch const zurückgeben, der Funktionsschreiber versucht zu beschränken, was der Funktionsverbraucher mit der Funktion macht.

Persönlich mache ich das nie, es ist nur eine unnötige Einschränkung und verursacht Probleme genau wie Sie in diesem Beispiel zeigen. Aber andere Leute glauben, dass es den "Preis" wert ist, f(w1++) zu verbieten, um eine Compilerdiagnose über w1++ = w2; zu bekommen, die wahrscheinlich ein logischer Fehler ist. Es ist eine Frage der Meinung und des Codierungsstils wirklich.