View
26
Download
2
Category
Preview:
DESCRIPTION
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 - PowerPoint PPT Presentation
Citation preview
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
Concepts Modules Reflection Full-featured Garbage Collection “No New libraries (beyond TR1)” TR1 math libraries
Becomes its own standard instead
export auto to declare local variables access declarations Conversion from string literal to ‘char *’
Converts only to ‘char const *’ now Reference counted strings
C99 + TC1 + TC2 + Unicode TR Unicode ECMAscript regular expressions Posix
error handling threads
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
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
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
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!)
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
exception cloning initializer lists range-based for loop garbage collection
shared_ptr binders function array unordered (hashing) containers tuple random numbers regular expressions type traits Adopt C99 library
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
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
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
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
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
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
auto_ptr old function binders unary/binary_function
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
Recommended