C++ Notes For Pro. 600+ pages of professional hints and tricks (GoalKicker.com) (Z-Library)

📄 File Format: PDF

💾 File Size: 4.9 MB

📖 Read Online ⬇️ Download

Registered users can read the full content for free

Register as a Gaohf Library member to read the complete e-book online for free and enjoy a better reading experience.

📄 Page 1

C++ Notes for ProfessionalsC++ Notes for Professionals GoalKicker.com Free Programming Books Disclaimer This is an unocial free book created for educational purposes and is not aliated with ocial C++ group(s) or company(s). All trademarks and registered trademarks are the property of their respective owners 600+ pages of professional hints and tricks

📄 Page 2

Contents About 1 ................................................................................................................................................................................... Chapter 1: Getting started with C++ 2 .................................................................................................................... Section 1.1: Hello World 2 ................................................................................................................................................. Section 1.2: Comments 3 .................................................................................................................................................. Section 1.3: The standard C++ compilation process 5 .................................................................................................. Section 1.4: Function 5 ...................................................................................................................................................... Section 1.5: Visibility of function prototypes and declarations 8 ................................................................................. Section 1.6: Preprocessor 9 .............................................................................................................................................. Chapter 2: Literals 11 ...................................................................................................................................................... Section 2.1: this 11 ............................................................................................................................................................. Section 2.2: Integer literal 11 ........................................................................................................................................... Section 2.3: true 12 ........................................................................................................................................................... Section 2.4: false 13 .......................................................................................................................................................... Section 2.5: nullptr 13 ....................................................................................................................................................... Chapter 3: operator precedence 14 ........................................................................................................................ Section 3.1: Logical && and || operators: short-circuit 14 .............................................................................................. Section 3.2: Unary Operators 15 ..................................................................................................................................... Section 3.3: Arithmetic operators 15 .............................................................................................................................. Section 3.4: Logical AND and OR operators 16 ............................................................................................................ Chapter 4: Floating Point Arithmetic 17 ............................................................................................................... Section 4.1: Floating Point Numbers are Weird 17 ........................................................................................................ Chapter 5: Bit Operators 18 ........................................................................................................................................ Section 5.1: | - bitwise OR 18 ............................................................................................................................................ Section 5.2: ^ - bitwise XOR (exclusive OR) 18 .............................................................................................................. Section 5.3: & - bitwise AND 20 ....................................................................................................................................... Section 5.4: << - left shift 20 ............................................................................................................................................. Section 5.5: >> - right shift 21 .......................................................................................................................................... Chapter 6: Bit Manipulation 23 ................................................................................................................................... Section 6.1: Remove rightmost set bit 23 ....................................................................................................................... Section 6.2: Set all bits 23 ................................................................................................................................................ Section 6.3: Toggling a bit 23 .......................................................................................................................................... Section 6.4: Checking a bit 23 ......................................................................................................................................... Section 6.5: Counting bits set 24 ..................................................................................................................................... Section 6.6: Check if an integer is a power of 2 25 ....................................................................................................... Section 6.7: Setting a bit 25 ............................................................................................................................................. Section 6.8: Clearing a bit 25 ........................................................................................................................................... Section 6.9: Changing the nth bit to x 25 ....................................................................................................................... Section 6.10: Bit Manipulation Application: Small to Capital Letter 26 ........................................................................ Chapter 7: Bit fields 27 ................................................................................................................................................... Section 7.1: Declaration and Usage 27 ........................................................................................................................... Chapter 8: Arrays 28 ....................................................................................................................................................... Section 8.1: Array initialization 28 .................................................................................................................................... Section 8.2: A fixed size raw array matrix (that is, a 2D raw array) 29 ...................................................................... Section 8.3: Dynamically sized raw array 29 ................................................................................................................. Section 8.4: Array size: type safe at compile time 30 ................................................................................................... Section 8.5: Expanding dynamic size array by using std::vector 31 ...........................................................................

📄 Page 3

Section 8.6: A dynamic size matrix using std::vector for storage 32 .......................................................................... Chapter 9: Iterators 35 ................................................................................................................................................... Section 9.1: Overview 35 ................................................................................................................................................... Section 9.2: Vector Iterator 38 ........................................................................................................................................ Section 9.3: Map Iterator 38 ............................................................................................................................................ Section 9.4: Reverse Iterators 39 .................................................................................................................................... Section 9.5: Stream Iterators 40 ...................................................................................................................................... Section 9.6: C Iterators (Pointers) 40 .............................................................................................................................. Section 9.7: Write your own generator-backed iterator 41 ......................................................................................... Chapter 10: Basic input/output in c++ 43 ............................................................................................................. Section 10.1: user input and standard output 43 ........................................................................................................... Chapter 11: Loops 44 ........................................................................................................................................................ Section 11.1: Range-Based For 44 .................................................................................................................................... Section 11.2: For loop 46 ................................................................................................................................................... Section 11.3: While loop 48 ............................................................................................................................................... Section 11.4: Do-while loop 49 .......................................................................................................................................... Section 11.5: Loop Control statements : Break and Continue 50 .................................................................................. Section 11.6: Declaration of variables in conditions 51 ................................................................................................. Section 11.7: Range-for over a sub-range 52 ................................................................................................................. Chapter 12: File I/O 54 .................................................................................................................................................... Section 12.1: Writing to a file 54 ....................................................................................................................................... Section 12.2: Opening a file 54 ........................................................................................................................................ Section 12.3: Reading from a file 55 ............................................................................................................................... Section 12.4: Opening modes 57 ..................................................................................................................................... Section 12.5: Reading an ASCII file into a std::string 58 ................................................................................................ Section 12.6: Writing files with non-standard locale settings 59 .................................................................................. Section 12.7: Checking end of file inside a loop condition, bad practice? 60 ............................................................. Section 12.8: Flushing a stream 61 .................................................................................................................................. Section 12.9: Reading a file into a container 61 ............................................................................................................. Section 12.10: Copying a file 62 ....................................................................................................................................... Section 12.11: Closing a file 62 .......................................................................................................................................... Section 12.12: Reading a `struct` from a formatted text file 63 .................................................................................... Chapter 13: C++ Streams 65 ......................................................................................................................................... Section 13.1: String streams 65 ........................................................................................................................................ Section 13.2: Printing collections with iostream 66 ........................................................................................................ Chapter 14: Stream manipulators 68 ..................................................................................................................... Section 14.1: Stream manipulators 68 ............................................................................................................................. Section 14.2: Output stream manipulators 73 ............................................................................................................... Section 14.3: Input stream manipulators 75 ................................................................................................................... Chapter 15: Flow Control 77 ......................................................................................................................................... Section 15.1: case 77 ......................................................................................................................................................... Section 15.2: switch 77 ...................................................................................................................................................... Section 15.3: catch 77 ....................................................................................................................................................... Section 15.4: throw 78 ....................................................................................................................................................... Section 15.5: default 79 .................................................................................................................................................... Section 15.6: try 79 ............................................................................................................................................................ Section 15.7: if 79 ............................................................................................................................................................... Section 15.8: else 80 .......................................................................................................................................................... Section 15.9: Conditional Structures: if, if..else 80 ...........................................................................................................

📄 Page 4

