如何检查变量是否仍然有效或在其上使用了 std::move？

Question

I am aware that after using std::move the variable is still valid, but in an unspecified state.

Unfortunately, recently I have come across several bugs in our code base where a function was accessing the moved variable, and weird things were happening. These issues were extremely hard to track down.

Is there any compiler option (in clang) or any way to throw an error either during runtime or compilation?

Answer 1

Some things that may help :

• Use a static analyzer. Xcode has it built-in.

  • https://clang-analyzer.llvm.org/

• Use Address Sanitizer and Undefined Behaviour sanitizer

  • http://clang.llvm.org/docs/AddressSanitizer.html
  • https://clang.llvm.org/docs/UndefinedBehaviorSanitizer.html

---

Code changes that can make such bugs easy to track down:

I'm assuming that if you're using std::move on something, it is (not always) a heavy container.

If so, try to use std::unique_ptr<T> to create it. Calls to movers must explicitly use std::move , which is easy to spot. And other non-owning access functions can just work with .get() . You can also check for nullability and throw if it's nullptr at any point where you need to access it.

Answer 2

I am aware that after using std::move the variable is still valid, but in an unspecified state.

This is not a universal truth. More generally, the object that was moved from is in whatever state in which the move constructor / assignment operator left it.

The standard library does have the guarantee that you describe at minimum. But it is also possible to implement a member function for your class which doesn't abide by it, and leaves the moved from object in an invalid state. It is however a good design choice to implement move operations in the way you describe.

How to check if variable is still valid or std::move was used on it?

There is no way to do such check in general within the language.

Is there any compiler option (in clang) or any way to throw an error either during runtime or compilation?

Note that using a variable after a move is not necessarily a bug at all, but can instead be an entirely correct thing to do. Some types specify exactly the state of the moved from object ( std::unique_ptr for example) and others which have the validity guarantee can be used in ways that have no pre-conditions (such as calling container.size() ).

As such, using a moved from object is only a problem if that violates a pre-condition, which would result in undefined behaviour. Clang and other compilers have runtime sanitisers that may be able to catch some undefined behaviour. There are also many warning options and static analysers that diagnose cases where bugs are likely.

Using them is a very good idea, but you should not rely solely on them because they won't be able to find all bugs. The programmer still needs to be careful when writing the program, and needs to compare it with the rules of the language. Following common idioms such as RAII, avoiding bare owning pointers (and other resource handles) goes a long way in avoiding typical bugs.