Atribuindo referências de tipo de classe a Rvalue: um paradoxo resolvido

No reino de C , a distinção entre lvalues ​​e rvalues ​​é fundamental. Lvalues ​​representam objetos com locais de memória que podem ser modificados, enquanto rvalues ​​incorporam objetos temporários ou constantes que não podem. No entanto, um trecho de código intrigante levanta questões sobre essa divisão fundamental:

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

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

Por que esse código é compilado? O rvalue retornado pelo construtor não é efêmero e, portanto, impróprio para atribuição?

A chave para entender esse paradoxo está no operador de atribuição implícito em C . Quando o operador de atribuição não é definido explicitamente para uma classe, o compilador sintetiza um operador de atribuição padrão. Crucialmente, este operador sintetizado pode ser aplicável a rvalues ​​em alguns casos.

É aqui que a palavra-chave explícita desempenha um papel. No exemplo dado, a classe Y não declara um operador de atribuição, então o compilador gera um. A palavra-chave explícita evita conversões implícitas de rvalores, mas não impede que o operador de atribuição sintetizado seja aplicável a rvalores.

Assim, em nosso código, o operador de atribuição sintetizado:

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

ou

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

pode ser invocado com o rvalue Y(1) no lado esquerdo. Isso permite que a atribuição prossiga, mesmo que Y(1) seja um rvalue.

Para evitar a atribuição a objetos temporários, pode-se declarar explicitamente o operador de atribuição com um qualificador de referência (&):

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

Nesse caso, o operador de atribuição não será sintetizado e a tentativa de atribuir a um rvalue resultará em um erro de compilação.