1 / 29

C++ 2011 in haste

C++ 2011 in haste. A Quick History Lesson. Standards Process. 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

bryony
Download Presentation

C++ 2011 in haste

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. C++ 2011 in haste

  2. A Quick History Lesson

  3. Standards Process • 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. Changes

  5. What was missed? • Concepts • Modules • Reflection • Full-featured Garbage Collection • “No New libraries (beyond TR1)” • TR1 math libraries • Becomes its own standard instead

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

  7. Embrace Standards • C99 + TC1 + TC2 + Unicode TR • Unicode • ECMAscript regular expressions • Posix • error handling • threads

  8. Concurrency

  9. Language Updates

  10. Ease of use

  11. Syntax cleanup:

  12. Correctness: • 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. Expressiveness: • 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. Interoperability

  15. Efficiency

  16. Miscellaneous • 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. Library: -------- • 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. Library Updates

  19. Adopt Language Features: • 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. Support Language Features: • exception cloning • initializer lists • range-based for loop • garbage collection

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

  22. New features: • 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. New Algorithms • 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. Enhancements: • 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. TR1 Enhancements: • 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. Thread Safety • 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. Clean-up • hidden header dependencies • swap now in <utility> rather than <algorithm> • C/C++ std header implementations • allocators • vector< bool > • bitset constructors • ios_base::failure derives from system_error

  28. Deprecated: • auto_ptr • old function binders • unary/binary_function

  29. Where can we get it? • 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

More Related