Zuweisen von R-Wert-Referenzen des Klassentyps: Ein gelöstes Paradoxon

Im Bereich C ist die Unterscheidung zwischen L-Werten und R-Werten von größter Bedeutung. L-Werte stellen Objekte mit Speicherorten dar, die geändert werden können, während R-Werte temporäre Objekte oder Konstanten verkörpern, die nicht geändert werden können. Ein interessanter Codeausschnitt wirft jedoch Fragen zu dieser grundlegenden Unterscheidung auf:

class Y {
public:
    explicit Y(size_t num = 0) {}
};

int main() {
    Y(1) = Y(0); // Here lies the enigma!
    return 0;
}

Warum wird dieser Code kompiliert? Ist der vom Konstruktor zurückgegebene R-Wert nicht kurzlebig und daher für die Zuweisung ungeeignet?

Der Schlüssel zum Verständnis dieses Paradoxons liegt im impliziten Zuweisungsoperator in C. Wenn der Zuweisungsoperator nicht explizit für eine Klasse definiert ist, synthetisiert der Compiler einen Standardzuweisungsoperator. Entscheidend ist, dass dieser synthetisierte Operator in einigen Fällen auf R-Werte anwendbar sein kann.

Hier spielt das explizite Schlüsselwort eine Rolle. Im gegebenen Beispiel deklariert die Y-Klasse keinen Zuweisungsoperator, daher generiert der Compiler einen. Das Schlüsselwort „explicit“ verhindert implizite Konvertierungen von R-Werten, verhindert jedoch nicht, dass der synthetisierte Zuweisungsoperator auf R-Werte anwendbar ist.

In unserem Code ist also der synthetisierte Zuweisungsoperator:

Y& Y::operator=(Y const&);

or

Y& Y::operator=(Y&);

kann mit dem R-Wert Y aufgerufen werden (1) auf der linken Seite. Dadurch kann die Zuweisung fortgesetzt werden, auch wenn Y(1) ein R-Wert ist.

Um die Zuweisung an temporäre Objekte zu verhindern, kann man den Zuweisungsoperator explizit mit einem Ref-Qualifizierer (&) deklarieren:

class Y {
public:
    explicit Y(std::size_t num = 0);
    Y& operator=(Y const&) & = default;
};

In diesem Fall wird der Zuweisungsoperator nicht synthetisiert und der Versuch, ihn einem R-Wert zuzuweisen, führt zu einem Kompilierungsfehler.