C++11/14 Rocks. VS2013 Edition. Alex Korban

Size: px

Start display at page:

Download "C++11/14 Rocks. VS2013 Edition. Alex Korban"

Reginald Blankenship
6 years ago
Views:

1 C++11/14 Rocks VS2013 Edition Alex Korban 1

2 Contents Introduction 18 Type Inference 20 auto decltype Side e ects Trailing return types Non-standard behavior and bugs in Visual Studio const qualifier retained incorrectly by decltype Using class members and this in decltype expressions Referring to a member of a member object inside decltype decltype doesn t respect access control Using a friend function defined inside a class in a decltype expression 29 Lambda Expressions 31 Why do we need this thing? Return type Lambda parameters Lambda body Storing lambdas std::function to the rescue References to outside context Closures Capturing in C

3 Capturing by reference Default capture modes Capturing class members Limitations of capturing Mutable lambdas Conversion to function pointers, nested lambdas, recursion How not to shoot yourself in the foot Rules of thumb for lambdas Lambda syntax in all its glory Non-standard behavior and bugs in VS Nested lambdas lead to slow compile times and huge object files Using a lambda as a comparator for an STL container Using a lambda as a default function argument Using const from enclosing scope inside a lambda Invalid initialization of closure type variables Lambda returning a capturing lambda Lambdas as ternary operator operands Template Features 51 Variadic templates What else are variadic templates good for? Back to the example Working with parameter packs Traversing template parameter packs Constraining parameter packs to one type More places to expand a parameter pack Nested variadic templates One function template, two parameter packs

4 Template aliases Using using instead of typedef Closing angle brackets are o cially allowed to tail-gate Local and unnamed types as template arguments extern template qualifier Default values for function template parameters Non-standard behavior and bugs in Visual Studio Empty parameter pack not handled Variadic template-template parameter troubles Can t use a template alias inside another template Can t define a private static member using a template alias type Default template arguments not applied in class context sizeof... always returns 1 if used in a template alias Class Features 69 In-class initializers for non-static data members Delegating constructors Default methods Deleted methods override and final Extended friend declarations Nested class access rights Non-standard behavior and bugs in Visual Studio default can t be applied to move operations final isn t honored on class templates friend lookup goes too far Nested class access fails with enough nesting

5 Move Semantics and Rvalue References 84 Lvalue/rvalue revision const attribute Reference initialization Rvalue references xvalues Move semantics implementation Moving members std::move Moving it right rvalue references to const values Derived class construction Implementing the move constructor in terms of assignment Check for self-assignment Don t make move constructors explicit Move-only types Non-standard behavior and bugs in Visual Studio Move operations never generated by the compiler Move operations don t disable default copy operations Rvalue reference not recognized correctly Perfect Forwarding 102 The forwarding problem and solution Reference collapsing and templates involving rvalue reference arguments How perfect forwarding works Bonus: the implementation of std::move Range-based for loop 110 Non-standard behavior and bugs in Visual Studio

6 nullptr 114 Non-standard behavior and bugs in VS enum Changes 116 Scoped enums Specifying the underlying type Forward declaration Non-standard behavior and bugs in Visual Studio Explicit Conversion Operators 121 Non-standard behavior and bugs in Visual Studio Raw String Literals 123 The Dream of Uniform Initialization 125 Embrace the braces initializer_list Narrowing conversions Distortions of the uniformity continuum Want a move-only type in your vector? auto + {} <> + {} =? Surprising consequences of narrowing What s the verdict? Non-standard behavior and bugs in Visual Studio New initialization syntax doesn t work for member arrays Aggregate initialization doesn t work in the constructor initialization list. 133 Nested initializer lists can cause crashes or memory leaks Double delete of initializer_list elements

7 Nested initializer lists compile when they shouldn t Can t combine auto with an initializer list of function pointers Uniform initialization of a type with a user-defined destructor Empty parameter pack expansion error when combined with uniform initialization syntax Smart Pointers 139 unique_ptr Custom deleters Array specialization make_unique shared_ptr Custom deleters Thread safety Performance make_shared and allocate_shared enable_shared_from_this shared_ptr<void> Class hierarchies and smart casts weak_ptr Non-standard behavior and bugs in Visual Studio A bool can be assigned to unique_ptr An std::array of unique_ptr s cannot be moved or used within other containers shared_ptr debugging Tuple Types 152 make_tuple Accessing tuple elements

8 Multiple assignment Type information Comparison operators More advanced uses of tuple Iterating over a tuple with template metaprogramming Nested tuples Tuple concatenation Non-standard behavior and bugs in Visual Studio Binding Arguments with std::bind 159 Rearranging and duplicating parameters Passing bound values by reference Using bind with overloaded functions Using bind with member functions Binding data members Using bind with function objects Using bind with lambdas Function composition with nested bind expressions bind vs. lambda expressions Non-standard behavior and bugs in Visual Studio Can t pass a reference to this as an argument to bind Can t use bind with member functions taking rvalue references Can t always use bind with data members Generalized Function Objects 169 Using the function template Parameter and return type conversions Checks and comparisons

9 Performance and code size Non-standard behavior and bugs in Visual Studio No support for move-only types Can t use std::function with member functions void-returning std::function can t swallow return type Regular Expressions 174 Syntax Wildcards Repetition Character sets Character classes Anchors Or Word boundaries Capture groups and back references Escaping Analyzing strings and extracting information Flags Handling multiple matches with iterators Tokenization Searching and replacing Unicode support and localization Attaching a locale to a regex object Compile Time Assertions and Type Traits 189 static_assert Type traits