Section 15.10: goto 81 ....................................................................................................................................................... Section 15.11: Jump statements : break, continue, goto, exit 81 ................................................................................... Section 15.12: return 84 ..................................................................................................................................................... Chapter 16: Metaprogramming 86 ........................................................................................................................... Section 16.1: Calculating Factorials 86 ............................................................................................................................ Section 16.2: Iterating over a parameter pack 88 ......................................................................................................... Section 16.3: Iterating with std::integer_sequence 89 ................................................................................................... Section 16.4: Tag Dispatching 90 .................................................................................................................................... Section 16.5: Detect Whether Expression is Valid 90 ..................................................................................................... Section 16.6: If-then-else 92 ............................................................................................................................................. Section 16.7: Manual distinction of types when given any type T 92 .......................................................................... Section 16.8: Calculating power with C++11 (and higher) 93 ......................................................................................... Section 16.9: Generic Min/Max with variable argument count 94 ............................................................................... Chapter 17: const keyword 95 .................................................................................................................................... Section 17.1: Avoiding duplication of code in const and non-const getter methods 95 ............................................ Section 17.2: Const member functions 96 ...................................................................................................................... Section 17.3: Const local variables 97 ............................................................................................................................. Section 17.4: Const pointers 97 ........................................................................................................................................ Chapter 18: mutable keyword 99 .............................................................................................................................. Section 18.1: mutable lambdas 99 ................................................................................................................................... Section 18.2: non-static class member modifier 99 ...................................................................................................... Chapter 19: Friend keyword 101 ................................................................................................................................ Section 19.1: Friend function 101 ..................................................................................................................................... Section 19.2: Friend method 102 ..................................................................................................................................... Section 19.3: Friend class 102 .......................................................................................................................................... Chapter 20: Type Keywords 104 ............................................................................................................................... Section 20.1: class 104 ...................................................................................................................................................... Section 20.2: enum 105 .................................................................................................................................................... Section 20.3: struct 106 .................................................................................................................................................... Section 20.4: union 106 .................................................................................................................................................... Chapter 21: Basic Type Keywords 108 .................................................................................................................... Section 21.1: char 108 ....................................................................................................................................................... Section 21.2: char16_t 108 ................................................................................................................................................ Section 21.3: char32_t 108 ............................................................................................................................................... Section 21.4: int 108 .......................................................................................................................................................... Section 21.5: void 108 ....................................................................................................................................................... Section 21.6: wchar_t 109 ................................................................................................................................................ Section 21.7: float 109 ....................................................................................................................................................... Section 21.8: double 109 ................................................................................................................................................... Section 21.9: long 109 ....................................................................................................................................................... Section 21.10: short 110 .................................................................................................................................................... Section 21.11: bool 110 ...................................................................................................................................................... Chapter 22: Variable Declaration Keywords 111 .............................................................................................. Section 22.1: decltype 111 ............................................................................................................................................... Section 22.2: const 111 .................................................................................................................................................... Section 22.3: volatile 112 ................................................................................................................................................. Section 22.4: signed 112 .................................................................................................................................................. Section 22.5: unsigned 112 .............................................................................................................................................. Chapter 23: Keywords 114 ............................................................................................................................................

📄 Page 5

Section 23.1: asm 114 ....................................................................................................................................................... Section 23.2: Dierent keywords 114 ............................................................................................................................. Section 23.3: typename 118 ............................................................................................................................................ Section 23.4: explicit 119 .................................................................................................................................................. Section 23.5: sizeof 119 .................................................................................................................................................... Section 23.6: noexcept 120 .............................................................................................................................................. Chapter 24: Returning several values from a function 122 ....................................................................... Section 24.1: Using std::tuple 122 .................................................................................................................................... Section 24.2: Structured Bindings 123 ............................................................................................................................ Section 24.3: Using struct 124 ......................................................................................................................................... Section 24.4: Using Output Parameters 125 .................................................................................................................. Section 24.5: Using a Function Object Consumer 126 .................................................................................................. Section 24.6: Using std::pair 127 ..................................................................................................................................... Section 24.7: Using std::array 127 ................................................................................................................................... Section 24.8: Using Output Iterator 127 ......................................................................................................................... Section 24.9: Using std::vector 128 ................................................................................................................................. Chapter 25: Polymorphism 129 .................................................................................................................................. Section 25.1: Define polymorphic classes 129 ............................................................................................................... Section 25.2: Safe downcasting 130 ............................................................................................................................... Section 25.3: Polymorphism & Destructors 131 ............................................................................................................ Chapter 26: References 133 ......................................................................................................................................... Section 26.1: Defining a reference 133 ........................................................................................................................... Chapter 27: Value and Reference Semantics 134 ............................................................................................ Section 27.1: Definitions 134 ............................................................................................................................................ Section 27.2: Deep copying and move support 134 ..................................................................................................... Chapter 28: C++ function "call by value" vs. "call by reference" 138 .................................................... Section 28.1: Call by value 138 ........................................................................................................................................ Chapter 29: Copying vs Assignment 140 ............................................................................................................... Section 29.1: Assignment Operator 140 ......................................................................................................................... Section 29.2: Copy Constructor 140 ............................................................................................................................... Section 29.3: Copy Constructor Vs Assignment Constructor 141 ............................................................................... Chapter 30: Pointers 143 ............................................................................................................................................... Section 30.1: Pointer Operations 143 .............................................................................................................................. Section 30.2: Pointer basics 143 ...................................................................................................................................... Section 30.3: Pointer Arithmetic 145 ............................................................................................................................... Chapter 31: Pointers to members 147 ..................................................................................................................... Section 31.1: Pointers to static member functions 147 .................................................................................................. Section 31.2: Pointers to member functions 147 ........................................................................................................... Section 31.3: Pointers to member variables 148 ............................................................................................................ Section 31.4: Pointers to static member variables 148 ................................................................................................. Chapter 32: The This Pointer 150 .............................................................................................................................. Section 32.1: this Pointer 150 ........................................................................................................................................... Section 32.2: Using the this Pointer to Access Member Data 152 ............................................................................... Section 32.3: Using the this Pointer to Dierentiate Between Member Data and Parameters 152 ........................ Section 32.4: this Pointer CV-Qualifiers 153 ................................................................................................................... Section 32.5: this Pointer Ref-Qualifiers 156 .................................................................................................................. Chapter 33: Smart Pointers 158 ................................................................................................................................. Section 33.1: Unique ownership (std::unique_ptr) 158 .................................................................................................. Section 33.2: Sharing ownership (std::shared_ptr) 159 ................................................................................................

📄 Page 6

