Learn C++ One Concept at a Time

Write your first C++ program and understand how compilation works

Fundamental data types and how to store information in variables

Master C++ arithmetic operations and understand operator precedence for accurate calculations

Learn to interact with users through console input and formatted output

Learn to make decisions in your code with conditional statements and boolean logic

Learn to handle multiple discrete values elegantly with switch statements and understand fall-through behavior

Master repetition in C++ with while loops and learn to avoid infinite loops

Learn the most versatile loop in C++ for counting, iterating, and repeating operations

Master loop control with break and continue statements to exit loops early or skip iterations

Learn to create reusable code blocks with functions, including declaration, definition, and calling conventions

Learn to pass data into functions using parameters, understand pass-by-value, and create flexible reusable functions

Master function return values to create functions that compute and send data back to the caller

Learn to create multiple functions with the same name but different parameters, making your code more intuitive and flexible

Master recursive functions - functions that call themselves to solve problems by breaking them into smaller, similar subproblems

Learn to work with arrays - fixed-size collections that store multiple values of the same type in contiguous memory

Master multidimensional arrays to represent tables, matrices, and grids using arrays of arrays

Understand C-style strings as character arrays with null terminators and learn fundamental string manipulation functions

Master the modern std::string class for safe, convenient, and powerful string handling in C++

Master advanced string operations including substring extraction, searching, replacing, and string manipulation techniques

Master character classification and conversion functions to test and transform individual characters

Master stringstream for parsing, formatting, and converting between strings and other data types

Variables that store memory addresses, allowing direct manipulation of data in memory.

Aliases for existing variables, providing an alternative name for the same memory location.

Master pointer arithmetic to navigate through memory, increment and decrement pointers, and traverse arrays efficiently

Understand the deep relationship between pointers and arrays, array decay, and pointer notation for array access

Learn the key differences between pointers and references, and when to use each in professional C++ code

Master dynamic memory allocation with new and delete operators to create variables and arrays at runtime on the heap

Understand memory leaks, how to detect them, and best practices for managing dynamic memory safely

Learn to group related data together using structures, the foundation for object-oriented programming in C++

Master enumerations for type-safe constants and unions for memory-efficient data

Discover the power of classes in C++ to bundle data and behavior together, the cornerstone of object-oriented programming

Master constructors to automatically initialize objects correctly and prevent bugs from uninitialized data

Learn how destructors automatically clean up resources and prevent memory leaks when objects are destroyed

Control access to class members with public, private, and protected modifiers to enforce encapsulation

Understand the this pointer that every member function receives and learn when to use it explicitly

Using const to specify immutability and prevent accidental modifications

Learn how static members belong to the class itself rather than individual objects

Master the fundamental OOP principle of bundling data with methods and hiding implementation details

Master copy constructors to control how objects are copied and prevent shallow copy problems

Master the assignment operator to control object assignment and handle self-assignment correctly

Learn how to redefine operators to work naturally with your custom classes

Learn how to use friend functions to grant external functions controlled access to private class members

Learn how to create derived classes that inherit properties and behaviors from base classes

Master the protected access specifier to control inheritance while maintaining encapsulation

Master virtual functions to enable runtime polymorphism and dynamic dispatch

Create abstract interfaces using pure virtual functions that derived classes must implement

Design abstract base classes that define common interfaces and shared implementation

Master polymorphism to write flexible code that works with objects of different types through a common interface

Learn how to inherit from multiple base classes and handle the diamond problem

Master rvalue references to enable move semantics and eliminate unnecessary copying

Master C++11 move semantics to efficiently transfer resources instead of copying them

Master perfect forwarding with std::forward for writing efficient generic code

Master the Rule of Three/Five for complete resource management in C++ classes

Learn how to write generic functions using templates that work with any data type

Learn how to create generic classes that work with any data type using C++ class templates

Learn how to customize template behavior for specific types using full and partial template specialization

Master variadic templates to create functions and classes that accept any number of arguments with full type safety

Learn the basics of compile-time computation using templates as a functional programming language

Master SFINAE to enable or disable template functions based on type properties and create sophisticated compile-time type checking

Master the <type_traits> library for compile-time type information, transformations, and conditional compilation

Master std::vector, the most versatile and commonly used STL container for dynamic array management

Learn std::list (doubly-linked list) and std::deque (double-ended queue) for efficient insertion and deletion operations

Learn std::stack and std::queue container adapters for LIFO and FIFO data structures

Master std::priority_queue for automatically maintaining elements in priority order with O(log n) operations

Master std::set and std::multiset for automatically sorted, unique (or duplicate) element storage with fast lookups

Master std::map and std::multimap for efficient key-value storage with automatic sorting and fast lookups

Master hash-based unordered_set and unordered_map for O(1) average-case performance when order doesn't matter

Master iterators, the glue between containers and algorithms that enables generic programming in C++

Master fundamental STL algorithms like find, count, copy, and fill that work with any container

Master STL sorting and searching algorithms with custom comparators and understand their performance characteristics

Master std::transform and std::accumulate for powerful data transformations and reductions

Master lambda expressions for creating inline anonymous functions with captures for powerful, concise code

Learn function objects (functors) - classes that act like functions and provide state and customization

Master std::function, the polymorphic wrapper that can store any callable object for flexible callback systems

Master automatic type deduction with auto and decltype for cleaner, more maintainable code

Simplify iteration with C++11's range-based for loops for cleaner, safer code

Master unique_ptr for automatic memory management with exclusive ownership

Master shared_ptr for automatic memory management with shared ownership

Master weak_ptr to break circular references and safely observe shared objects

Master Resource Acquisition Is Initialization for automatic resource management

Learn how to handle errors gracefully using C++ exception handling mechanisms

Create custom exception classes to provide domain-specific error information

Master comprehensive strategies for writing robust, error-resistant C++ applications

Master reading from and writing to files using C++ file streams

Learn to work with binary files for efficient data storage and retrieval

Master advanced file stream operations including seeking, positioning, and state management

Learn to create and manage threads for concurrent programming in C++

Learn to synchronize thread access to shared data using mutexes and locks to prevent data races

Master efficient thread coordination using condition variables to signal between threads

Master lock-free thread-safe operations using atomic types for high-performance concurrent programming

Learn to handle asynchronous results elegantly using futures and promises for cleaner concurrent code

Simplify asynchronous programming with std::async for automatic thread management and result handling

Master efficient concurrent task management using thread pools to avoid thread creation overhead

Understand inline functions for zero-overhead abstraction

Organize code and prevent name collisions with C++ namespaces

Master preprocessor directives for conditional compilation and code generation

Master bitwise operations for efficient low-level programming

Understand memory alignment for performance and correctness

Master essential software design patterns for building maintainable C++ applications

Build a comprehensive task management system combining all C++ concepts learned