![Lambda functions 24 60/
Also called anonymous functions
Lambda functions are useful to:
➔
Keep code localized and contained
➔
Pass callbacks to functions, event managers or threads!
Lambda signature
➔ [ capture-list ] ( params ) mutable → ret { body }
Capture List
➔
[a,&b] → a captured by value and b is captured by reference.
➔
[&] → captures all automatic variables odr-used in the body of the lambda by reference
➔
[=] → captures all automatic variables odr-used in the body of the lambda by value
➔
[] → captures nothing
Mutable specifier (optional)
➔
Allows body to modify the parameters captured by copy, and to call their non-const member
functions. It means it can mutate (change its own state).
More information at: http://en.cppreference.com/w/cpp/language/lambda
One Definition Rule](https://image.slidesharecdn.com/ctalkv2-160421143246/85/C-14-Modern-Programming-for-Demanding-Times-24-320.jpg)
C++14 - Modern Programming for Demanding Times
- 1. NAP Talks C++14: Modern Programming for Demanding Times Speaker: Carlos Miguel Ferreira Position: PhD Student and IT Researcher Contact: carlosmf.pt@gmail.com
- 2. Layout 1st Part – Some History ➔ Some background about C++ ➔ Philosophy ➔ The International Standard ➔ Boost ➔ Standard Template Library Break Time 2 60/ 2nd Part – The Basics ➔ Standard Types ➔ Methods ➔ Pointers and References ➔ Lambda Functions ➔ Casting in C++ ➔ Structures and Classes 4th Part - Extreme C++ ➔ Automatic Type Deduction ➔ Templates & Meta-Programming ➔ SFINAE rule ➔ Type Traits 3rd Part – Increased complexity ➔ Exceptions ➔ Smart Pointers ➔ Generic Containers ➔ Generic Algorithms ➔ Multi-threading ➔ Synchronization
- 3. 1st Part 3 60/ C++14 History, Philosophy and Standards Why waste time learning when ignorance is instantaneous? – Hobbes
- 4. C++ History 4 60/ The author: Bjarne Stroustrup Development starts by the around 1978, during his PhD at Churchill College, Cambridge. Took inspiration from Simula ➔ Known as the first language to support Object Oriented Programming. ➔ But it was to slow for practical use... In the beginning, It was called “C with Classes” First compiler: Cfront (derived from Cpre) ➔ Under the hood, just a translator ● Translating classes to pure C. ● Self-hosting compiler ● Supported classes, basic inheritance, inlining, default arguments ● It did not officially supported the OO paradigm...
- 5. C++ History 5 60/ In 1983: ➔ The language changes the name to C++ ➔ First implementation in use In 1986: ➔ First commercial release (Cfront PC port) ➔ But still no available standard… In 1987: ➔ GNU C++ compiler v0.9 beta is released by Richard Stallman. ➔ New features were added: ● Virtual functions, overloading, references… ● It could then be called an Object Oriented Programming Language! ● “The C++ Programming Language 1st Ed.” book is released. Free Software Foundation Founder
- 6. C++ Philosophy 6 60/ Some of the philosophical rules that guide the C++ language development. Not All! Know more from the paper “Evolving a language in and for the real world: C++ 1991-2006” DOI: 10.1145/1238844.1238848 General ➔ C++ evolution must be driven by real problems. ➔ Every feature must have a reasonably obvious implementation. ➔ C++ is a language, not a complete system. ➔ Don’t try to force people to use a specific programming style. Technical ➔ Locality is good. ➔ Avoid order dependencies. ➔ Preprocessor usage should be eliminated. Low-Level Support ➔ Leave no room for a lower-level language below C++ (except assembler). ➔ What you don’t use, you don’t pay for (zero- overhead rule). Design ➔ Say what you mean. ➔ Provide facilities for program organization. ➔ All features must be affordable.
- 7. C++ International Standards (ISO) 7 60/ What are Technical Standards? Even better, what are International Standards? Technical Standards A technical standard is an established norm or requirement in regard to technical systems. It is usually a formal document that establishes uniform engineering or technical criteria, methods, processes and practices. In contrast, a custom, convention, company product, corporate standard, etc. that becomes generally accepted and dominant is often called a de facto standard. International Standards International standards are one way of overcoming technical barriers in international commerce caused by differences among technical regulations and standards developed independently and separately by each nation, national standards organization, or company. Technical barriers arise when different groups come together, each with a large user base, doing some well established thing that between them is mutually incompatible. Establishing international standards is one way of preventing or overcoming this problem. According to Wikipedia...
- 8. C++ International Standards (ISO) 8 60/ The C++ Standard intends to: ➔ Create an abstraction of a general computing machine. ➔ Defines a very rigid technical specification, asserting code portability. ● It Defines Behaviours, and more important Undefined Behaviours! ➔ Defines the Standard Library (std::) behaviour. Very Important! ● You will see lots of "the behaviour is defined/undefined" indications, in the C++ reference manuals. ➔ It gave us the Standard Template Library (STL) The C++ Standard is maintained by a Committee: ➔ Composed by companies, academics and freelancers representatives. ➔ Very strict review of new additions to the standard. ➔ Promote C++ learning and adoption. ➔ They usually take some time… ● First Commercial was release in 1987... ● But the 1st ISO only came out in 1998! (C++98: ISO/IEC 14882:1998)
- 9. C++ International Standards (ISO) 9 60/ C++98 ➔ The first one ➔ 1998 ➔ ISO/IEC 14882:1998 ➔ Single Threading by design. C++03 ➔ 2003 ➔ ISO/IEC 14882:2003 Existing C++ Standards C++11 ➔ 2011 ➔ ISO/IEC 14882:2011 ➔ Multi-threaded by design C++14 ➔ 2014 ➔ ISO/IEC 14882:2014 C++17 ➔ Expected 2017 Old and quirky New and Improved! vector<vector<int> > vector_of_int_vectors; The lack of a space between the “> >” was an error in C++03. The compiler got confused with the “>>” operator. More information at: https://isocpp.org/std/status
- 10. C++ Boost→ 10 60/ “Boost provides free peer-reviewed portable C++ source libraries. We emphasize libraries that work well with the C++ Standard Library. Boost libraries are intended to be widely useful, and usable across a broad spectrum of applications. The Boost license encourages both commercial and non-commercial use. We aim to establish "existing practice" and provide reference implementations so that Boost libraries are suitable for eventual standardization. Ten Boost libraries are included in the C++ Standards Committee's Library Technical Report (TR1) and in the new C++11 Standard. C++11 also includes several more Boost libraries in addition to those from TR1. More Boost libraries are proposed for standardization in C++17.” The Boost Libraries ➔ First release in 1998 ➔ After the Standard Library, Boost is the most important library available to the C++ development community. ➔ Many of its own libraries made their way to the C++11 standard! ● Arrays ● Regular Expressions ● Complex numbers ➔ More will be added to C++17. ● Filesystem More information at: https://www.boost.org
- 11. C++ Standard Template Library→ 11 60/ What is the Standard Template Library (STL)? ➔ A set of Generalized Structures ➔ A set of Algorithms for Generalized Structures ● The key here is generalized. ● STL does not deal in specifics! ➔ Separates algorithms from storage in a way that is classical (as in math) but not object oriented. ➔ It separates policy decisions of algorithms, such as sorting and search criteria, from the container, and the element class. ➔ Standardized Structures and Behaviours! Some of the available containers <array> <list> <map> <queue> <set> <stack> <vector> and many others... More information at: http://en.cppreference.com/w/cpp/container Later, I will talk more about these containers The result? Unsurpassed flexibility and performance.
- 12. C++ 14 12 60/ This talk is about the C++14 Standard. Threads Containers Lambda Expressions Automatic Type deduction Ranged for Loops Move Constructors Initialization Lists Type Traits Smart Pointers
- 13. 2nd Part 13 60/ C++14 Lets start with the basics! A programmer is a machine for turning caffeine into code. – A programmer
- 14. Including 14 60/ C++ has many new features not present in C To maintain compatibility and to keep C libraries usable in C++ environments, the standard provides compatibility header files: <cassert> (assert.h) → C Diagnostics Library <cctype> (ctype.h) → Character handling functions <cerrno> (errno.h) → C Errors <csignal> (signal.h) → C library to handle signals <cstdio> (stdio.h) → C library to perform Input/Output operations <cstdlib> (stdlib.h) → C Standard General Utilities Library <cstring> (string.h) → C Strings <ctgmath> (tgmath.h) → Type-generic math <ctime> (time.h) → C Time Library <cuchar> (uchar.h) → Unicode characters <cwchar> (wchar.h) → Wide characters <cwctype> (wctype.h) → Wide character The C precedes the name of the classical C header. More information at: http://en.cppreference.com/w/cpp/header
- 15. The main function. 15 60/ Global method term used to catch unhandled exceptions. Uncaught exception handler is registered. Program arguments are caught and std::strings are created. Don’t worry about the Exception I will talk about them later... std::exception is throwed.
- 16. Namespaces 16 60/ Same method declared in different namespaces. Result: Namespaces are great for code management! Explicitly choose the namespace Or specifically state your intentions The std:: namespace contains every C++ standardized type, function and object.
- 17. Standard Types → void, bool and char 17 60/ The C++ 14 standard specifies the behaviour for a set of types. ➔ Most are from C99 standard. ➔ Fundamental types are not inside the namespace std:: Void type ➔ void ➔ nullptr literal ➔ std::nullptr_t type Boolean Type ➔ bool → true or false Character types ➔ char (signed/unsigned) ➔ wchar_t ➔ char16_t ➔ char32_t Special types! Standard dictactes there cannot be void type arrays. void size is undefined! The most efficiently processed character representation on the target system (size undefined). The necessary size to represent any kind of supported character code unit (32bits for Unicode systems). Large enough for: ● UTF-16 ● UTF-32 Size is 1 byte
- 18. Standard Types i→ nteger, float and double 18 60/ Floating point types (IEEE-754)Integer types ➔ float → single precision ➔ double → double precision ➔ long double → extended precision int (signed/unsigned)→ 2 bytes at least ➔ short –----→ 2 bytes at least ➔ long –----→ 4 bytes at least ➔ long long –----→ 8 bytes at least More information at: http://en.cppreference.com/w/cpp/language/types Defined by Standard ➔ Sizes are undefined. ➔ Instead, the standard defines the precision behaviour, and special values. ● Infinity ● Negative Zero ● Not-a-Number (NaN) ➔ Arithmetic operations are also specified
- 19. Standard Types Fixed Width Integers→ 19 60/ Fixed Width Integer types (all within std::) int8_t int16_t int32_t int64_t int_fast8_t int_fast16_t int_fast32_t int_fast64_t int_least8_t int_least16_t int_least32_t int_least64_t intmax_t intptr_t More information at: http://en.cppreference.com/w/cpp/types/integer uint8_t uint16_t uint32_t uint64_t uint_fast8_t uint_fast16_t uint_fast32_t uint_fast64_t uint_least8_t uint_least16_t uint_least32_t uint_least64_t uintmax_t uintptr_t ➢ Integer type with width of exactly 8, 16, 32 and 64 bits Signed Unsigned ➢ Fastest integer type with width of at least 8, 16, 32 and 64 bits ➢ Smallest integer type with width of at least 8, 16, 32 and 64 bits ➢ Maximum width integer type ➢ Integer type capable of holding a pointer
- 20. Standard Types Enumerators→ 20 60/ Specifying the enum memory size ➔ This is a hidden inheritance Enumerations declarations ➔ By default, the size is int Get the defined enumerations using the :: scope resolution operator
- 21. Standard Types Strings→ 21 60/ Available at <string> Regular expressions at <regex> ➔ String → char ➔ wstring → wchar_t ➔ u16string → char16_t ➔ u32string → char32_t More information at: http://en.cppreference.com/w/cpp/header/string These types use these fundamental types underneath Initializations Attributions Concatenations Iterations Compatibility
- 22. Methods 22 60/ Result Method Overloading The names are equal ➔ Different signatures for equivalent behaviours ➔ Keep code clean, elegant! ➔ No method naming Hell!
- 23. Pointers, References and the const specifier 23 60/ Pointers and References (prefer references, unless working with C) Pointers are useful but: ➔ Is there really an object at address 0x123? ➔ Good code always checks if memory is accessible. ➔ Memory checks cost processing time... ➔ A pointer value could be NULL References provide assurance: ➔ Object must exists! (sort of) The const type qualifier provides robustness: ➔ Forbids state modification Yes, you can always hack it, but seriously… don’t… ➔ Always avoid this ● Unless you’re using a buggy library… ➔ Never ever in your life do this!!! ● You have been warned! ● The segfault Hell awaits you, if you ignore...
- 24. Lambda functions 24 60/ Also called anonymous functions Lambda functions are useful to: ➔ Keep code localized and contained ➔ Pass callbacks to functions, event managers or threads! Lambda signature ➔ [ capture-list ] ( params ) mutable → ret { body } Capture List ➔ [a,&b] → a captured by value and b is captured by reference. ➔ [&] → captures all automatic variables odr-used in the body of the lambda by reference ➔ [=] → captures all automatic variables odr-used in the body of the lambda by value ➔ [] → captures nothing Mutable specifier (optional) ➔ Allows body to modify the parameters captured by copy, and to call their non-const member functions. It means it can mutate (change its own state). More information at: http://en.cppreference.com/w/cpp/language/lambda One Definition Rule
- 25. Lambda functions 25 60/ More information at: http://en.cppreference.com/w/cpp/language/lambda A lambda is created and saved in f1 and f2 Lambda Functions in action (using std::function type in this example) But f1 does not modify the x value despite being mutable. f2 is not mutable but modifies x. Why? f1 is mutable. x is passed by copy. f2 is not mutable and is not allowed to change its state. To f2, x is passed by reference. f1 copies x and then changes it, within its own context. f2 changes x because x is passed by reference. f2 is not mutating its own state.
- 26. Structures and Classes 26 60/ More information at: http://en.cppreference.com/w/cpp/language/class C++ provides two ways of structuring complex objects Structures Classes ➔ By default, attributes and methods are public (friendship) ➔ Can be used with C code ➔ By default, attributes and methods are private (friendship) ➔ Cannot be used with C Code In truth, these are the only differences between Structs and Classes in C++. Both Types support: ➔ Constructors ➔ Polymorphism through inheritance ➔ Friendship ➔ Operator Overloading ➔ Casts Operators ➔ They can even be mixed (classes inheriting from structs and vice versa) ➔ But classes are the standard for oriented programming.
- 27. Structs and Classes Vocabulary→ 27 60/ More information at: http://en.cppreference.com/w/cpp/language/class Vocabulary is important when talking about Object Oriented Programming Structs Classes Memory Allocation Object Object Instantiation Object Blueprints
- 28. Structs and Classes Breaking with the old→ 28 60/ Code organization is VERY important when talking about Object Oriented Programming Past Ghosts from C code organization You were led to believe that: ➔ For each .hpp header, there should be a .cpp module. ➔ Header should only have prototypes, modules should have the real code. Nothing could be further from the truth… It is possible to develop C++ code using only headers, while having only 1 module. ➔ Location where main is implemented. ➔ Location where static objects and class attributes are declared. ➔ Code in header files can be inlined!
- 29. Classes Attributes and Access Management→ 29 60/ By default, Class attributes are private Enumeration can be defined within classes static attribute. These are shared between all Top instantiations. Private method. Can only be called from Top context or Top friends (friendship explained later). Private default constructor. There can be no Top X() Protected attributes. A class that inherits from Top, can access these attributes/methods. private public private protected public Public attributes. These can be accessed by everyone and everything. Be careful with these, if not const. State can be modified without the object knowing about such. Rule of Thumb! Object attributes should always be private, with the exception of const attributes.
- 30. Classes Constructors and Destructor→ 30 60/ Result Private unique pointer to string with pointer default initialization Copy Constructor Move Constructor Destructor Default Constructor Explicit String Copy Constructor Acessing unique pointer after move Undefined Behaviour! More information at: http://en.cppreference.com/w/cpp/language/classes
- 31. Classes Implicit Copy Constructor→ 31 60/ Implicit construction Implicit constructors can be a source of confusion. B as a copy constructor for A C as a copy constructor for B C can be built using an object A using B copy constructor as an intermediate. C++ only travels 1 hop! ➔ C calls B calls A → Allowed! ➔ D calls C calls B calls A → Not Allowed! Avoid the implicit construct by marking a copy/type constructor as explicit
- 32. Classes → const Methods and Attributes 32 60/ Result const attribute. Once initialized, it cannot be modified (immutable). A const attribute can only be returned using a const modifier with the returned value. const modifier should be used when returning the reference of an internal attribute. const modifier for the method means, the method does not modify the objet internal state Never ever do this. It exposes to modification, the private attribute. Moving a string. string_moved was cleared.
- 33. Classes Operator Overloading→ 33 60/ Result Array subscript operator to access a specific character from attr. Sum operator to concatenate the attr from two different Top objects. Assignment operator to assign a new value to attr coming from another Top object. Stream insertion operator ➔ friend operator ➔ NOT a Top class operator! ➔ It is an Out-of-Member Operator ➔ No this reference access
- 34. Classes Casting Operators→ 34 60/ Cast Operators ➔ It allows an object to transformed to other types of objects. ➔ By default, casts are implicit! ➔ Like the constructors, casts can be declared explicit. Result Explicit cast Implicit cast
- 35. Classes Inheritance & Polymorphism→ 35 60/ Polymorphism a fundamental concept in C++ It is divided into two different types Run-time Polymorphism ➔ Implements a virtual table (v-table) to provide polymorphism. ➔ Overhead due to v-table. ➔ Requires Run Time Type Information (RTTI) Compile-Time Polymorphism ➔ Methods are not overridden ➔ No v-table ➔ No overhead ➔ No dynamic casting ➔ Good for code reuse Disclaimer I will not talk about Multiple-Inheritance It is a complex world...
- 36. Classes Polymorphic Inheritance→ 36 60/ Abstract Class ➔ Classes with a pure virtual method (= 0) Pure Virtual Methods must be implemented by lower classes. Circle and Square inherit from Figure ➔ In order for a method to be overridden, it needs to be declared as virtual. ➔ A polymorphic object is an object with at least one virtual method. Polymorphic objects must have a virtual destructor
- 37. Classes Polymorphic Inheritance→ 37 60/ Result Polymorphism allows a programmer to deal with the abstract. ➔ A Figure list (Figure is the abstraction) ➔ Circle and Square are Figure implementations The Virtual Table ➔ Calls are made to Circle and Square implementations, respectively ➔ The virtual table pointer is located in memory, along with the Information Type about the Polymorphic class (extra 8 bytes in x86_64).
- 38. Classes Non-Polymorphic Inheritance→ 38 60/ Person_Name and Dog_Name inherit from Name There are no Virtual members/constructs
- 39. Classes Non-Polymorphic Inheritance→ 39 60/ Result No Polymorphism ➔ Methods are not overridden ➔ There is no V-Table
- 40. Classes Friendship→ 40 60/ Friendship ➔ It allows an object to grant access to specific entities ➔ Entities can be: ➢ Objects ➢ Methods ➔ Friend declaration can be used for prototype. ➔ Beware! Objects internal state can be exposed if misused.
- 41. Casting in C++ 41 60/ C++ provides 4 types of Casting Static Casting Dynamic Casting Reinterpret Casting Const Casting ➔ Explicit casting ➔ Non-Polymorphic Casting ➔ Type checks are performed during compile-time ➔ Checks if conversion is possible ➔ Less restrictive than Dynamic Casting ➔ Used for Polymorphic Casting ➔ Performed during run-time ➔ The safest type of casting (and most expensive) ➔ The NUCLEAR CAST ➔ Direct conversion, just like C Casts ➔ Performs absolutely no type checks ➔ Can generate SegFaults if misused.. ➔ Used to add or remove const attribute. ➔ Used when it is absolutely necessary to remove consteness (anti-patern) ● Buggy libraries where it is necessary to break through const to solve issues. ● Modifying const values results in undefined behaviour. More information at: http://en.cppreference.com/w/cpp/language/expressions#Conversions
- 42. 42 60/ Lets take a break! Questions?
- 43. 3rd Part 43 60/ C++14 Increasing the complexity... For every complex problem, there is an answer that is clear, simple, and wrong. – H. L. Mencken
- 44. Exceptions 44 60/ Exceptions is how C++ deals with errors Using exceptions allows to: ➔ Errors handling organization. ➔ Delegate error treatment to upper calls, via stack unrolling. All exceptions specification should inherit from std::exception and override the const char * what() method.
- 45. Smart Pointers – Auto Memory Management 45 60/ Available at <memory> More information at: http://en.cppreference.com/w/cpp/memory Three types of Smart Pointers exist Before C++11, there was only two choices: ➔ Manual Memory Management ● Prone to errors and object leaks ● Segfault Hell world... ➔ Resort to Boost Libraries ● Despite high quality, not standard... Unique Pointers ➔ Single Ownership Shared Pointers ➔ Shared Ownership Weak Pointers ➔ No Ownership unique_ptr shared_ptr weak_ptr Smart pointers are responsible for the memory management of the object to which they point! After C++11, there are Smart Pointers! ➔ Automatic Memory Management ➔ Developer is free from memory management ● Less bugs from object leaks ● Objects existence is self managed ● Increased Code robustness
- 46. Smart Pointers Unique Pointers→ 46 60/ More information at: http://en.cppreference.com/w/cpp/memory/unique_ptr Unique pointers cannot be copied! 1 to 1 relationship with object Result Pointer is created with object constructor arguments Context is closed, pointer and object are destroyed Pointer is created, with object. Pointer is transferred to Method Method execution ends, pointer and object are destroyed. Unique pointers cost ZERO in performance!
- 47. Smart Pointers Shared Pointers→ 47 60/ More information at: http://en.cppreference.com/w/cpp/memory/shared_ptr Result Pointer 1 is created without object Pointer 2 is created with object Pointer 2 is copied to pointer 1, reference counter is increased in 1. Context is closed, pointer 2 is destroyed Context is closed, pointer 1 and object are destroyed. Shared pointers can be copied! Many to 1 relationship with object ➔ Shared pointers track object ownership, using a per-object, shared, internal reference counter. ➔ When the counter reaches zero, the object is destroyed. Beware! Shared pointers are vulnerable to circular reference issues
- 48. Smart Pointers Weak Pointers→ 48 60/ More information at: http://en.cppreference.com/w/cpp/memory/weak_ptr Weak pointer is created Shared pointer 1 is created with object Shared pointer 1 info related to object is copied into weak pointer. Verification if object still exists (true) Shared pointer 2 is created from Weak pointer. Context is closed, pointer 2 is destroyed Context is closed, pointer 1 and object are destroyed Verification if object no longer exists (true) Weak pointers have no object ownership! Used to avoid circular reference issues. ➔ To access an object pointed by weak pointers, it is required to create a Shared Pointer. ➔ Shared pointer creation may fail, if object no longer exists! Result
- 49. C++ Generic Containers→ 49 60/ The power of the Standard Template Library, is easily seen in its Generic Data containers. Generic Containers (some of them) ➔ Arrays <array> ➔ Vectors <vector> ➔ Lists <list> ➔ Maps <map> ➔ Sets <set> ➔ Stacks <stack> ➔ Queues <queue> More information at: http://en.cppreference.com/w/cpp/container
- 50. C++ Generic Algorithms→ 50 60/ Generic Algorithms for Generic Structures. ➔ Searching ● Binary Search ➔ Sorting ➔ Swapping ➔ Copying ➔ Partitioning ➔ Set Operations ➔ Minimum/Maximum Operations ➔ Numeric Operations More information at: http://en.cppreference.com/w/cpp/algorithm Result Available at <algorithm>
- 51. C++ Threads and Locks→ 51 60/ More information at: http://en.cppreference.com/w/cpp/thread/thread http://en.cppreference.com/w/cpp/thread/mutex ➔ Type declaration for the thread “main” ➔ Number of available hardware threads ➔ Shared counter ➔ List of Threads ➔ Threads will increase the counter, until it reaches 1000000 ➔ Thread object creation ➔ Moving thread to the list, NOT COPY! ➔ Master thread will wait for working threads to end ➔ Final counter value is printed Available at <thread>
- 52. C++ Threads and Locks→ 52 60/ Result Result More information at: http://en.cppreference.com/w/cpp/thread/thread http://en.cppreference.com/w/cpp/thread/mutex But… there is a synchronization problem! For 90% of the trials, the result is correct! But the problem is the remaining 10%...
- 53. C++ Threads and Locks→ 53 60/ We solve the problem with a mutex! Before accessing the shared resource, the thread locks the access When it no longer needs the resource, it releases the lock! Result Available at <mutex>
- 54. 4th Part 54 60/ C++14 Extreme Properties It ain’t what you don’t know that gets you into trouble. It’s what you know for sure that just ain’t so. – Mark Twain WARNING If you don’t understand at first, don’t worry… neither did I This is mostly to show C++14 capabilities
- 55. C++ Templates & SFINAE→ 55 60/ C++ provides a Meta-programming language ➔ It is very helpful for automatic code generation! This language is implemented using templates ➔ The base of STL ➔ Allow the creation of Generic Code ➔ Developers focus on algorithms and establish boundaries for type deduction Substitution Failure Is Not An Error (SFINAE) ➔ This rule applies during overloading resolution of function templates. ➔ Specializations are discarded, when the compiler fails to substitute the types in the template parameters. More information at: http://en.cppreference.com/w/cpp/language/templates http://en.cppreference.com/w/cpp/language/partial_specialization http://en.cppreference.com/w/cpp/language/sfinae Template Processing 1st ➔ Recursive template code evaluation ➔ Template Parameter Substitution ● SFINAE validation 2nd ➔ Code Inlining and Compilation
- 56. C++ Automatic Type Deduction→ 56 60/ Result ➔ Just a “magic method” that outputs the name of the object type Template with automatic type deduction, with type identification from operation. SFINAE rule discards incorrect template Automatic type deduction from provided value Automatic type deduction from make_shared operation More information at: http://en.cppreference.com/w/cpp/language/auto
- 57. C++ Templates with Type Traits→ 57 60/ Result More information at: http://en.cppreference.com/w/cpp/header/type_traits Templates with Type Traits Recursive Templates Available at <type_traits>
- 58. C++14 Efficient Modern Development→ 58 60/ Summarizing important C++ modern features ➔ Cleaner and Sane Syntax ➔ Lambda Functions ● Powerful way to organize code and reduce namespace pollution. ➔ Move Constructor and Move Semantics ● Allows zero-copy transfer of attribute information ➔ Smart Pointers ● Automatic Memory Management with Ownership Management ➔ Improved Generic Containers ● Updated with Move semantics ➔ Improved Generic Algorithms ● Lots of generic algorithms ● C++17 will bring Parallel Algorithms ➔ Automatic Type Deduction ➔ Templates Type Traits ● Type boundary capabilities
- 59. C++14 Resources→ 59 60/ Websites ➔ http://www.cppreference.com ➔ http://www.cplusplus.com/ Recommended Books ➔ The C++ Programming Language 4th Edition (Addison.Wesley Jun 2013) ➔ Programming Principles and Practice Using C++, 2nd Edition (Addison Wesley, 2014) ➔ Professional C++ 3rd Edition (2014) ➔ Effective Modern C++ (OReilly2014) ➔ C++ For Dummies, 7th Edition (2014) ➔ A Tour of C++ (2013 Addison Wesley) Libraries and Frameworks worth of checking out ➔ Boost ➔ POCO ➔ QT5
- 60. C++14 We are done!→ 60 60/ Thank you for your patience!