Skip to content

00 Table of Contents

├── 01 Introduction/
│   ├── Environment Setup/
│   │   ├── Recommended Setup for Windows
│   │   ├── Recommended Setup for macOS
│   │   └── Alternative Setup via Web
│   ├── How C++ Works/
│   │   ├── Entry Point
│   │   ├── Preprocessor Directives
│   │   ├── Compiler
│   │   └── Linker
│   ├── Header Files/
│   │   ├── Header Guard
│   │   └── Header Search
│   ├── Code Comments/
│   │   └── Types of Comments
│   ├── Data Types and Variables/
│   │   ├── Data Types and Variables
│   │   ├── ASCII
│   │   ├── Declaring and Naming Variables
│   │   └── Constants
│   ├── Terminal Input and Output
│   └── Exercises
│
├── 02 Control Flow/
│   ├── If Statements
│   ├── Switch Statements
│   ├── Go To Statements
│   ├── Loops/
│   │   ├── While Loops
│   │   ├── For Loops
│   │   └── Nested Loops
│   ├── Break and Continue
│   ├── Shortened Notations
│   └── Exercises
│
├── 03 Operators/
│   ├── Comparison Operators
│   ├── Logical Operators
│   ├── Arithmetic Operators/
│   │   └── Shortened Notations
│   ├── Operator Evaluation Order
│   ├── Bitwise Operators/
│   │   ├── Binary Representation
│   │   ├── Conversion Between Decimal and Binary Systems
│   │   ├── Conversion Between Decimal and Hexadecimal Systems
│   │   ├── Conversion Between Decimal and Octal Systems
│   │   ├── Examining Memory Representation in Practice
│   │   ├── Bitwise Shift Operators
│   │   ├── Bitwise Logic Operators/
│   │   │   ├── Bitwise AND
│   │   │   ├── Bitwise OR
│   │   │   ├── Bitwise XOR
│   │   │   └── Bitwise NOT
│   │   └── Writing Binary, Hexadecimal and Octal Values in C++
│   ├── Ternary Operator
│   ├── Operator Overloading
│   └── Exercises
│
├── 04 Functions/
│   ├── Function Creation
│   ├── Return Values/
│   │   └── Mandatory Return Values
│   ├── Multiple Return Values
│   ├── Parameter List
│   ├── Function Declaration vs. Definition
│   ├── Function Overloading
│   ├── Inline Functions
│   ├── Recursion
│   ├── Lambdas/
│   │   ├── When to Use Lambdas
│   │   └── Lambda Use Case
│   └── Exercises
│
├── 05 Data Types/
│   ├── Static and Strong Typing
│   ├── Primitive Data Types/
│   │   ├── Standard Integer Types
│   │   ├── Fixed-Width Integer Types
│   │   ├── Unsigned Integers
│   │   ├── Floating-Point Types
│   │   └── Character Types
│   ├── Automatic Type Inference
│   ├── Determining the Byte Size of Variables
│   ├── Type Casting/
│   │   ├── Conversions
│   │   ├── C-Style Cast
│   │   ├── C++ Casts/
│   │   │   ├── Static Cast
│   │   │   ├── Dynamic Cast
│   │   │   ├── Constant Cast
│   │   │   └── Reinterpret Cast
│   │   └── When to Cast
│   ├── Constants and Compile-Time Constructs/
│   │   ├── Constexpr
│   │   └── Consteval and Constinit
│   ├── Padding and Alignment/
│   │   └── Difference Between Alignment and Byte Size
│   ├── Type Punning
│   ├── Dynamic Typing/
│   │   ├── Optional Data
│   │   ├── Multi-Type Data Holder
│   │   └── Any Data Type
│   ├── Run-Time Type Identification/
│   │   ├── Type ID
│   │   └── Considerations When Using RTTI
│   └── Exercises
│
├── 06 Pointers and References/
│   ├── Memory Allocation
│   ├── Object Lifetimes
│   ├── Raw Pointers/
│   │   ├── Declaring Pointers
│   │   ├── Null Pointers
│   │   ├── Accessing the Memory Address of a Variable
│   │   ├── Dereferencing a Pointer
│   │   ├── Dynamic Memory Allocation/
│   │   │   ├── Initializing Heap Memory
│   │   │   ├── Heap Memory Management
│   │   ├── Constant Pointers/
│   │   │   ├── Pointer to Constant
│   │   │   ├── Constant Pointer
│   │   │   ├── Constant Pointer to Constant
│   │   ├── Pointer to Pointer
│   │   ├── Pointer Safety/
│   │   │   ├── Dangling Pointers
│   │   │   ├── Memory Leaks
│   │   │   ├── Buffer Overflows
│   │   │   ├── Pointer Aliasing and Ownership
│   │   │   ├── Preventions
│   ├── Pointer Arithmetic
│   ├── References/
│   │   ├── Reference vs. Address-of Operator
│   │   ├── Pass by Value vs. Pass by Reference
│   │   ├── When to Pass by Reference
│   ├── Function Pointer
│   ├── Where to Use Function Pointers
│   ├── Lvalues and Rvalues/
│   │   ├── Lvalue Reference
│   │   ├── Rvalue Reference
│   ├── Move Semantics/
│   │   ├── Standard Move Function
│   │   ├── Move Assignment Operator
│   ├── Smart Pointers/
│   │   ├── Unique Pointer
│   │   ├── Shared Pointer
│   │   ├── Weak Pointer
│   │   ├── When to Use Smart Pointers
│   └── Exercises
│
├── 07 Collections of Data/
│   ├── C-Style Arrays/
│   │   ├── Access and Modify Elements
│   │   ├── Iterate Over Arrays
│   │   ├── Pointer Arithmetic on Arrays
│   │   ├── Array Heap Allocation
│   │   ├── Multidimensional Arrays/
│   │   │   ├── Dynamically Allocate a 2D Array
│   │   │   ├── Deallocate a 2D Array
│   │   │   ├── Access Multidimensional Arrays
│   │   │   ├── Optimize Memory Access for Multidimensional Arrays
│   ├── Strings/
│   │   ├── C-Style Strings
│   │   ├── Modifiable C-Style Strings
│   │   ├── C++ Strings
│   │   ├── String Concatenation
│   │   ├── String Literals/
│   │   │   ├── Raw String Literals
│   │   │   ├── Unicode String Literals
│   │   ├── Small Strings
│   │   ├── Optimize Strings in C++/
│   │   │   ├── Substring Operations Overhead
│   │   │   ├── String Views
│   ├── C++ Static Array
│   ├── Dynamic Array/
│   │   ├── Vector Optimization
│   ├── HashMap/
│   │   ├── Hashing Function
│   │   ├── Index Operator
│   ├── Linked List
│   ├── Stack and Queue
│   ├── Iterators/
│   │   ├── Range-Based For Loops
│   └── Exercises
│
├── 08 User Defined Types
│   ├── Structs
│   ├── Unions
│   ├── Enums
│   ├── Classes/
│   │   ├── Static Inside Classe
│   │   ├── Static Outside Classe
│   │   ├── Getters and Setters
│   │   ├── Constant Member Functions
│   │   ├── Constructors/
│   │   │   ├── Member Initializer List
│   │   │   ├── Copy Constructor
│   │   │   ├── Copy Assignment Operator
│   │   │   ├── Move Constructor
│   │   │   ├── Move Assignment Operator
│   │   │   ├── Explicit Constructor
│   │   │   └── Rule of Zero and Five
│   │   ├── Destructors
│   │   ├── Arrow Operator
│   │   ├── Current Instance Pointer
│   ├── Inheritance and Polymorphism
│   ├── Singletons
│   └── Exercises

Working on more...