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 (8)
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
- Test-Driven Development: Writing Better Code
- Achieving Zero Downtime Deployment: Why User Experience Matters
- Building Software at Scale: Real-World Engineering Practices
- HelloC++: Discover. Practice. Build. Repeat.
- Why C++? And Why Am I Teaching It?
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