Why is `std::move` allowed on const objects in C 11?

Understanding std::move on const Objects

In C 11, it is permissible to invoke std::move on a const object, an action that may seem illogical given the immutability of such objects. This behavior has raised concerns regarding its potential to lead to subtle programming errors.

However, it is crucial to note that std::move(const) does not modify the actual object. Instead, it merely instructs the compiler to attempt a move operation. If the object does not support move semantics (e.g., does not have a compatible constructor), the compiler will automatically invoke the copy constructor instead.

This behavior allows developers to safely employ std::move for objects that may or may not support move semantics. If a move operation is feasible, the compiler will efficiently transfer ownership, thereby optimizing performance. However, if a move is not supported, the code will still function correctly, albeit with the performance penalty associated with copying.

In the example provided:

struct Cat {
   Cat(){}
};

const Cat cat;
std::move(cat); //this is valid in C++11

std::move(cat) will effectively invoke the copy constructor since Cat does not define a move constructor. Thus, the const nature of the object is maintained, and no errors or unexpected behavior will occur.

In the case of the Annotation class in Scott Meyers' example:

class Annotation {
public:
    explicit Annotation(const std::string text)
     : value(std::move(text))
};

The compiler will attempt to invoke the std::string(std::string&&) constructor, but since text is const, the actual type of std::move(text) will be const std::string&&, which does not match the required std::string&&. As a result, the std::string(const std::string&) constructor will be called instead, leading to a performance penalty but not an error.

Therefore, while it may seem counterintuitive to invoke std::move on const objects, it does not inherently lead to errors or instability. Instead, it enables flexible and efficient code by allowing the compiler to determine the appropriate action based on the availability of move semantics for the specific object.

The above is the detailed content of Why is `std::move` allowed on const objects in C 11?. For more information, please follow other related articles on the PHP Chinese website!