Is there a useful script for moving const objects?

Question

I realized that the general knowledge that "you cannot move a const object" is not entirely true. You can, if you declare the ctor move as

X(const X&&); 

Full example below:

 #include <iostream> struct X { X() = default; X(const X&&) {std::cout << "const move\n";} }; int main() { const X x{}; X y{std::move(x)}; } 

Live on coliru

Question: Is there any reason why you would like this? Any useful / practical scenario?

Answer 1

Your example does not move anything. Yes, you wrote std::move to get the rvalue, and you called the move constructor, but nothing actually ends with the transition. And it cannot, because the object is const .

If the participants you were interested in were marked mutable , you could not "move". Thus, there is no useful or even possible scenario.

Answer 2

Not sure if this is practical, but can be made legal if the modified data members are mutable .

This program is legal, and if you like such a thing, it will be easy for you to follow:

 #include <iostream> #include <string> struct animal { animal(const animal&& other) : type(other.type) { other.type = "dog"; } animal() = default; mutable std::string type = "cat"; }; std::ostream& operator<<(std::ostream& os, const animal& a) { return os << "I am a " << a.type; } std::ostream& operator<<(std::ostream& os, const animal&& a) { return os << "I am a " << a.type << " and I feel moved"; } int main() { const auto cat = animal(); std::cout << cat << std::endl; auto dog = std::move(cat); std::cout << cat << std::endl; std::cout << dog << std::endl; std::cout << std::move(dog) << std::endl; } 

expected output:

 I am a cat I am a dog I am a cat I am a cat and I feel moved 

Answer 3

As noted in the comments, you cannot actually “move” anything from the argument object because it is const (at least not without casting const, which is a bad idea, as this can lead to UB). So this is clearly not useful for moving. The whole purpose of movement semantics is to provide performance optimization, and this does not happen here, so why do it?

However, I can only think of two cases where this is useful. The first includes greedy constructors:

 #include <iostream> struct Foo { Foo() = default; Foo(const Foo&) { std::cerr << "copy constructor"; } Foo(Foo&&) { std::cerr << "copy constructor"; } template <class T> Foo(T&&) { std::cerr << "forward"; } }; const Foo bar() { return Foo{}; } int main() { Foo f2(bar()); return 0; } 

This program prints "forward". The reason is that the computed type in the template will be const Foo , which makes it a better match. This also shows up when you have the perfect redirects to the variation constructors. Common for proxy objects. Of course, returning by const value is bad practice, but, strictly speaking, this is not true, and it could break your class. So you really have to provide an overload of Foo(const Foo&&) (which just delegates to the copy constructor); think of it as the intersection of t, or how I write high-quality generic code.

The second case arises if you want to explicitly remove the move constructors or the move transformation operator:

 struct Baz { Baz() = default; Baz(const Baz&) = default; Baz(Baz&&) = delete; }; const Baz zwug() { return {}; } int main() { Baz b2(zwug()); } 

This program compiles, so the author has not completed his task. The reason is that const ref overloads the match with const rvalues, and const rvalue has not been explicitly deleted. If you want to remove moves, you will also need to remove the const rvalue overload.

The second example may seem wildly obscure, but say that you are writing a class that provides a string representation. You may not want it to be created from a string, temporary, since you are at a greater risk of damaging the image.