Attribution à des références Rvalue d'un type de classe : un paradoxe résolu

Dans le domaine de C , la distinction entre lvalues ​​et rvalues ​​est primordiale. Les valeurs L représentent des objets avec des emplacements mémoire qui peuvent être modifiés, tandis que les valeurs R incarnent des objets temporaires ou des constantes qui ne le peuvent pas. Cependant, un extrait de code intrigant soulève des questions sur cette division fondamentale :

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

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

Pourquoi ce code est-il compilé ? La rvalue renvoyée par le constructeur n'est-elle pas éphémère et donc impropre à l'affectation ?

La clé pour comprendre ce paradoxe réside dans l'opérateur d'affectation implicite en C . Lorsque l'opérateur d'affectation n'est pas explicitement défini pour une classe, le compilateur synthétise un opérateur d'affectation par défaut. Surtout, cet opérateur synthétisé peut être applicable aux rvalues ​​dans certains cas.

C'est là que le mot-clé explicite joue un rôle. Dans l'exemple donné, la classe Y ne déclare pas d'opérateur d'affectation, le compilateur en génère donc un. Le mot-clé explicite empêche les conversions implicites à partir des rvalues, mais il n'empêche pas l'opérateur d'affectation synthétisé d'être applicable aux rvalues.

Ainsi, dans notre code, l'opérateur d'affectation synthétisé :

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

ou

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

peut être invoqué avec la rvalue Y(1) sur le côté gauche. Cela permet à l'affectation de se poursuivre, même si Y(1) est une valeur r.

Pour empêcher l'affectation à des objets temporaires, on peut déclarer explicitement l'opérateur d'affectation avec un qualificatif de référence (&) :

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

Dans ce cas, l'opérateur d'affectation ne sera pas synthétisé et tenter de l'attribuer à une rvalue entraînera une erreur de compilation.