Section 33.3: Sharing with temporary ownership (std::weak_ptr) 161 ....................................................................... Section 33.4: Using custom deleters to create a wrapper to a C interface 163 ........................................................ Section 33.5: Unique ownership without move semantics (auto_ptr) 164 ................................................................. Section 33.6: Casting std::shared_ptr pointers 166 ....................................................................................................... Section 33.7: Writing a smart pointer: value_ptr 166 ................................................................................................... Section 33.8: Getting a shared_ptr referring to this 168 .............................................................................................. Chapter 34: Classes/Structures 170 ....................................................................................................................... Section 34.1: Class basics 170 .......................................................................................................................................... Section 34.2: Final classes and structs 170 .................................................................................................................... Section 34.3: Access specifiers 171 ................................................................................................................................. Section 34.4: Inheritance 172 .......................................................................................................................................... Section 34.5: Friendship 174 ............................................................................................................................................ Section 34.6: Virtual Inheritance 175 .............................................................................................................................. Section 34.7: Private inheritance: restricting base class interface 176 ....................................................................... Section 34.8: Accessing class members 177 ................................................................................................................. Section 34.9: Member Types and Aliases 178 ............................................................................................................... Section 34.10: Nested Classes/Structures 182 ............................................................................................................... Section 34.11: Unnamed struct/class 186 ....................................................................................................................... Section 34.12: Static class members 187 ........................................................................................................................ Section 34.13: Multiple Inheritance 191 ........................................................................................................................... Section 34.14: Non-static member functions 192 .......................................................................................................... Chapter 35: Function Overloading 195 ................................................................................................................... Section 35.1: What is Function Overloading? 195 .......................................................................................................... Section 35.2: Return Type in Function Overloading 196 .............................................................................................. Section 35.3: Member Function cv-qualifier Overloading 196 ..................................................................................... Chapter 36: Operator Overloading 199 ................................................................................................................. Section 36.1: Arithmetic operators 199 ........................................................................................................................... Section 36.2: Array subscript operator 200 ................................................................................................................... Section 36.3: Conversion operators 201 ......................................................................................................................... Section 36.4: Complex Numbers Revisited 202 ............................................................................................................. Section 36.5: Named operators 206 ............................................................................................................................... Section 36.6: Unary operators 208 ................................................................................................................................. Section 36.7: Comparison operators 209 ....................................................................................................................... Section 36.8: Assignment operator 210 ......................................................................................................................... Section 36.9: Function call operator 211 ........................................................................................................................ Section 36.10: Bitwise NOT operator 211 ....................................................................................................................... Section 36.11: Bit shift operators for I/O 212 .................................................................................................................. Chapter 37: Function Template Overloading 213 ............................................................................................. Section 37.1: What is a valid function template overloading? 213 .............................................................................. Chapter 38: Virtual Member Functions 214 ......................................................................................................... Section 38.1: Final virtual functions 214 .......................................................................................................................... Section 38.2: Using override with virtual in C++11 and later 214 .................................................................................. Section 38.3: Virtual vs non-virtual member functions 215 ......................................................................................... Section 38.4: Behaviour of virtual functions in constructors and destructors 216 .................................................... Section 38.5: Pure virtual functions 217 ......................................................................................................................... Chapter 39: Inline functions 220 ................................................................................................................................. Section 39.1: Non-member inline function definition 220 ............................................................................................. Section 39.2: Member inline functions 220 ..................................................................................................................... Section 39.3: What is function inlining? 220 ................................................................................................................... Section 39.4: Non-member inline function declaration 221 .........................................................................................

📄 Page 7

Chapter 40: Special Member Functions 222 ........................................................................................................ Section 40.1: Default Constructor 222 ............................................................................................................................ Section 40.2: Destructor 224 ........................................................................................................................................... Section 40.3: Copy and swap 225 ................................................................................................................................... Section 40.4: Implicit Move and Copy 227 ..................................................................................................................... Chapter 41: Non-Static Member Functions 228 ................................................................................................. Section 41.1: Non-static Member Functions 228 ............................................................................................................ Section 41.2: Encapsulation 229 ...................................................................................................................................... Section 41.3: Name Hiding & Importing 229 .................................................................................................................. Section 41.4: Virtual Member Functions 231 .................................................................................................................. Section 41.5: Const Correctness 233 ............................................................................................................................... Chapter 42: Constant class member functions 235 ........................................................................................ Section 42.1: constant member function 235 ................................................................................................................ Chapter 43: C++ Containers 236 ................................................................................................................................ Section 43.1: C++ Containers Flowchart 236 .................................................................................................................. Chapter 44: Namespaces 237 .................................................................................................................................... Section 44.1: What are namespaces? 237 ..................................................................................................................... Section 44.2: Argument Dependent Lookup 238 .......................................................................................................... Section 44.3: Extending namespaces 239 ...................................................................................................................... Section 44.4: Using directive 239 .................................................................................................................................... Section 44.5: Making namespaces 240 .......................................................................................................................... Section 44.6: Unnamed/anonymous namespaces 241 ............................................................................................... Section 44.7: Compact nested namespaces 241 .......................................................................................................... Section 44.8: Namespace alias 241 ................................................................................................................................ Section 44.9: Inline namespace 242 ............................................................................................................................... Section 44.10: Aliasing a long namespace 244 .............................................................................................................. Section 44.11: Alias Declaration scope 244 ..................................................................................................................... Chapter 45: Header Files 246 ..................................................................................................................................... Section 45.1: Basic Example 246 ..................................................................................................................................... Section 45.2: Templates in Header Files 247 ................................................................................................................. Chapter 46: Using declaration 248 .......................................................................................................................... Section 46.1: Importing names individually from a namespace 248 .......................................................................... Section 46.2: Redeclaring members from a base class to avoid name hiding 248 .................................................. Section 46.3: Inheriting constructors 248 ....................................................................................................................... Chapter 47: std::string 250 ........................................................................................................................................... Section 47.1: Tokenize 250 ............................................................................................................................................... Section 47.2: Conversion to (const) char* 251 ............................................................................................................... Section 47.3: Using the std::string_view class 251 ........................................................................................................ Section 47.4: Conversion to std::wstring 252 .................................................................................................................. Section 47.5: Lexicographical comparison 253 ............................................................................................................. Section 47.6: Trimming characters at start/end 254 ................................................................................................... Section 47.7: String replacement 255 ............................................................................................................................. Section 47.8: Converting to std::string 256 ..................................................................................................................... Section 47.9: Splitting 257 ................................................................................................................................................ Section 47.10: Accessing a character 258 ...................................................................................................................... Section 47.11: Checking if a string is a prefix of another 258 ....................................................................................... Section 47.12: Looping through each character 259 .................................................................................................... Section 47.13: Conversion to integers/floating point types 259 .................................................................................. Section 47.14: Concatenation 260 ...................................................................................................................................

📄 Page 8

Section 47.15: Converting between character encodings 261 ..................................................................................... Section 47.16: Finding character(s) in a string 262 ....................................................................................................... Chapter 48: std::array 263 ........................................................................................................................................... Section 48.1: Initializing an std::array 263 ....................................................................................................................... Section 48.2: Element access 264 ................................................................................................................................... Section 48.3: Iterating through the Array 266 ............................................................................................................... Section 48.4: Checking size of the Array 266 ................................................................................................................ Section 48.5: Changing all array elements at once 266 ............................................................................................... Chapter 49: std::vector 267 ......................................................................................................................................... Section 49.1: Accessing Elements 267 ............................................................................................................................ Section 49.2: Initializing a std::vector 269 ....................................................................................................................... Section 49.3: Deleting Elements 270 ............................................................................................................................... Section 49.4: Iterating Over std::vector 272 ................................................................................................................... Section 49.5: vector<bool>: The Exception To So Many, So Many Rules 274 ............................................................ Section 49.6: Inserting Elements 275 .............................................................................................................................. Section 49.7: Using std::vector as a C array 276 ........................................................................................................... Section 49.8: Finding an Element in std::vector 277 ...................................................................................................... Section 49.9: Concatenating Vectors 278 ...................................................................................................................... Section 49.10: Matrices Using Vectors 279 ..................................................................................................................... Section 49.11: Using a Sorted Vector for Fast Element Lookup 280 ............................................................................ Section 49.12: Reducing the Capacity of a Vector 281 ................................................................................................. Section 49.13: Vector size and capacity 281 .................................................................................................................. Section 49.14: Iterator/Pointer Invalidation 283 ............................................................................................................ Section 49.15: Find max and min Element and Respective Index in a Vector 284 ..................................................... Section 49.16: Converting an array to std::vector 284 .................................................................................................. Section 49.17: Functions Returning Large Vectors 285 ................................................................................................. Chapter 50: std::map 287 .............................................................................................................................................. Section 50.1: Accessing elements 287 ............................................................................................................................ Section 50.2: Inserting elements 288 .............................................................................................................................. Section 50.3: Searching in std::map or in std::multimap 289 ........................................................................................ Section 50.4: Initializing a std::map or std::multimap 290 ............................................................................................. Section 50.5: Checking number of elements 291 .......................................................................................................... Section 50.6: Types of Maps 291 .................................................................................................................................... Section 50.7: Deleting elements 292 ............................................................................................................................... Section 50.8: Iterating over std::map or std::multimap 293 ......................................................................................... Section 50.9: Creating std::map with user-defined types as key 293 ......................................................................... Chapter 51: std::optional 295 ....................................................................................................................................... Section 51.1: Using optionals to represent the absence of a value 295 ...................................................................... Section 51.2: optional as return value 295 ..................................................................................................................... Section 51.3: value_or 296 ............................................................................................................................................... Section 51.4: Introduction 296 .......................................................................................................................................... Section 51.5: Using optionals to represent the failure of a function 297 .................................................................... Chapter 52: std::function: To wrap any element that is callable 299 .................................................... Section 52.1: Simple usage 299 ....................................................................................................................................... Section 52.2: std::function used with std::bind 299 ........................................................................................................ Section 52.3: Binding std::function to a dierent callable types 300 .......................................................................... Section 52.4: Storing function arguments in std::tuple 302 .......................................................................................... Section 52.5: std::function with lambda and std::bind 303 ........................................................................................... Section 52.6: `function` overhead 304 ............................................................................................................................ Chapter 53: std::forward_list 305 .............................................................................................................................

