2. C++98 Initial Standard ~7 years C++03 Revised standard Limited to bug fixing ~ 5 years TR1 Pure library extension ~3 years C++11 Significant new features to language and library Many more bug fixes than C++03 ~8 years work

3.  Work under auspices of ISO SC22 WG21  Typically 5-10 national bodies present at any meeting  More participants online  Meet 2-3 times a year for week-long meetings  Typical attendance in 50-100 range  4 active working groups  Core  Library  Evolution  Concurrency  Work continues online at a slower pace

4. > 50 New Language Features New Libraries Built on top of a wider set of standards What’s new? Revised Library for new language Resolved several hundred defect reports Cleaned up presentation What’s changed?

5.  Concepts  Modules  Reflection  Full-featured Garbage Collection  “No New libraries (beyond TR1)”  TR1 math libraries  Becomes its own standard instead

6.  export  auto to declare local variables  access declarations  Conversion from string literal to ‘char *’  Converts only to ‘char const *’ now  Reference counted strings

7.  C99 + TC1 + TC2 + Unicode TR  Unicode  ECMAscript regular expressions  Posix  error handling  threads

8. New Memory Model Define race conditions Limit optimisations within a single thread Thread local storage Parallel initialization/shutdown Low level primitives atomic operations and fences thread wrappers Mutexes and locks High level primitives Futures asynch

9. Incidental Programmer Ease of use Syntax cleanup Large Scale systems Program Correctness Expressiveness Interoperability Performance Efficiency Concurrency

10. Declarations auto alias templates raw string literals UTF8 literals Initialization delegating constructors forwarding constructors member initializers list initialization Facilities garbage collection new for- loop lambda expressions

11. Simplified rules.template typename right-angle-brackets reference collapsing nested classes are members extended SFINAE Extended syntax Consistent initialization default template parameters for function templates sizeof (non-static) data members linkage for local templates

12.  explicit override ‘keyword’  nullptr  strong enum  forwarding constructors ('strong' typedef)  static_assert  explicit conversion functions  conditionally supported behavior -> more diagnosable errors  deleted functions  detect array-new overflow  detect narrowing conversions (with new syntax)  noexcept destructors

13.  New data types  long long  char16_t  char32_t  extended integral types  decltype  auto function declarations  extended friends  extern template  variadic templates  variadic macros  _Pragma  move semantics  perfect forwarding  defaulted functions  user defined literals  initializer lists  attributes  trivial types  fixed-base for enums  forward declare enums  enum class

14. long Unicode char typesStandard layout typesAlignment specifiersC99 preprocessor

15. Serial rvalue references constexpr trivial types noexcept final virtual functions alignment control Concurrent memory model thread local storage atomic operations

16.  inline namespaces  exception cloning  native support for type traits  __func__ and updated assert macro  implicit move constructor  implicit move-assignment operator  reference qualifiers  anonymous namespace has internal linkage  concatenate string literals of different type

17.  Almost doubled in size (by page count)  Huge effort to clean up specification  Simplify through use of common definitions  More precise contracts, using those terms  Learned a lot from the ‘concept’ experiments  Resolved roughly 6x as many issues as TC1  (although many came from new features as library evolved!)

18. Incidental Programmer New Library Components Enhanced APIs Large Scale systems Support wider standards Better error detection Enhanced resource management Performance Apply new language features Concurrency

19.  rvalue references  variadic templates  sequence constructors  constexpr  long long and extended integral types  Unicode character types  explicit bool conversion operators  deleted copy semantics  noexcept  nullptr

20.  exception cloning  initializer lists  range-based for loop  garbage collection

21.  shared_ptr  binders  function  array  unordered (hashing) containers  tuple  random numbers  regular expressions  type traits  Adopt C99 library

22.  unique_ptr and move_iterator  forward_list  atomic primitives  thread launching  thread synchronization  futures and asynch  time interval support  compile-time ratio arithmetic  clocks  portable handling of system errors  nested_exception  type_index

23.  all_of/any_of/none_of  find_if_not  copy_n/copy_if  move / move_backward  partition_copy  is_partitioned/partition_point  is_sorted/is_sorted_until  is_heap/is_heap_until  next/prev  iota  minmax / minmax_element  variadic min/max/minmax  uninitialized_copy_n

24.  emplace  cbegin/cend  consistent const_iterator to locate elements  consistent overload on std::string as well as const char *  thread-safe strings (no reference counting)  simple numeric string / std::string conversions  code conversion for wide/narrow strings  new facets : time and money  better floating point support (iostream flags / num limits)  allocator upgrade

25.  move semantics  random numbers  allocator for shared_ptr/function  shared_ptr aliasing  shared_ptr factories  atomic shared_ptr interface  more type traits : decay/conditional/enable_if  alignment calculators (type traits)  tuple concatenation  equality comparison of hashing containers

26.  basic thread-safe guarantee through library  Can safely use any library object from a single thread without locking  Sharing an object between threads requires user to synchronize access  Read-only access generally safe without locking, but a single write means reads must synchronize too!  basic_string cannot be copy-on-write  shared_ptr must have thread-safe reference counting  thread-safe access to handler functions, e.g. at_exit

27.  hidden header dependencies  swap now in rather than  C/C++ std header implementations  allocators  vector  bitset constructors  ios_base::failure derives from system_error

28.  auto_ptr  old function binders  unary/binary_function

29.  Most modern compilers implement a subset  static_assert  auto  decltype  rvalue references  lambda  gcc 4.6 has widest support  Clang getting good coverage if you want to build your own