Object passed to std::move but not moved from?

Question

I am reviewing some code like this, where A is a moveable type:

// Returns true exactly when ownership of a is taken
bool MaybeConsume(A&& a) {
  if (some condition) {
    Consume(std::move(a));  // ???
    return true;
  }
  return false;
}

// ... elsewhere ...

A a;
if (!MaybeConsume(std::move(a))) {
  a.DoSomething();  // !!!
}

Our static analysis tool complains that a is used after being moved (at !!!). IIUC std::move is only a static_cast, and the object a won't actually get gutted until a move constructor or assignment operator is called (presumably in Consume). Assuming MaybeConsume satisfies the contract in the comment,

1. Does this work?
2. Is it UB?
3. Is std::move at ??? a no-op?

(Probably this particular instance can be refactored to avoid the subtlety, but I would still like to ask for my own understanding).

Answer 1

It's a spurious warning from your static analysis tool.

1. Does this work?

Yes, MaybeConsume is doing what the comment says. It's only taking ownership of its argument when some condition is true (assuming Consume actually does move construct/assign from its argument).

std::move is indeed just a fancy static_cast<T&&> so MaybeConsume(std::move(a)) is not transferring ownership, you're simply binding a reference to MaybeConsume's parameter.

2. Is it UB?

No, you're not making use of a if MaybeConsume indicates it has assumed ownership of its argument.

3. Is std::move at ??? a no-op?

Well, it's a no-op because it's just a static_cast, but if you meant to ask whether it's unnecessary, then, no, it isn't. Within the body of MaybeConsume, a is an lvalue because it has a name. If the signature of Consume is void Consume(A&&), then the code won't compile without that std::move.

---

From the example usage you've shown, it seems you're not supposed to call MaybeConsume with a prvalue argument, since the caller should presumably use the argument in some other manner if the function returns false. If that's true, then you should change its signature to bool MaybeConsume(A&). This will probably make your static analysis tool happy because that would allow you to write if (!MaybeConsume(a)).

Answer 2

To understand why the static analysis tool raises a warning, one needs to think in the way a static analyzer does. When it sees a piece of code like below:

A a;
fun(std::move(a);
a.method();

It is not clear what might happen inside fun() call. To successfully perform method() on a depends some prerequisites being satisfied, that might not( or no longer) holds after call of fun(). While the programmer might well know that it is safe to call method(), the analyzer does not, so it raises a warning.

The following is only my own opinion. It is safer to just assume the ownership of a is wholly taken by fun(). To prevent confusion, it is better to enforce a borrow-and-return style, Thinking of it as if a friend borrows a book from you, you don't (can not) use that book until it is returned. Thus never risk oneself accidentally invoke an object that should be "dead" by then.

See the below demonstration code:

#include <iostream>
#include <utility>
#include <tuple>
#include<cassert>
struct A {
public:
    int *p; 
public:
    A() {
        p = new int();
        assert(p != nullptr);
        std::cout << p << std::endl;
        std::cout << "default constrctor is called" << std::endl;
    }
    A(const A&) = delete;
    A& operator=(const A&) = delete;
    A(A&& _a): p(_a.p) {
        _a.p = nullptr;
        std::cout << p << std::endl;
        std::cout << "move constructor is called" << std::endl;;
    }
    A& operator=(A&& _a) {
        std::cout << "move assignment is called"<<std::endl;;
        p = std::move(_a.p);
        return *this;
    }
    void DoSomthing(){
        std::cout << "do somthing is called" << std::endl;
        *p = 100;
        std::cout << "value of p is changed"<<std::endl;
    }
};
std::tuple<A&&, bool>  MaybeConsume(A&& a) {
    if (1==2) {//try 1==1 alternatively
        delete a.p;
        a.p = nullptr;//consume
        std::cout << "content consumed" << std::endl;
        return std::make_tuple(Consume(std::move(a)), true);
    }
    else {
        return std::make_tuple(std::move(a), false);
    }
}

int main()
{
    A a;
    std::tuple<A&&, bool> t = MaybeConsume(std::move(a));
    if (!(std::get<bool> (t))) {
        A a1 = std::move(std::get<A&&>(t));
        a1.DoSomthing();
    }
    return 0;
}