📄 Page 9

Section 53.1: Example 305 ................................................................................................................................................ Section 53.2: Methods 305 ............................................................................................................................................... Chapter 54: std::pair 307 .............................................................................................................................................. Section 54.1: Compare operators 307 ............................................................................................................................ Section 54.2: Creating a Pair and accessing the elements 307 ................................................................................... Chapter 55: std::atomics 309 ....................................................................................................................................... Section 55.1: atomic types 309 ........................................................................................................................................ Chapter 56: std::variant 311 ........................................................................................................................................ Section 56.1: Create pseudo-method pointers 311 ....................................................................................................... Section 56.2: Basic std::variant use 312 .......................................................................................................................... Section 56.3: Constructing a `std::variant` 313 ............................................................................................................... Chapter 57: std::iomanip 314 ...................................................................................................................................... Section 57.1: std::setprecision 314 ................................................................................................................................... Section 57.2: std::setfill 314 .............................................................................................................................................. Section 57.3: std::setiosflags 314 ..................................................................................................................................... Section 57.4: std::setw 316 ............................................................................................................................................... Chapter 58: std::any 317 ................................................................................................................................................ Section 58.1: Basic usage 317 .......................................................................................................................................... Chapter 59: std::set and std::multiset 318 ............................................................................................................ Section 59.1: Changing the default sort of a set 318 .................................................................................................... Section 59.2: Deleting values from a set 320 ................................................................................................................ Section 59.3: Inserting values in a set 321 ..................................................................................................................... Section 59.4: Inserting values in a multiset 323 ............................................................................................................. Section 59.5: Searching values in set and multiset 323 ................................................................................................ Chapter 60: std::integer_sequence 325 ................................................................................................................ Section 60.1: Turn a std::tuple<T...> into function parameters 325 .............................................................................. Section 60.2: Create a parameter pack consisting of integers 326 ............................................................................ Section 60.3: Turn a sequence of indices into copies of an element 326 ................................................................... Chapter 61: Using std::unordered_map 328 ........................................................................................................ Section 61.1: Declaration and Usage 328 ....................................................................................................................... Section 61.2: Some Basic Functions 328 ......................................................................................................................... Chapter 62: Standard Library Algorithms 329 ................................................................................................... Section 62.1: std::next_permutation 329 ......................................................................................................................... Section 62.2: std::for_each 329 ....................................................................................................................................... Section 62.3: std::accumulate 330 ................................................................................................................................... Section 62.4: std::find 331 ................................................................................................................................................ Section 62.5: std::min_element 333 ................................................................................................................................ Section 62.6: std::find_if 334 ............................................................................................................................................ Section 62.7: Using std::nth_element To Find The Median (Or Other Quantiles) 335 ............................................... Section 62.8: std::count 336 ............................................................................................................................................. Section 62.9: std::count_if 337 ......................................................................................................................................... Chapter 63: The ISO C++ Standard 339 .................................................................................................................. Section 63.1: Current Working Drafts 339 ...................................................................................................................... Section 63.2: C++17 339 .................................................................................................................................................... Section 63.3: C++11 340 ..................................................................................................................................................... Section 63.4: C++14 341 .................................................................................................................................................... Section 63.5: C++98 342 ................................................................................................................................................... Section 63.6: C++03 342 ................................................................................................................................................... Section 63.7: C++20 343 ...................................................................................................................................................

📄 Page 10

Chapter 64: Inline variables 344 ................................................................................................................................ Section 64.1: Defining a static data member in the class definition 344 ..................................................................... Chapter 65: Random number generation 345 ................................................................................................... Section 65.1: True random value generator 345 ........................................................................................................... Section 65.2: Generating a pseudo-random number 345 ............................................................................................ Section 65.3: Using the generator for multiple distributions 346 ................................................................................ Chapter 66: Date and time using <chrono> header 347 ................................................................................ Section 66.1: Measuring time using <chrono> 347 ........................................................................................................ Section 66.2: Find number of days between two dates 347 ........................................................................................ Chapter 67: Sorting 349 ................................................................................................................................................. Section 67.1: Sorting and sequence containers 349 ...................................................................................................... Section 67.2: sorting with std::map (ascending and descending) 349 ........................................................................ Section 67.3: Sorting sequence containers by overloaded less operator 351 ........................................................... Section 67.4: Sorting sequence containers using compare function 352 ................................................................... Section 67.5: Sorting sequence containers using lambda expressions (C++11) 353 .................................................. Section 67.6: Sorting built-in arrays 354 ........................................................................................................................ Section 67.7: Sorting sequence containers with specifed ordering 354 ..................................................................... Chapter 68: Enumeration 355 ..................................................................................................................................... Section 68.1: Iteration over an enum 355 ....................................................................................................................... Section 68.2: Scoped enums 356 .................................................................................................................................... Section 68.3: Enum forward declaration in C++11 357 .................................................................................................. Section 68.4: Basic Enumeration Declaration 357 ........................................................................................................ Section 68.5: Enumeration in switch statements 358 ................................................................................................... Chapter 69: Iteration 359 .............................................................................................................................................. Section 69.1: break 359 .................................................................................................................................................... Section 69.2: continue 359 ............................................................................................................................................... Section 69.3: do 359 ......................................................................................................................................................... Section 69.4: while 359 ..................................................................................................................................................... Section 69.5: range-based for loop 360 ......................................................................................................................... Section 69.6: for 360 ......................................................................................................................................................... Chapter 70: Regular expressions 361 ..................................................................................................................... Section 70.1: Basic regex_match and regex_search Examples 361 ........................................................................... Section 70.2: regex_iterator Example 361 ..................................................................................................................... Section 70.3: Anchors 362 ................................................................................................................................................ Section 70.4: regex_replace Example 363 ..................................................................................................................... Section 70.5: regex_token_iterator Example 363 ........................................................................................................ Section 70.6: Quantifiers 363 ........................................................................................................................................... Section 70.7: Splitting a string 365 .................................................................................................................................. Chapter 71: Implementation-defined behavior 366 ......................................................................................... Section 71.1: Size of integral types 366 ........................................................................................................................... Section 71.2: Char might be unsigned or signed 368 .................................................................................................... Section 71.3: Ranges of numeric types 368 ................................................................................................................... Section 71.4: Value representation of floating point types 369 ................................................................................... Section 71.5: Overflow when converting from integer to signed integer 369 ............................................................ Section 71.6: Underlying type (and hence size) of an enum 370 ................................................................................. Section 71.7: Numeric value of a pointer 370 ................................................................................................................. Section 71.8: Number of bits in a byte 371 ..................................................................................................................... Chapter 72: Exceptions 372 .......................................................................................................................................... Section 72.1: Catching exceptions 372 ............................................................................................................................

