Sitemap
Browse all available content on helloC++.dev
Daily Concepts (100)
- Hello World & Your First Program
- Variables & Data Types
- Arithmetic Operators
- Basic Input/Output
- If-Else Statements
- Switch Statements
- While Loops
- For Loops
- Break and Continue
- Functions Basics
- Function Parameters
- Return Values
- Function Overloading
- Recursion
- Arrays Basics
- Multidimensional Arrays
- C-Style Strings
- std::string Class
- String Operations
- Character Manipulation
- String Streams
- Pointers
- References
- Pointer Arithmetic
- Pointers and Arrays
- Pointers vs References
- Dynamic Memory Allocation
- Memory Leaks and Management
- Structures
- Union and Enum
- Classes Introduction
- Constructors
- Destructors
- Access Modifiers
- this Pointer
- Const Correctness
- Static Members
- Encapsulation
- Copy Constructor
- Assignment Operator
- Operator Overloading
- Friend Functions
- Inheritance Basics
- Protected Members
- Virtual Functions
- Pure Virtual Functions
- Abstract Classes
- Polymorphism
- Multiple Inheritance
- Rvalue References
- Move Semantics
- Perfect Forwarding
- Rule of Three/Five
- Function Templates
- Class Templates
- Template Specialization
- Variadic Templates
- Template Metaprogramming Introduction
- SFINAE - Substitution Failure Is Not An Error
- Type Traits
- Vector - Dynamic Arrays
- List and Deque
- Stack and Queue
- Priority Queue
- Set and Multiset
- Map and Multimap
- Unordered Containers
- Iterators
- Algorithm Basics
- Sorting and Searching
- Transform and Accumulate
- Lambda Expressions
- Function Objects (Functors)
- std::function
- Auto and Decltype
- Range-Based For Loops
- Smart Pointers - unique_ptr
- Smart Pointers - shared_ptr
- Smart Pointers - weak_ptr
- RAII Principle
- Exception Handling
- Custom Exceptions
- Error Handling Best Practices
- File Input/Output
- Binary Files
- File Stream Manipulation
- Threads Basics
- Mutex and Lock
- Condition Variables
- Atomic Operations
- Futures and Promises
- Async
- Thread Pools
- Inline Functions
- Namespaces
- Preprocessor Directives
- Bit Manipulation
- Memory Alignment
- Design Patterns in C++
- Building a Complete Project
Guided Projects (9)
Blog Posts (16)
- Understanding Big O Notation: A Beginner's Guide to Algorithm Efficiency
- Working with GitHub: Remote Repositories and Collaboration
- Understanding Git Commits: Snapshots, History, and Time Travel
- Git Branches and Merging: Parallel Development Without Chaos
- Your First Git Repository: init, add, commit
- Installing Git: Setup for Windows, macOS, and Linux
- What is Version Control? The Problem Git Solves
- New Feature: Build Projects Locally with Git Integration
- Git Fundamentals: Version Control for C++ Developers
- Application Monitoring with Sentry: From Bugs to Performance
- End-to-End Testing with Playwright: Building Confidence in Complex Features
- Achieving Zero Downtime Deployment: Why User Experience Matters
- Test-Driven Development: Writing Better Code
- Building Software at Scale: Real-World Engineering Practices
- HelloC++: Discover. Practice. Build. Repeat.
- Why C++? And Why Am I Teaching It?
Reading C++ Assembly
Learn to read the x86-64 assembly your C++ compiles into. Understand registers, the stack, calling conventions, control flow, how C++ features like virtual functions look at machine level, and what the optimizer really does to your code.
From C++ to Assembly
x86-64 Foundations: Registers and Instructions
Control Flow in Assembly
Functions, the Stack, and Calling Conventions
Data, Pointers, and Memory
C++ Features in Assembly
ANSI C (C89)
The classic ANSI C university syllabus, taught in its traditional order from tokens and operators through arrays, strings, functions, structures, pointers, files, and linked lists. Every program you write is compiled as strict C89 with pedantic errors, exactly the dialect old exam papers assume, but written correctly: real prototypes, checked return values, safe input, and AddressSanitizer verifying every run. Includes exam notes wherever old compilers and question papers differ from what the language actually guarantees.
Getting Started with C
Constants, Variables, and Data Types
Operators and Expressions
Input and Output
Branching
Arrays
Character Arrays and Strings
Functions
Structures and Unions
Pointers
File Handling
Dynamic Memory and Linked Lists
The Preprocessor
C Fundamentals
Learn C from your very first program with memory as your map: see where variables live, follow the call stack, and master pointers and dynamic memory early instead of last. Arrays, strings, structs, and error handling all build on that same picture, with undefined behaviour called by its name and AddressSanitizer checking every program you run.
Programs, Variables, and Memory
Data, Operators, and Control Flow
Functions and the Call Stack
Arrays and Dynamic Memory
Strings
Structs, Enums, and Program Organization
Floating Point, Errors, and Undefined Behaviour
C++ Programming Fundamentals
Start from scratch with variables, data types, and functions. Build up to operators, control flow, scope management, and your first classes.
C++ Basics
- Welcome to C++
- Essential C++ Terminology (Reference)
- Your First Program: Hello World!
- Comments
- Basic C++ Errors
- Statements
- If Statements
- Whitespace and Formatting
- C++ Naming Conventions
- Objects and Variables
- Data Types
- Variable Assignment and Initialization
- Undefined Behavior
- Literals and Operators
- Expressions
- Iostream: std::cout, std::cin, and std::endl
- Beyond Basic C++ Errors
- C++ Error Reference (Reference)
- Developing Your First Program
- C++ Basics Summary
Built-in Data Types in C++
- Data Types Terminology (Reference)
- Fundamental Data Types
- void Data Type
- sizeof Operator
- Signed Integers
- Unsigned Integers
- Fixed-Width Integers
- Scientific Notation Fundamentals
- Using Floating-Point Numbers
- Boolean Data Type
- Character Data Type
- static_cast and Type Conversion
- Built-in Data Types in C++ Summary
Functions and Files
- Functions and Files Terminology (Reference)
- Function Basics
- Void Functions
- Functions with Return
- Parameters and Arguments
- Local Scope
- Better Programs with Functions
- Forward Declarations
- Multi-File Programs
- Namespaces
- The Preprocessor
- Header Files
- Header Guards
- Program Design with Functions
- Functions and Files Summary
Working with Constants and Text
- Constants and Text Terminology (Reference)
- const Variables
- Literals
- Numeral Systems
- As-If Rule and Compile-Time Optimization
- Constant Expressions
- constexpr Variables - Compile-Time Constants
- std::string for Text Handling
- Using std::string_view
- Advanced std::string_view Techniques
- Working with Constants and Text Summary
C++ Operators and Expressions
- Operators Terminology (Reference)
- Understanding Operator Precedence Rules
- Mathematical Operations with Arithmetic Operators
- Modulo and Power Operations
- Increment and Decrement Operators
- Comma Operator
- Ternary Conditional Expressions
- Relational Operators
- Boolean Logic with Logical Operators
- C++ Operators and Expressions Summary
Program Flow and Decision Making
- Control Flow Terminology (Reference)
- Understanding Program Control Flow
- Conditional Execution with If Statements
- Avoiding Common If Statement Pitfalls
- Compile-Time Conditionals with constexpr if
- Multi-Way Branching with Switch Statements
- Advanced Switch Statement Techniques
- Understanding Goto and Why to Avoid It
- Repetition with While Loops
- Post-Test Loops with Do-While
- Counter-Controlled Loops with For
- Controlling Loop Execution
- Early Program Termination Techniques
- Generating Random Numbers in C++
- High-Quality Random Numbers with Mersenne Twister
- Creating a Global Random Number Generator
- Program Flow and Decision Making Summary
Variable Scope and Lifetime Management
- Scope and Lifetime Terminology (Reference)
- Organizing Code with Compound Statements
- Creating Custom Namespaces
- Understanding Local Variable Scope and Lifetime
- Working with Global Variables
- Understanding Variable Shadowing
- Limiting Visibility with Internal Linkage
- Sharing Variables with External Linkage
- The Problems with Global Mutable State
- Defining Inline Functions and Variables
- Sharing Constants with Inline Variables
- Preserving State with Static Local Variables
- Scope, duration, and linkage Summary
- Namespace Access with Using Declarations
- Advanced Namespace Techniques
- Variable Scope and Lifetime Management Summary
Object-Oriented Programming Basics
- OOP Terminology (Reference)
- Object-Oriented Programming Fundamentals
- Defining Classes in C++
- Adding Behavior to Classes
- Immutable Objects and Const Member Functions
- Controlling Member Access
- Getters and Setters for Class Members
- Returning References from Member Functions
- Encapsulation and Information Hiding
- Object Initialization with Constructors
- Efficient Member Initialization
- Parameterless and Default-Parameter Constructors
- Constructor Delegation for Code Reuse
- Understanding Temporary Objects
- Copying Objects with Copy Constructors
- Optimizing Object Construction
- Preventing Implicit Conversions
- Compile-Time Class Objects
- Object-Oriented Programming Basics Summary
C++ (plus)
Go deeper with type inference, references, enums, structs, and function templates. Covers compile-time evaluation, std::vector, and arrays.
Type Systems and Automatic Type Inference
- Type Inference Terminology (Reference)
- Automatic Type Conversions in C++
- Numeric Type Promotions
- Converting Between Numeric Types
- Safe Initialization and Narrowing Conversions
- Mixed-Type Arithmetic Conversions
- Manual Type Casting Techniques
- Creating Type Aliases for Clarity
- Automatic Type Deduction with auto
- Function Return Type Deduction
- Type Systems and Automatic Type Inference Summary
References and Memory Addresses
- References and Pointers Terminology (Reference)
- Building Complex Types from Simple Ones
- Understanding Lvalues and Rvalues
- Creating References to Objects
- Read-Only References with const
- Efficient Parameter Passing by Reference
- Read-Only Parameter Passing
- Understanding Memory Addresses and Pointers
- Representing Absent Pointers with nullptr
- Const Correctness with Pointers
- Parameter Passing with Pointers
- Advanced Pointer Parameter Techniques
- Returning References and Pointers from Functions
- Parameter Passing Conventions
- Auto Type Deduction with Pointers and References
- Representing Optional Values with std::optional
- References and Memory Addresses Summary
Custom Data Types with Enums and Structs
- Enums and Structs Terminology (Reference)
- Creating Custom Data Types
- Defining Enumeration Types
- Converting Enumerations to Integers
- String Conversion for Enumerations
- Custom Input/Output with Operator Overloading
- Type-Safe Enumerations with enum class
- Grouping Data with Structs
- Initializing Struct Members
- Providing Default Member Values
- Struct Parameter and Return Techniques
- Additional Struct Features and Best Practices
- Accessing Members Indirectly
- Generic Types with Class Templates
- Automatic Template Argument Deduction
- Creating Template Type Aliases
- Custom Data Types with Enums and Structs Summary
Advanced Function Techniques and Templates
- Function Templates Terminology (Reference)
- Function Overloading
- Overload Differentiation
- Overload Resolution
- Deleted Functions
- Default Arguments
- Function Templates
- Template Instantiation
- Multiple Template Types
- Non-Type Template Parameters
- Templates in Multiple Files
- Advanced Function Techniques and Templates Summary
Compile-Time Function Evaluation
Advanced Class Concepts and Techniques
- Advanced Class Terminology (Reference)
- The this Pointer and Method Chaining
- Organizing Class Definitions
- Defining Types Within Classes
- Resource Cleanup with Destructors
- Implementing Generic Class Behavior
- Class-Level Data with Static Members
- Class-Level Functions
- Granting External Function Access
- Cross-Class Access with Friend Declarations
- Overloading Based on Object Value Category
- Advanced Class Concepts and Techniques Summary
Resizable Arrays with std::vector
- Vector Terminology (Reference)
- Storing Collections of Data
- Creating Dynamic Arrays with std::vector
- Index Type Considerations for std::vector
- Efficient Vector Parameter Passing
- Returning Vectors Efficiently
- Iterating Through Array Elements
- Array Iteration Patterns and Solutions
- Simplified Iteration with Range-Based For
- Type-Safe Array Indexing with Enums
- Managing Vector Size and Memory
- Using std::vector as a Stack
- The Specialized bool Vector
- Resizable Arrays with std::vector Summary
Fixed-Size Arrays and C-Style Arrays
- Arrays Terminology (Reference)
- Fixed-Size Arrays with std::array
- Working with std::array Size and Indices
- std::array Parameter and Return Techniques
- Working with std::array of Custom Types
- Creating Reference Arrays
- Using Enumerations with std::array
- Understanding Legacy C Arrays
- Array-to-Pointer Conversion
- Navigating Memory with Pointer Arithmetic
- Null-Terminated Character Arrays
- String Literals in C++
- Working with Multi-Dimensional C Arrays
- Fixed Multi-Dimensional Arrays
- Fixed-Size Arrays and C-Style Arrays Summary
Advanced C++ Programming
Dynamic memory, operator overloading, move semantics, inheritance, virtual functions, class templates, exception handling, file I/O, and multithreading.
Managing Memory at Runtime
- Memory Management Terminology (Reference)
- Manual Memory Management with new and delete
- Creating Arrays at Runtime
- Cleaning Up Dynamic Resources
- Multi-Level Indirection
- Generic Pointer Type
- Understanding Function Pointers
- Understanding Stack and Heap Memory
- Functions Calling Themselves
- Processing Program Arguments
- Variable Argument Lists
- Creating Inline Functions
- Variable Capture in Lambdas
- Managing Memory at Runtime Summary
Custom Operator Implementations
- Operator Overloading Terminology (Reference)
- Customizing Operator Behavior
- Arithmetic Operator Overloading
- Non-Member Operator Overloading
- Custom Stream Input/Output
- Member Operator Overloading
- Unary Operator Overloading
- Comparison Operator Overloading
- Increment/Decrement Operator Overloading
- Array-Style Access Operator
- Function Call Operator Overloading
- Custom Type Conversion Operators
- Copy Assignment Operator Overloading
- Understanding Shallow and Deep Copies
- Combining Operator Overloading with Templates
- Custom Operator Implementations Summary
Efficient Resource Management with Move Semantics
Modeling Relationships Between Objects
- Object Relationships Terminology (Reference)
- Understanding Object Relationships
- Building Complex Objects from Simple Parts
- Modeling Has-A Relationships
- Modeling Uses-A Relationships
- Managing Object Dependencies
- Creating Custom Container Types
- std::initializer_list
- Modeling Relationships Between Objects Summary
Code Reuse Through Inheritance
- Inheritance Terminology (Reference)
- Code Reuse Through Inheritance
- Implementing Class Hierarchies
- Understanding Construction Order
- Initializing Base and Derived Classes
- Controlling Inherited Member Access
- Extending Base Class Behavior
- Method Overriding in Derived Classes
- Shadowing Base Class Members
- Inheriting from Multiple Base Classes
- Code Reuse Through Inheritance Summary
Runtime Polymorphism with Virtual Functions
- Polymorphism Terminology (Reference)
- Base Class Pointers and References
- Dynamic Dispatch with Virtual Functions
- Ensuring Correct Overrides
- Virtual Special Member Functions
- Compile-Time vs Runtime Binding
- How Virtual Functions Work Internally
- Defining Abstract Interfaces
- Resolving Multiple Inheritance Ambiguity
- Understanding Object Truncation
- Safe Downcasting with dynamic_cast
- Output Streaming for Hierarchies
- Runtime Polymorphism with Virtual Functions Summary
Generic Programming with Class Templates
Error Handling with Exceptions
- Exceptions Terminology (Reference)
- Why Exception Handling is Necessary
- Try-Catch Exception Handling
- How Exceptions Propagate
- Handling Unexpected Exceptions
- Class-Based Exception Hierarchies
- Propagating Exceptions Up the Call Stack
- Exception Handling in Constructors
- Exception Safety Considerations
- Documenting Exception Guarantees
- Conditional Move Optimization
- Error Handling with Exceptions Summary