what C++ idioms are deprecated in C++11

 

With the new standard, there are new ways of doing things, and many are nicer than the old ways, but the old way is still fine. It's also clear that the new standard doesn't officially deprecate very much, for backward compatibility reasons. So the question that remains is:

What old ways of coding are definitely inferior to C++11 styles, and what can we now do instead?

In answering this, you may skip the obvious things like "use auto variables".

  • 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 contains provide 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 explicitely denied. This is applicable to preventing heap allocation (ie, =delete for member operator 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 template result_of should be replaced with decltype. I think result_of uses decltype 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 as nullptr 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 lines 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.

    链接地址: http://www.djcxy.com/p/40476.html

    上一篇: 在C ++ 11中安全吗？

    下一篇: 在C ++ 11中弃用了哪些C ++习惯用法