📄 Page 11

Section 72.2: Rethrow (propagate) exception 373 ....................................................................................................... Section 72.3: Best practice: throw by value, catch by const reference 374 ............................................................... Section 72.4: Custom exception 375 ............................................................................................................................... Section 72.5: std::uncaught_exceptions 377 .................................................................................................................. Section 72.6: Function Try Block for regular function 378 ........................................................................................... Section 72.7: Nested exception 378 ................................................................................................................................ Section 72.8: Function Try Blocks In constructor 380 ................................................................................................... Section 72.9: Function Try Blocks In destructor 381 ..................................................................................................... Chapter 73: Lambdas 382 ............................................................................................................................................. Section 73.1: What is a lambda expression? 382 ........................................................................................................... Section 73.2: Specifying the return type 384 ................................................................................................................. Section 73.3: Capture by value 385 ................................................................................................................................ Section 73.4: Recursive lambdas 386 ............................................................................................................................. Section 73.5: Default capture 388 ................................................................................................................................... Section 73.6: Class lambdas and capture of this 388 ................................................................................................... Section 73.7: Capture by reference 390 ......................................................................................................................... Section 73.8: Generic lambdas 390 ................................................................................................................................. Section 73.9: Using lambdas for inline parameter pack unpacking 391 .................................................................... Section 73.10: Generalized capture 393 .......................................................................................................................... Section 73.11: Conversion to function pointer 394 ......................................................................................................... Section 73.12: Porting lambda functions to C++03 using functors 394 ....................................................................... Chapter 74: Value Categories 396 ........................................................................................................................... Section 74.1: Value Category Meanings 396 .................................................................................................................. Section 74.2: rvalue 396 ................................................................................................................................................... Section 74.3: xvalue 397 ................................................................................................................................................... Section 74.4: prvalue 397 ................................................................................................................................................. Section 74.5: lvalue 398 .................................................................................................................................................... Section 74.6: glvalue 398 ................................................................................................................................................. Chapter 75: Preprocessor 399 .................................................................................................................................... Section 75.1: Include Guards 399 ..................................................................................................................................... Section 75.2: Conditional logic and cross-platform handling 400 ............................................................................... Section 75.3: X-macros 401 ............................................................................................................................................. Section 75.4: Macros 403 ................................................................................................................................................. Section 75.5: Predefined macros 406 ............................................................................................................................. Section 75.6: Preprocessor Operators 408 .................................................................................................................... Section 75.7: #pragma once 408 .................................................................................................................................... Section 75.8: Preprocessor error messages 409 ........................................................................................................... Chapter 76: Data Structures in C++ 410 ................................................................................................................ Section 76.1: Linked List implementation in C++ 410 ..................................................................................................... Chapter 77: Templates 413 .......................................................................................................................................... Section 77.1: Basic Class Template 413 .......................................................................................................................... Section 77.2: Function Templates 413 ............................................................................................................................ Section 77.3: Variadic template data structures 415 .................................................................................................... Section 77.4: Argument forwarding 417 ........................................................................................................................ Section 77.5: Partial template specialization 418 .......................................................................................................... Section 77.6: Template Specialization 420 ..................................................................................................................... Section 77.7: Alias template 420 ..................................................................................................................................... Section 77.8: Explicit instantiation 420 ............................................................................................................................ Section 77.9: Non-type template parameter 421 ......................................................................................................... Section 77.10: Declaring non-type template arguments with auto 422 ......................................................................

📄 Page 12

Section 77.11: Template template parameters 423 ....................................................................................................... Section 77.12: Default template parameter value 424 ................................................................................................. Chapter 78: Expression templates 425 ................................................................................................................... Section 78.1: A basic example illustrating expression templates 425 ......................................................................... Chapter 79: Curiously Recurring Template Pattern (CRTP) 429 ............................................................... Section 79.1: The Curiously Recurring Template Pattern (CRTP) 429 ......................................................................... Section 79.2: CRTP to avoid code duplication 430 ........................................................................................................ Chapter 80: Threading 432 ........................................................................................................................................... Section 80.1: Creating a std::thread 432 ......................................................................................................................... Section 80.2: Passing a reference to a thread 434 ....................................................................................................... Section 80.3: Using std::async instead of std::thread 434 ............................................................................................ Section 80.4: Basic Synchronization 435 ........................................................................................................................ Section 80.5: Create a simple thread pool 435 ............................................................................................................. Section 80.6: Ensuring a thread is always joined 437 ................................................................................................... Section 80.7: Operations on the current thread 438 .................................................................................................... Section 80.8: Using Condition Variables 439 ................................................................................................................. Section 80.9: Thread operations 441 ............................................................................................................................. Section 80.10: Thread-local storage 441 ........................................................................................................................ Section 80.11: Reassigning thread objects 442 .............................................................................................................. Chapter 81: Thread synchronization structures 443 ....................................................................................... Section 81.1: std::condition_variable_any, std::cv_status 443 ...................................................................................... Section 81.2: std::shared_lock 443 .................................................................................................................................. Section 81.3: std::call_once, std::once_flag 443 ............................................................................................................. Section 81.4: Object locking for ecient access 444 .................................................................................................... Chapter 82: The Rule of Three, Five, And Zero 446 ......................................................................................... Section 82.1: Rule of Zero 446 ......................................................................................................................................... Section 82.2: Rule of Five 447 ......................................................................................................................................... Section 82.3: Rule of Three 448 ...................................................................................................................................... Section 82.4: Self-assignment Protection 449 ............................................................................................................... Chapter 83: RAII: Resource Acquisition Is Initialization 451 ......................................................................... Section 83.1: Locking 451 ................................................................................................................................................. Section 83.2: ScopeSuccess (c++17) 452 ........................................................................................................................ Section 83.3: ScopeFail (c++17) 453 ................................................................................................................................ Section 83.4: Finally/ScopeExit 454 ................................................................................................................................ Chapter 84: RTTI: Run-Time Type Information 455 ........................................................................................ Section 84.1: dynamic_cast 455 ...................................................................................................................................... Section 84.2: The typeid keyword 455 ........................................................................................................................... Section 84.3: Name of a type 456 ................................................................................................................................... Section 84.4: When to use which cast in c++ 456 .......................................................................................................... Chapter 85: Mutexes 457 ............................................................................................................................................... Section 85.1: Mutex Types 457 ........................................................................................................................................ Section 85.2: std::lock 457 ................................................................................................................................................ Section 85.3: std::unique_lock, std::shared_lock, std::lock_guard 457 ....................................................................... Section 85.4: Strategies for lock classes: std::try_to_lock, std::adopt_lock, std::defer_lock 458 ............................ Section 85.5: std::mutex 459 ............................................................................................................................................ Section 85.6: std::scoped_lock (C++ 17) 459 .................................................................................................................. Chapter 86: Recursive Mutex 460 .............................................................................................................................. Section 86.1: std::recursive_mutex 460 ........................................................................................................................... Chapter 87: Semaphore 461 ........................................................................................................................................

