Question

After a debug session I realised that the next sample code compile with no warnings (g++-4.7.2 -Wextra and -Wall)

char *p;
char *q = std::move(p);
*p = 'p';
*q = 'q';

I’m a bit shocked, and I have three questions about it.

1- Am I missing something about move semantics and there is a reason for not issuing a warning in this situation, or is gcc’s checking not good enough?

2- Should the next code throw a warning?

char c = 'c';
char *p = &c;
char *q = std::move(p);
*p = 'p';

As far I understand, after std::move(p) p can hold any value, therefore once p is moved is like an uninitialized variable.

3- Can other tools/compilers check these errors?

Answer 1

1- I’m missing something about move semantics and there is a reason for no throw a warning in this situation, or gcc checking is not good enough?

The code is wrong, so a warning would be good. G++ isn’t smart enough to “see through” the call to std::move. It’s valid to pass an uninitialized variable by reference to a function (that function might initialize the variable) so calling std::move itself doesn’t trigger a warning. Because q gets assigned a value, it appears to be initialized to the compiler.

If I turn on optimization so that G++ inlines the call to std::move then I get an error from G++ 4.7:

f.cc: In function ‘int main()’:
f.cc:6:9: warning: ‘p’ is used uninitialized in this function [-Wuninitialized]

This is because the call to std::move is no longer “opaque” to the compiler, when it analyses the inlined code it can see that p never gets assigned a value. The compiler still isn’t smart enough to see that q never gets a good value, the cast inside std::move probably confuses the compiler.

2- The next code should throw a warning?

No. std::move doesn’t alter fundamental types such as pointers, so the value of p will not be changed. The standard library says that objects are left in a “valid but unspecified” state after being moved from, because the standard doesn’t generally define the exact behaviour of a move constructor or move assignment operator, but for fundamental types such as int and char* there is no move constructor. std::move(p) just casts the object to an rvalue, it doesn’t alter it, and initializing q with the value doesn’t alter it either – it just copies the value.

3- Other tools/compilers can check these errors?

Clang and ICC fail to warn about the first example even with optimization on.

Note that although warnings are very useful, compilers are not perfect and it is impossible to warn about all unsafe code. You should not be totally surprised when unsafe code doesn’t get a warning (maybe open a bug report for the compiler to request it be improved) — it doesn’t mean the code is OK. Absence of warnings does not imply absence of bugs.