10 Primary traits Composite traits Type properties Array-specific traits Type relationships Type manipulation const and volatile modifications References Sign conversions Array modifications Pointer modifications Other transformations Additional template aliases in C Non-standard behavior and bugs in Visual Studio static_assert in a class definition Compiling with code analysis may wrongly trigger a static_assert is_function fails to detect a static member function remove_pointer fails with a const pointer to a function is_pod provides wrong results for types with user-defined constructors. 208 is_trivially_copyable fails on arrays of scalar types Construction-related type traits fail on abstract types is_assignable provides wrong results in some cases is_destructible doesn t work is_convertible gives wrong results alignment_of implementation deviates from the standard enable_if combined with two type parameters compile error

11 New STL Containers 212 forward_list array Element operations Container operations Initialization Array as tuple Hash tables unordered_map Custom hash unordered_multimap, unordered_set, unordered_multiset Other STL Improvements 224 Container improvements Support for move semantics Better const_iterator support emplace methods Reducing container capacity Immutable set elements String improvements Miscellaneous Iterator improvements Iterator adapters to support move operations prev()/next() functions C++14 specializations for operator functors in functional New algorithms bool all_of(iter first, Iter last, Pred pred) bool any_of(iter first, Iter last, Pred pred)

12 bool none_of(iter first, Iter last, Pred pred) Iter find_if_not(iter first, Iter last, Pred pred) OutIter copy_if(initer first, InIter last, OutIter result, Pred pred) OutIter copy_n(initer first, Size n, OutIter result) uninitialized_copy_n(initer first, Size n, OutIter result) 232 OutIter move(initer first, InIter last, OutIter result) OutIter move_backward(initer first, InIter last, OutIter result) is_partitioned(initer first, InIter last, Pred pred) pair<outiter1, OutIter2> partition_copy(initer first, InIter last, OutIter1 out_true, OutIter2 out_false, Pred pred) Iter partition_point(iter first, Iter last, Pred pred) RAIter partial_sort_copy(initer first, InIter last, RAIter result_first, RAIter result_last) RAIter partial_sort_copy(initer first, InIter last, RAIter result_first, RAIter result_last, Compare comp) bool is_sorted(iter first, Iter last) bool is_sorted(iter first, Iter last, Compare comp) Iter is_sorted_until(iter first, Iter last) Iter is_sorted_until(iter first, Iter last, Compare comp). 234 bool is_heap(iter first, Iter last) bool is_heap(iter first, Iter last, Compare comp) Iter is_heap_until(iter first, Iter last) Iter is_heap_until(iter first, Iter last, Compare comp) pair<const T&, const T&> minmax(const T& a, const T& b) pair<const T&, const T&> minmax(const T& a, const T& b, Compare comp)

13 pair<const T&, const T&> minmax(initializer_list<t> lst). 235 pair<const T&, const T&> minmax(initializer_list<t> lst, Compare comp) const T& min(initializer_list<t> lst) const T& min(initializer_list<t> lst, Compare comp) const T& max(initializer_list<t> lst) const T& max(initializer_list<t> lst, Compare comp) pair<iter, Iter> minmax_element(iter first, Iter last) pair<iter, Iter> minmax_element(iter first, Iter last, Compare comp) void iota(iter first, Iter last, T value) Random Number Facility 238 Engines mersenne_twister_engine linear_congruential_engine subtract_with_carry_engine random_device Engine adapters seed_seq Distributions Uniform distributions Normal distributions Bernoulli distributions Poisson distributions Sampling distributions Non-standard behavior and bugs in Visual Studio

14 Rational Arithmetic and Time Support Libraries 246 Rational number representation and manipulation Time utilities Time durations Clocks and time points Time points Non-standard behavior and bugs in Visual Studio Concurrency Support: High Level 258 Memory model overview Asynchronous code execution Launch policies and lazy evaluation future Polling and waiting for task completion Getting multiple threads to wait for one result Non-standard behavior and bugs in Visual Studio async can t handle move-only arguments Initialization of statics not thread-safe Non-blocking future destructor Concurrency Support: Building Blocks 268 Rolling your own threads Joining threads Detaching threads Thread IDs and native handles promise Helper functions for use with threads packaged_task

15 Non-standard behavior and bugs in Visual Studio thread constructor doesn t take rvalue reference arguments Calling join after main exits causes the program to hang Wrong exception type thrown by promise future::get doesn t throw when shared state in packaged_task is abandoned packaged_task wrapping a void or reference-returning function isn t movable Incorrect handle value in a default-constructed thread object Concurrency Support: Exceptions, Thread Local Storage 280 Manual exception handling in threads exception_ptr Functions for working with exception_ptr Thread local storage Non-standard behavior and bugs in Visual Studio Concurrency Support: Synchronization 285 Mutexes Timed mutexes Locking multiple mutexes Locks call_once Condition variables Limiting wait time Other lockable types notify_all_at_thread_exit A note on const and mutable Non-standard behavior and bugs in Visual Studio

16 Concurrency Support: Atomic Data Types and Operations 298 Atomic data types Alternative C-style interface Atomic flag Low level atomic interface Fences Non-standard behavior and bugs in Visual Studio Miscellaneous Features 307 Alignment addressof template Using type_info in containers bitset and valarray improvements New stream functionality system_error header C99 compatibility Deprecated and Future Features 310 Deprecated features Beyond Visual Studio C Return type deduction for functions Generic lambdas Extended capturing in lambdas Revised restrictions on constexpr functions constexpr variable templates More language changes Beyond C

17 Conclusion 317 Contact Information and License Agreement 318 License agreement

C++11/14 Rocks. Clang Edition. Alex Korban

C++11/14 Rocks. Clang Edition. Alex Korban C++11/14 Rocks Clang Edition Alex Korban 1 Contents Introduction 9 C++11 guiding principles... 9 Type Inference 11 auto... 11 Some things are still manual... 12 More than syntactic sugar... 12 Why else