📄 Page 13

Section 87.1: Semaphore C++ 11 461 ............................................................................................................................... Section 87.2: Semaphore class in action 461 ................................................................................................................ Chapter 88: Futures and Promises 463 .................................................................................................................. Section 88.1: Async operation classes 463 ..................................................................................................................... Section 88.2: std::future and std::promise 463 ............................................................................................................... Section 88.3: Deferred async example 463 ................................................................................................................... Section 88.4: std::packaged_task and std::future 464 .................................................................................................. Section 88.5: std::future_error and std::future_errc 464 .............................................................................................. Section 88.6: std::future and std::async 465 ................................................................................................................... Chapter 89: Atomic Types 468 .................................................................................................................................... Section 89.1: Multi-threaded Access 468 ........................................................................................................................ Chapter 90: Type Erasure 470 .................................................................................................................................... Section 90.1: A move-only `std::function` 470 ................................................................................................................. Section 90.2: Erasing down to a Regular type with manual vtable 472 ..................................................................... Section 90.3: Basic mechanism 475 ............................................................................................................................... Section 90.4: Erasing down to a contiguous buer of T 476 ....................................................................................... Section 90.5: Type erasing type erasure with std::any 477 ......................................................................................... Chapter 91: Explicit type conversions 482 ............................................................................................................. Section 91.1: C-style casting 482 ...................................................................................................................................... Section 91.2: Casting away constness 482 ..................................................................................................................... Section 91.3: Base to derived conversion 482 ................................................................................................................ Section 91.4: Conversion between pointer and integer 483 ......................................................................................... Section 91.5: Conversion by explicit constructor or explicit conversion function 484 ............................................... Section 91.6: Implicit conversion 484 .............................................................................................................................. Section 91.7: Enum conversions 484 ............................................................................................................................... Section 91.8: Derived to base conversion for pointers to members 486 .................................................................... Section 91.9: void* to T* 486 ............................................................................................................................................. Section 91.10: Type punning conversion 487 ................................................................................................................. Chapter 92: Unnamed types 488 ............................................................................................................................... Section 92.1: Unnamed classes 488 ................................................................................................................................ Section 92.2: As a type alias 488 .................................................................................................................................... Section 92.3: Anonymous members 488 ....................................................................................................................... Section 92.4: Anonymous Union 489 .............................................................................................................................. Chapter 93: Type Traits 490 ......................................................................................................................................... Section 93.1: Type Properties 490 ................................................................................................................................... Section 93.2: Standard type traits 491 ........................................................................................................................... Section 93.3: Type relations with std::is_same<T, T> 492 ............................................................................................ Section 93.4: Fundamental type traits 493 .................................................................................................................... Chapter 94: Return Type Covariance 495 ............................................................................................................ Section 94.1: Covariant result version of the base example, static type checking 495 ............................................. Section 94.2: Covariant smart pointer result (automated cleanup) 495 .................................................................... Chapter 95: Layout of object types 497 ................................................................................................................ Section 95.1: Class types 497 ........................................................................................................................................... Section 95.2: Arithmetic types 499 ................................................................................................................................. Section 95.3: Arrays 500 .................................................................................................................................................. Chapter 96: Type Inference 501 ................................................................................................................................ Section 96.1: Data Type: Auto 501 .................................................................................................................................. Section 96.2: Lambda auto 501 ...................................................................................................................................... Section 96.3: Loops and auto 501 ...................................................................................................................................

📄 Page 14

Chapter 97: Typedef and type aliases 503 .......................................................................................................... Section 97.1: Basic typedef syntax 503 .......................................................................................................................... Section 97.2: More complex uses of typedef 503 ......................................................................................................... Section 97.3: Declaring multiple types with typedef 504 ............................................................................................. Section 97.4: Alias declaration with "using" 504 ............................................................................................................ Chapter 98: type deduction 505 ................................................................................................................................ Section 98.1: Template parameter deduction for constructors 505 ........................................................................... Section 98.2: Auto Type Deduction 505 ......................................................................................................................... Section 98.3: Template Type Deduction 506 ................................................................................................................. Chapter 99: Trailing return type 508 ....................................................................................................................... Section 99.1: Avoid qualifying a nested type name 508 ............................................................................................... Section 99.2: Lambda expressions 508 .......................................................................................................................... Chapter 100: Alignment 509 ......................................................................................................................................... Section 100.1: Controlling alignment 509 ........................................................................................................................ Section 100.2: Querying the alignment of a type 509 .................................................................................................. Chapter 101: Perfect Forwarding 511 ...................................................................................................................... Section 101.1: Factory functions 511 ................................................................................................................................ Chapter 102: decltype 512 ............................................................................................................................................ Section 102.1: Basic Example 512 .................................................................................................................................... Section 102.2: Another example 512 ............................................................................................................................... Chapter 103: SFINAE (Substitution Failure Is Not An Error) 513 ................................................................ Section 103.1: What is SFINAE 513 ................................................................................................................................... Section 103.2: void_t 513 ................................................................................................................................................. Section 103.3: enable_if 515 ............................................................................................................................................ Section 103.4: is_detected 516 ........................................................................................................................................ Section 103.5: Overload resolution with a large number of options 518 .................................................................... Section 103.6: trailing decltype in function templates 519 ........................................................................................... Section 103.7: enable_if_all / enable_if_any 520 ........................................................................................................ Chapter 104: Undefined Behavior 522 .................................................................................................................... Section 104.1: Reading or writing through a null pointer 522 ....................................................................................... Section 104.2: Using an uninitialized local variable 522 ............................................................................................... Section 104.3: Accessing an out-of-bounds index 523 .................................................................................................. Section 104.4: Deleting a derived object via a pointer to a base class that doesn't have a virtual destructor 523 ............................................................................................................................................................................. Section 104.5: Extending the `std` or `posix` Namespace 523 ...................................................................................... Section 104.6: Invalid pointer arithmetic 524 ................................................................................................................. Section 104.7: No return statement for a function with a non-void return type 525 ................................................. Section 104.8: Accessing a dangling reference 525 ...................................................................................................... Section 104.9: Integer division by zero 526 .................................................................................................................... Section 104.10: Shifting by an invalid number of positions 526 ................................................................................... Section 104.11: Incorrect pairing of memory allocation and deallocation 526 ........................................................... Section 104.12: Signed Integer Overflow 527 ................................................................................................................. Section 104.13: Multiple non-identical definitions (the One Definition Rule) 527 ........................................................ Section 104.14: Modifying a const object 528 ................................................................................................................ Section 104.15: Returning from a [[noreturn]] function 529 ........................................................................................ Section 104.16: Infinite template recursion 529 .............................................................................................................. Section 104.17: Overflow during conversion to or from floating point type 530 ........................................................ Section 104.18: Modifying a string literal 530 ................................................................................................................. Section 104.19: Accessing an object as the wrong type 530 ........................................................................................

📄 Page 15

