Why Can We Assign to Rvalues of Class Type in C ?

Why is Assignment Possible to Rvalues of Class Type?

In C , assignments to rvalue expressions generally cannot be performed. However, this behavior is seemingly violated in the code snippet below:

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

int main() {
    Y(1) = Y(0); // Assignment to rvalue
    return 0;
}

Explanation:

Contrary to initial expectations, this code compiles successfully. The reason lies in the implicit synthesis of member functions, specifically the assignment operator. According to the C Standard (section 12.8 [class.copy], paragraph 18), if an assignment operator is not declared or marked as deleted, the compiler synthesizes one. For class type Y, the synthesized assignment operator will have the following signatures:

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

Note that these signatures do not include a ref-qualifier (&) before the parameter. Therefore, the synthesized assignment operator is applicable to rvalue expressions.

This behavior allows for the assignment to temporary objects created by calling the constructor: Y(1).

Prevention of Left-Hand Side Temporary:

To prevent creating a temporary object on the left-hand side of an assignment, you can use a technique called "copy elision". This involves declaring the assignment operator with a ref-qualifier, as shown in the following modified code:

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

With this change, the synthesized assignment operator will no longer be applicable to rvalues.

The above is the detailed content of Why Can We Assign to Rvalues of Class Type in C ?. For more information, please follow other related articles on the PHP Chinese website!