Gentle introduction to modern C++
Download as PPT, PDF•0 likes•599 views
The document is a presentation by Mihai Todor that introduces modern C++ features, focusing primarily on C++11. It covers topics such as move semantics, smart pointers, range-based for loops, and lambda functions while highlighting the advantages and complexities of using C++. The presentation aims to enhance understanding and utilization of these improved language features to write more efficient and expressive C++ code.
Gentle introduction to modern C++
- 1. Gentle* Introduction to Modern C++ Mihai Todor * Well, maybe not so gentle Disclaimer: This presentation is focused on C++11 features and assumes a basic understanding of C++
- 2. Intro I C++ is boring / hard to get right The C++ compilers are buggy We don’t want to mess with it
- 3. Intro II And your code looks like this*: *That’s actually C# code, but you get the point
- 5. Intro IV In spite of the fact that it lacks some of the C# flexibility and compactness, C++ is a beautiful language, having a rich syntax, which enables a high degree of expressivity and abstraction, with a fine grained control over resource consumption.
- 6. Intro V If done right, in C++ you only pay for what you use If done wrong, in C++ you blow your entire leg off, not just a toe
- 7. Intro VI The compiler is never* wrong C++11 features alleviate much of the pain we had to endure when architecting code The STL is becoming richer and more flexible Compilers are adopting new features much faster *well, maybe sometimes, but it usually requires more than 10 minutes of coding to stumble upon a legit compiler bug
- 8. Some modern C++ features Move semantics Auto nullptr Range-based for loops override and final Strongly-typed enums Lambdas Explicitly defaulted and deleted functions Smart pointers
- 9. Move semantics Copies are expensive! Want speed, pass by value (not always*) Moving variables can be as cheap as a pointer swap Classes can now have move constructors and move assignment operators * http://juanchopanzacpp.wordpress.com/2014/05/11/want-speed-dont-always-pass-by-value/
- 10. Move semantics II In C++11, an expression can be: The && operator has been introduced in order to declare an rvalue reference Diagram shamelessly ripped from here: http://stackoverflow.com/a/3601748/1174378
- 11. Move semantics III xvalue (an “eXpiring” value) – also refers to an object, usually near the end of its lifetime A type Type followed by && represents an rvalue reference xvalues are explicit moves, created by std::move prvalue (“pure” rvalue) - an rvalue that is not an xvalue (implicit moves)
- 12. Move semantics IV A reference type that is declared using & is called an lvalue reference A reference type that is declared using && is called an rvalue reference.
- 13. Move semantics V Powerful tools in the <utility> header: std::move std::forward std::make_move_iterator A thorough explanation for std::move and std::forward: http://blogs.msdn.com/b/vcblog/archive/2009/02/03/rvalue-references-c-0x-features-in-vc10-part-2.aspx
- 14. auto Repurposed keyword (initially, it designated a storage duration specifier) Similar to C#’s var keyword Reduces code verbosity by deducing a variable’s type from the initializer Also allows return type deduction (C++14) Potential for abuse!
- 15. nullptr Eliminates the ambiguous conversion between NULL (#defined as 0) and integral types Denotes a value of type std::nullptr_t Converts implicitly to bool (as false) and null pointer values of any type You don’t have to test a variable for null with both NULL and nullptr! int *pointer = LegacyGetInt(); if (pointer != nullptr && pointer != NULL)//both tests are equivalent
- 16. Range-based for loops They resemble the C# foreach statement Syntax: for (auto value: collection) {/* do stuff */} the type specifier of value determines how the collection items are iterated: by value, by reference, by const reference, etc Can be used with any type for which non-member overloads of the begin() and end() functions are implemented see NonMemberBeginAndEnd.cpp
- 17. override and final If override is added to the declaration of a virtual method, which does not override a virtual method from the base class, the compiler emits an error If final is added to the declaration of a virtual method, then derived classes are not allowed to override this method in C++, the virtual specifier is optional for derived class override methods If final is added to the declaration of a class, then no other classes can derive from that class. This resembles C#’s sealed keyword
- 18. Strongly-typed enums Eliminate issues caused by regular enums: namespace pollution and implicit conversions For now, there is no simple way to use these in the same way as a C# flags enum (tagged enumeration) The enum class underlying type can be specified by the user: enum class Colors : std::int8_t { RED = 1, GREEN = 2, BLUE = 3 }; Extracting underlying values of an enum class requires an explicit cast: auto blue = static_cast<std::underlying_type<Colors>::type>(Colors::Blue);
- 19. Smart pointers They provide reference counting in order to enable the automatic release of memory Concerns about performance degradation / extra memory consumption are, indeed, legitimate, but in most cases we are not creating millions of objects on the heap to have really tight constraints std::unique_ptr – Guarantees unique ownership of a memory resource. It cannot be copied (only moved to another std::unique_ptr). Created with std::make_unique (C++14) std::auto_ptr is obsolete! Please replace it on sight with std::unique_ptr.
- 20. Smart pointers II std::shared_ptr – Allows shared ownership of a memory resource Created with std::make_shared (C++11) std::weak_ptr – Holds a reference to an object managed by an std::shared_ptr. does not contribute to the reference count Ensures that cycles are broken std::static_pointer_cast, std::dynamic_pointer_cast and std::const_pointer_cast are your friends!
- 21. Lambdas C++11 introduces support for anonymous functions, namely lambdas Fine-grained control over variable capture By default, variables captured by value are const, unless the mutable specification is present We can have recursive lambdas
- 22. Lambdas II Syntax (shamelessly ripped from MSDN*) 1. lambda-introducer (Also known as the capture clause) 2. lambda declarator (Also known as the parameter list). Optional! 3. mutable (Also known as the mutable specification) . Optional! 4. exception-specification (Also known as the exception specification) . Optional! 5. trailing-return-type (Also known as the return type) . Optional! 6. compound-statement (Also known as the lambda body) * http://msdn.microsoft.com/en-us/library/dd293603.aspx
- 23. Explicitly defaulted and deleted functions The rules which specify when the implicitly- declared default constructor and destructor, copy and move constructors and copy and move assignment operators get generated are somewhat complex, so C++11 allows you to force the compiler to generate them or not, via the =default and =delete specifiers. Please take the Rules of three/five/zero into account when using these specifiers!
- 24. Explicitly defaulted and deleted functions II Let’s design a trivial object, which can be constructed and moved, but not copied class UniqueObject { public: UniqueObject() =default; ~UniqueObject() =default; UniqueObject(const UniqueObject &obj) =delete; UniqueObject &operator=(const UniqueObject &obj) =delete; UniqueObject(UniqueObject &&obj) =default; UniqueObject &operator=(UniqueObject &&obj) =default; };
- 25. More modern C++ features? static_assert and type traits Mutable Constructor delegation http://www.nullptr.me/2012/01/17/c11-delegating-constructors/ Uniform initialization http://programmers.stackexchange.com/questions/133688/is-c11- uniform-initialization-a-replacement-for-the-old-style-syntax rvalue reference for *this http://stackoverflow.com/questions/12306226/what-does-an-ampersand- after-this-assignment-operator-mean Many more…
- 26. Follow me on: Twitter: @MihaiTodor Linkedin: www.linkedin.com/mtodor See my activity on StackOverflow: http://stackoverflow.com/users/1174378/mihai-todor