Section 104.20: Invalid derived-to-base conversion for pointers to members 531 ................................................... Section 104.21: Destroying an object that has already been destroyed 531 ............................................................. Section 104.22: Access to nonexistent member through pointer to member 532 ..................................................... Section 104.23: Invalid base-to-derived static cast 532 ................................................................................................ Section 104.24: Floating point overflow 532 .................................................................................................................. Section 104.25: Calling (Pure) Virtual Members From Constructor Or Destructor 532 ............................................. Section 104.26: Function call through mismatched function pointer type 533 .......................................................... Chapter 105: Overload resolution 534 .................................................................................................................... Section 105.1: Categorization of argument to parameter cost 534 ............................................................................. Section 105.2: Arithmetic promotions and conversions 534 ........................................................................................ Section 105.3: Overloading on Forwarding Reference 535 .......................................................................................... Section 105.4: Exact match 536 ....................................................................................................................................... Section 105.5: Overloading on constness and volatility 536 ........................................................................................ Section 105.6: Name lookup and access checking 537 ................................................................................................ Section 105.7: Overloading within a class hierarchy 538 .............................................................................................. Section 105.8: Steps of Overload Resolution 539 .......................................................................................................... Chapter 106: Move Semantics 541 ............................................................................................................................ Section 106.1: Move semantics 541 ................................................................................................................................. Section 106.2: Using std::move to reduce complexity from O(n²) to O(n) 541 ........................................................... Section 106.3: Move constructor 544 .............................................................................................................................. Section 106.4: Re-use a moved object 546 .................................................................................................................... Section 106.5: Move assignment 546 .............................................................................................................................. Section 106.6: Using move semantics on containers 547 ............................................................................................. Chapter 107: Pimpl Idiom 549 ...................................................................................................................................... Section 107.1: Basic Pimpl idiom 549 ............................................................................................................................... Chapter 108: auto 551 ..................................................................................................................................................... Section 108.1: Basic auto sample 551 ............................................................................................................................. Section 108.2: Generic lambda (C++14) 551 ................................................................................................................... Section 108.3: auto and proxy objects 552 .................................................................................................................... Section 108.4: auto and Expression Templates 552 ...................................................................................................... Section 108.5: auto, const, and references 553 ............................................................................................................. Section 108.6: Trailing return type 553 ........................................................................................................................... Chapter 109: Copy Elision 555 ..................................................................................................................................... Section 109.1: Purpose of copy elision 555 ..................................................................................................................... Section 109.2: Guaranteed copy elision 556 .................................................................................................................. Section 109.3: Parameter elision 557 .............................................................................................................................. Section 109.4: Return value elision 557 .......................................................................................................................... Section 109.5: Named return value elision 557 .............................................................................................................. Section 109.6: Copy initialization elision 558 .................................................................................................................. Chapter 110: Fold Expressions 559 ............................................................................................................................ Section 110.1: Unary Folds 559 ......................................................................................................................................... Section 110.2: Binary Folds 559 ....................................................................................................................................... Section 110.3: Folding over a comma 560 ...................................................................................................................... Chapter 111: Unions 561 ................................................................................................................................................... Section 111.1: Undefined Behavior 561 ............................................................................................................................. Section 111.2: Basic Union Features 561 ......................................................................................................................... Section 111.3: Typical Use 561 .......................................................................................................................................... Chapter 112: Design pattern implementation in C++ 563 .............................................................................. Section 112.1: Adapter Pattern 563 ..................................................................................................................................

📄 Page 16

Section 112.2: Observer pattern 565 ............................................................................................................................... Section 112.3: Factory Pattern 568 .................................................................................................................................. Section 112.4: Builder Pattern with Fluent API 568 ......................................................................................................... Chapter 113: Singleton Design Pattern 572 .......................................................................................................... Section 113.1: Lazy Initialization 572 ................................................................................................................................ Section 113.2: Static deinitialization-safe singleton 573 ................................................................................................ Section 113.3: Thread-safe Singeton 573 ........................................................................................................................ Section 113.4: Subclasses 573 .......................................................................................................................................... Chapter 114: User-Defined Literals 575 .................................................................................................................. Section 114.1: Self-made user-defined literal for binary 575 ........................................................................................ Section 114.2: Standard user-defined literals for duration 575 .................................................................................... Section 114.3: User-defined literals with long double values 576 ................................................................................. Section 114.4: Standard user-defined literals for strings 576 ....................................................................................... Section 114.5: Standard user-defined literals for complex 577 .................................................................................... Chapter 115: Memory management 578 ................................................................................................................ Section 115.1: Free Storage (Heap, Dynamic Allocation ...) 578 .................................................................................... Section 115.2: Placement new 579 ................................................................................................................................... Section 115.3: Stack 580 .................................................................................................................................................... Chapter 116: C++11 Memory Model 581 .................................................................................................................... Section 116.1: Need for Memory Model 582 .................................................................................................................... Section 116.2: Fence example 584 ................................................................................................................................... Chapter 117: Scopes 585 ................................................................................................................................................. Section 117.1: Global variables 585 .................................................................................................................................. Section 117.2: Simple block scope 585 ............................................................................................................................ Chapter 118: static_assert 587 ................................................................................................................................... Section 118.1: static_assert 587 ........................................................................................................................................ Chapter 119: constexpr 588 ........................................................................................................................................... Section 119.1: constexpr variables 588 ............................................................................................................................ Section 119.2: Static if statement 589 .............................................................................................................................. Section 119.3: constexpr functions 590 ............................................................................................................................ Chapter 120: One Definition Rule (ODR) 592 ....................................................................................................... Section 120.1: ODR violation via overload resolution 592 ............................................................................................. Section 120.2: Multiply defined function 592 .................................................................................................................. Section 120.3: Inline functions 593 .................................................................................................................................. Chapter 121: Unspecified behavior 595 ................................................................................................................... Section 121.1: Value of an out-of-range enum 595 ........................................................................................................ Section 121.2: Evaluation order of function arguments 595 ......................................................................................... Section 121.3: Result of some reinterpret_cast conversions 596 ................................................................................. Section 121.4: Space occupied by a reference 597 ....................................................................................................... Section 121.5: Moved-from state of most standard library classes 597 ..................................................................... Section 121.6: Result of some pointer comparisons 598 ............................................................................................... Section 121.7: Static cast from bogus void* value 598 .................................................................................................. Section 121.8: Order of initialization of globals across TU 598 .................................................................................... Chapter 122: Argument Dependent Name Lookup 600 ................................................................................. Section 122.1: What functions are found 600 ................................................................................................................. Chapter 123: Attributes 601 .......................................................................................................................................... Section 123.1: [[fallthrough]] 601 .................................................................................................................................... Section 123.2: [[nodiscard]] 601 ..................................................................................................................................... Section 123.3: [[deprecated]] and [[deprecated("reason")]] 602 ..............................................................................

📄 Page 17

