C ++不允许强制转换为右值引用

Question

As always with variables which have been std::move 'd, it is unsafe to use them afterwards.

As I have written a code where I encourage the user to apply std::move on various occasions, I want to avoid that it is used in a wrong way, at least in a few crucial places (so to say selectively "protect against Machiavelli").

Therefore, is the following overload of std::move a valid way to go? Or would you discourage from using it?

struct A
{
     void do_something() const { /* ... whatever ... */ }
};

namespace std
{
    auto move(A& t) noexcept = delete;
    auto move(A const& t) noexcept = delete;
    //possibly the same for volatile qualifier

    //possibly also specialize static_cast<A const&>, static_cast<A&>, etc.
}

// possibly set up another function "my_private_move"
// which I can use exclusively where it is appropriate.

int main()
{
    A a;
    // auto a_moved = std::move(a);      //disallow move of lvalue ref
    a.do_something();                    //otherwise this could be problematic

    A(A{});                             //direct initialization via move constructor is ok
    auto x2 = A{};                      
}

Answer 1

Your code exhibits undefined behavior, as per [namespace.std]:

The behavior of a C++ program is undefined if it adds declarations or definitions to namespace std or to a namespace within namespace std unless otherwise specified. A program may add a template specialization for any standard library template to namespace std only if the declaration depends on a user-defined type and the specialization meets the standard library requirements for the original template and is not explicitly prohibited.

Your use case does not fall under the "otherwise specified" umbrella. Besides being undefined, it's of questionable value... you're disallowing this:

A a; 
f(std::move(a)); 
// just don't use a here

despite that being potentially a performance improvement over f(a) . But the user can still write the cast explicitly to accomplish the same result:

f(static_cast<A&&>(a)); // slightly more verbose move

Answer 2

As always with variables which have been std::move'd, it is unsafe to use them afterwards

That's not true at all. It's perfectly safe to use things that have been moved from. There are lots of places where they must be used after being moved from by Standard, for example std::swap or even just destructing locals.

What you can't do is assume that they have any specific valid state. But they must have some valid state. If you are authoring A and it does not abide by these rules, then A is broken and should be fixed, rather than band-aiding over the problem.

Answer 3

A a;
auto a_moved = std::move(a); //disallow move of lvalue ref
a.do_something(); //otherwise this could be problematic

The point of std::move() is to take an lvalue and return an rvalue so your move constructor or move assignment can be called. So either make the move constructor and move assignment deleted or your users just have to know what are they doing. Here's some information on std::move() http://en.cppreference.com/w/cpp/utility/move