Which C++ idioms are deprecated in C++11?
- Final Class: C++11 provides the
final
specifier to prevent class derivation - C++11 lambdas substantially reduce the need for named function object (functor) classes.
- Move Constructor: The magical ways in which
std::auto_ptr
works are no longer needed due to first-class support for rvalue references. - Safe bool: This was mentioned earlier. Explicit operators of C++11 obviate this very common C++03 idiom.
- Shrink-to-fit: Many C++11 STL containers provide a
shrink_to_fit()
member function, which should eliminate the need swapping with a temporary. - Temporary Base Class: Some old C++ libraries use this rather complex idiom. With move semantics it's no longer needed.
- Type Safe Enum Enumerations are very safe in C++11.
- Prohibiting heap allocation: The
= delete
syntax is a much more direct way of saying that a particular functionality is explicitly denied. This is applicable to preventing heap allocation (i.e.,=delete
for memberoperator new
), preventing copies, assignment, etc. - Templated typedef: Alias templates in C++11 reduce the need for simple templated typedefs. However, complex type generators still need meta functions.
- Some numerical compile-time computations, such as Fibonacci can be easily replaced using generalized constant expressions
result_of
: Uses of class templateresult_of
should be replaced withdecltype
. I thinkresult_of
usesdecltype
when it is available.- In-class member initializers save typing for default initialization of non-static members with default values.
- In new C++11 code
NULL
should be redefined asnullptr
, but see STL's talk to learn why they decided against it. - Expression template fanatics are delighted to have the trailing return type function syntax in C++11. No more 30-line long return types!
I think I'll stop there!
At one point in time it was argued that one should return by const
value instead of just by value:
const A foo();
^^^^^
This was mostly harmless in C++98/03, and may have even caught a few bugs that looked like:
foo() = a;
But returning by const
is contraindicated in C++11 because it inhibits move semantics:
A a = foo(); // foo will copy into a instead of move into it
So just relax and code:
A foo(); // return by non-const value
As soon as you can abandon 0
and NULL
in favor of nullptr
, do so!
In non-generic code the use of 0
or NULL
is not such a big deal. But as soon as you start passing around null pointer constants in generic code the situation quickly changes. When you pass 0
to a template<class T> func(T)
T
gets deduced as an int
and not as a null pointer constant. And it can not be converted back to a null pointer constant after that. This cascades into a quagmire of problems that simply do not exist if the universe used only nullptr
.
C++11 does not deprecate 0
and NULL
as null pointer constants. But you should code as if it did.