Section 123.4: [[maybe_unused]] 602 ........................................................................................................................... Section 123.5: [[noreturn]] 603 ........................................................................................................................................ Chapter 124: Recursion in C++ 605 ........................................................................................................................... Section 124.1: Using tail recursion and Fibonnaci-style recursion to solve the Fibonnaci sequence 605 ................ Section 124.2: Recursion with memoization 605 ............................................................................................................ Chapter 125: Arithmitic Metaprogramming 607 ................................................................................................ Section 125.1: Calculating power in O(log n) 607 ........................................................................................................... Chapter 126: Callable Objects 609 ............................................................................................................................ Section 126.1: Function Pointers 609 ............................................................................................................................... Section 126.2: Classes with operator() (Functors) 609 ................................................................................................. Chapter 127: Client server examples 611 .............................................................................................................. Section 127.1: Hello TCP Client 611 .................................................................................................................................. Section 127.2: Hello TCP Server 612 ............................................................................................................................... Chapter 128: Const Correctness 616 ........................................................................................................................ Section 128.1: The Basics 616 ........................................................................................................................................... Section 128.2: Const Correct Class Design 616 ............................................................................................................. Section 128.3: Const Correct Function Parameters 618 ............................................................................................... Section 128.4: Const Correctness as Documentation 620 ............................................................................................ Chapter 129: Parameter packs 624 .......................................................................................................................... Section 129.1: A template with a parameter pack 624 .................................................................................................. Section 129.2: Expansion of a parameter pack 624 ...................................................................................................... Chapter 130: Build Systems 625 ................................................................................................................................. Section 130.1: Generating Build Environment with CMake 625 .................................................................................... Section 130.2: Compiling with GNU make 626 ............................................................................................................... Section 130.3: Building with SCons 628 ........................................................................................................................... Section 130.4: Autotools (GNU) 628 ................................................................................................................................ Section 130.5: Ninja 629 .................................................................................................................................................... Section 130.6: NMAKE (Microsoft Program Maintenance Utility) 629 ......................................................................... Chapter 131: Concurrency With OpenMP 630 ....................................................................................................... Section 131.1: OpenMP: Parallel Sections 630 ................................................................................................................. Section 131.2: OpenMP: Parallel Sections 630 ................................................................................................................. Section 131.3: OpenMP: Parallel For Loop 631 ................................................................................................................ Section 131.4: OpenMP: Parallel Gathering / Reduction 631 ........................................................................................ Chapter 132: Resource Management 633 .............................................................................................................. Section 132.1: Resource Acquisition Is Initialization 633 ................................................................................................ Section 132.2: Mutexes & Thread Safety 634 ................................................................................................................. Chapter 133: Storage class specifiers 636 ............................................................................................................ Section 133.1: extern 636 ................................................................................................................................................... Section 133.2: register 637 ............................................................................................................................................... Section 133.3: static 637 ................................................................................................................................................... Section 133.4: auto 638 ..................................................................................................................................................... Section 133.5: mutable 638 .............................................................................................................................................. Chapter 134: Linkage specifications 640 ............................................................................................................... Section 134.1: Signal handler for Unix-like operating system 640 ............................................................................... Section 134.2: Making a C library header compatible with C++ 640 ........................................................................... Chapter 135: Digit separators 642 ............................................................................................................................ Section 135.1: Digit Separator 642 ................................................................................................................................... Chapter 136: C incompatibilities 643 ........................................................................................................................

📄 Page 18

Section 136.1: Reserved Keywords 643 ........................................................................................................................... Section 136.2: Weakly typed pointers 643 ..................................................................................................................... Section 136.3: goto or switch 643 .................................................................................................................................... Chapter 137: Side by Side Comparisons of classic C++ examples solved via C++ vs C++11 vs C++14 vs C++17 644 ..................................................................................................................................................... Section 137.1: Looping through a container 644 ............................................................................................................ Chapter 138: Compiling and Building 645 .............................................................................................................. Section 138.1: Compiling with GCC 645 ........................................................................................................................... Section 138.2: Compiling with Visual Studio (Graphical Interface) - Hello World 646 ............................................... Section 138.3: Online Compilers 651 ............................................................................................................................... Section 138.4: Compiling with Visual C++ (Command Line) 653 .................................................................................. Section 138.5: Compiling with Clang 656 ........................................................................................................................ Section 138.6: The C++ compilation process 656 ........................................................................................................... Section 138.7: Compiling with Code::Blocks (Graphical interface) 658 ........................................................................ Chapter 139: Common compile/linker errors (GCC) 661 ............................................................................... Section 139.1: undefined reference to `***' 661 ................................................................................................................ Section 139.2: error: '***' was not declared in this scope 661 ........................................................................................ Section 139.3: fatal error: ***: No such file or directory 663 ........................................................................................... Chapter 140: More undefined behaviors in C++ 664 ........................................................................................ Section 140.1: Referring to non-static members in initializer lists 664 ......................................................................... Chapter 141: Unit Testing in C++ 665 ....................................................................................................................... Section 141.1: Google Test 665 ......................................................................................................................................... Section 141.2: Catch 665 ................................................................................................................................................... Chapter 142: C++ Debugging and Debug-prevention Tools & Techniques 667 ................................. Section 142.1: Static analysis 667 .................................................................................................................................... Section 142.2: Segfault analysis with GDB 668 .............................................................................................................. Section 142.3: Clean code 669 ......................................................................................................................................... Chapter 143: Optimization in C++ 671 ..................................................................................................................... Section 143.1: Introduction to performance 671 ............................................................................................................ Section 143.2: Empty Base Class Optimization 671 ...................................................................................................... Section 143.3: Optimizing by executing less code 672 .................................................................................................. Section 143.4: Using ecient containers 673 ................................................................................................................. Section 143.5: Small Object Optimization 674 ................................................................................................................ Chapter 144: Optimization 676 .................................................................................................................................. Section 144.1: Inline Expansion/Inlining 676 ................................................................................................................... Section 144.2: Empty base optimization 676 ................................................................................................................. Chapter 145: Profiling 678 ............................................................................................................................................. Section 145.1: Profiling with gcc and gprof 678 ............................................................................................................. Section 145.2: Generating callgraph diagrams with gperf2dot 678 ............................................................................ Section 145.3: Profiling CPU Usage with gcc and Google Perf Tools 679 ................................................................... Chapter 146: Refactoring Techniques 681 ........................................................................................................... Section 146.1: Goto Cleanup 681 ...................................................................................................................................... Credits 682 ............................................................................................................................................................................ You may also like 690 ......................................................................................................................................................

📄 Page 19

GoalKicker.com – C++ Notes for Professionals 1 About Please feel free to share this PDF with anyone for free, latest version of this book can be downloaded from: https://goalkicker.com/CPlusPlusBook This C++ Notes for Professionals book is compiled from Stack Overflow Documentation, the content is written by the beautiful people at Stack Overflow. Text content is released under Creative Commons BY-SA, see credits at the end of this book whom contributed to the various chapters. Images may be copyright of their respective owners unless otherwise specified This is an unofficial free book created for educational purposes and is not affiliated with official C++ group(s) or company(s) nor Stack Overflow. All trademarks and registered trademarks are the property of their respective company owners The information presented in this book is not guaranteed to be correct nor accurate, use at your own risk Please send feedback and corrections to web@petercv.com

📄 Page 20

GoalKicker.com – C++ Notes for Professionals 2 Chapter 1: Getting started with C++ Version Standard Release Date C++98 ISO/IEC 14882:1998 1998-09-01 C++03 ISO/IEC 14882:2003 2003-10-16 C++11 ISO/IEC 14882:2011 2011-09-01 C++14 ISO/IEC 14882:2014 2014-12-15 C++17 TBD 2017-01-01 C++20 TBD 2020-01-01 Section 1.1: Hello World This program prints Hello World! to the standard output stream: #include <iostream> int main() { std::cout << "Hello World!" << std::endl; } See it live on Coliru. Analysis Let's examine each part of this code in detail: #include <iostream> is a preprocessor directive that includes the content of the standard C++ header file iostream. iostream is a standard library header file that contains definitions of the standard input and output streams. These definitions are included in the std namespace, explained below. The standard input/output (I/O) streams provide ways for programs to get input from and output to an external system -- usually the terminal. int main() { ... } defines a new function named main. By convention, the main function is called upon execution of the program. There must be only one main function in a C++ program, and it must always return a number of the int type. Here, the int is what is called the function's return type. The value returned by the main function is an exit code. By convention, a program exit code of 0 or EXIT_SUCCESS is interpreted as success by a system that executes the program. Any other return code is associated with an error. If no return statement is present, the main function (and thus, the program itself) returns 0 by default. In this example, we don't need to explicitly write return 0;. All other functions, except those that return the void type, must explicitly return a value according to their return type, or else must not return at all.