The complete intermediate to advanced C++ Course 2024

Master basic syntax rules in C++: semicolon-terminated statements, variable declarations, code blocks with curly braces and scope, data types, functions, and control structures including if, loops, and do-while.

Examine the structure of a C++ program from preprocessor directives and including iostream to the using namespace std, main function, prototypes, program statements, and console output that returns zero.

Explore the fundamental C++ data types, including integers (short, int, long, long long) with varying sizes, floating points (float, double, long double), character types (char, char16_t, char32_t), boolean, and void.

master variables and constants in c++, declare with a data type, assign values, and use literal and symbolic constants such as pi and 3.14, and max_size and tax_rate.

Explore local, global, and static variables in C++, and learn how scope and lifetime affect memory management and code clarity.

Explore the scope resolution operator in C++, accessing global variables amid local shadows, defining class members outside the class, and resolving namespace and enumeration scopes.

Explore type modifiers in C++, including signed, unsigned, short, long, long long, const, volatile, register, and auto, and learn how they alter range, size, and storage behavior of basic types.

Explore arithmetic operators in c++ to perform addition, subtraction, multiplication, division, and modulus on numeric operands, including integer division truncation and prefix or postfix increment and decrement.

Master relational operators in C++, using ==, !=, >, <, >=, <= to compare operands and drive decisions in if statements and loops.

Explore the assignment operator in C++, including simple assignment and compound forms like addition, subtraction, multiplication, division, and modulus assignments that update variables.

Explain that a C-style string is a null-terminated char array, show how to declare, initialize, access, and modify it, and cover key functions like strlen, strcpy, strcat, and strcmp.

Explore the string class in the C++ standard library, a safer way to handle text than C‑style strings, with length, empty, append, substr, replace, find, and compare.

Explore the if else statement in C++, a core control flow tool that executes code based on conditions being true or false, with else if, nesting, and readability best practices.

Explore how the switch statement in C++ selects a code block based on a variable's value, using case constants, break, default, and fall-through behavior to manage control flow.

Explore how the while loop in C++ repeatedly executes code while a boolean condition stays true, including counter-based and user-input examples, with tips to avoid infinite loops.

Learn how the do while loop in C++ guarantees at least one execution and differs from a pre-check while loop, with examples like prompting user input until zero.

Master the for loop in C++ by understanding initialization, condition, and increment, and learn to iterate arrays with nested loops, break early, and avoid infinite loops.

Learn how nested loops place one loop inside another to process multi-dimensional data like matrices, with for and while patterns and practical examples such as a multiplication table.

Master continue statement in C++, a control flow tool that skips the rest of the current loop iteration and proceeds to the next one in for, while, and do-while loops.

Explore how to use the C++ regex library to search, match, and replace patterns in strings, including std::regex, std::regex_match, std::regex_search, and std::regex_replace, with an email extraction example and common patterns.

Explore object oriented programming in Python by defining classes and objects, and applying attributes, methods, inheritance, encapsulation, and polymorphism to create modular, maintainable, and scalable code.

Discover std::string_view's non-owning, immutable view for efficient string handling, and master std::format and std::print for type-safe, flexible formatting to improve readability and maintainability in modern C++20.

Discover how C++ functions declare return types before the function name, covering void, primitive types, user defined types, references, pointers, and std containers like string, vector, tuple, and pair.

Understand function overloading in C++, using the same function name with different parameter lists; the compiler selects the correct function at compile time based on the signature.

Explore how to define a struct in c++ to group related variables, compare it with a class, and initialize members via direct assignment, list initialization, or constructors.

Explore constructors and destructors in C++: learn default, parameterized, copy, and move constructors, and how destructors release resources to manage object lifecycles.

Learn how to pass arrays to functions in C++ by passing references to memory, avoiding copies, with one- and multi-dimensional examples, and modern options like std::array and std::vector.

Learn how namespaces in C++ group variables, functions, classes, and objects to prevent name collisions in projects, using the scope resolution operator and the using keyword.

Explores pointers in c++, showing how they store memory addresses to access arrays and dynamically allocated memory, enabling data structures such as linked lists and trees while avoiding memory leaks.

Explore pointer arithmetic in C++, covering incrementing and decrementing pointers, adding or subtracting integers, and subtracting two pointers to get number of elements between them in arrays and dynamic memory.

Discover how dynamic memory allocation in C++ uses new and delete to allocate heap memory for single objects and arrays, with reminders on leaks and dangling pointers.

Declare a reference with an ampersand to alias a variable, initialize at declaration, prevent reassignment to another variable, and enable passing or returning objects by reference to modify the data.

Compare pointers and references in C++, covering initialization, reassignment restrictions, nullability, and address-of and dereference operations. Explore dynamic memory allocation, pointer arithmetic, and function parameter and return type use cases.

Explore how a class acts as a blueprint for objects, encapsulating attributes and methods while supporting instantiation, abstraction, inheritance, and polymorphism in C++.

Learn how to define and create classes in C++, using the class keyword and a body of data and methods. Understand access specifiers, constructors, destructors, and encapsulation for objects.

Learn how getters (accessors) and setters (mutators) provide controlled access to private data in C++, encapsulating information and enabling validation to maintain class invariants.

Explore how base and derived classes implement inheritance in C++, enabling code reuse, extensibility, and a hierarchical class structure through object-oriented programming principles.

Explore encapsulation and abstraction as core object-oriented principles, using private, public, and protected access modifiers to hide data and expose behavior.

Function templates enable generic programming by defining one function that works with any data type using a type parameter, with compiler-driven instantiation; gain code reusability, type safety, and maintainability.

Explore class templates in C++, learn how generic classes use type parameters to operate with any data type, and see instantiation and code reuse across single and multi-parameter templates.

Explore standard template library containers such as vector, list, queue, set, and map, and learn how unordered set and unordered map enable fast lookups and insertions.

Explore the STL algorithms in C++, using iterators, function objects, and lambdas to perform non modifying, modifying, sorting, numeric, and set operations on containers.

Open and close files safely in C++ with AppStream, use ofstream and ifstream, write with the insertion operator, and read with the extraction operator.

Define and reuse code with macros in C++, a preprocessor feature that turns tokens into constants or code. Explore object-like and function-like macros, conditional compilation, examples, and potential pitfalls.

Move semantics in C++11 transfers ownership from temporaries via rvalue references, move constructors, and move assignment operators, enabling efficient resource management.

Explore lambda expressions in C++, as anonymous function objects, with capture by value or reference, parameters, return types, and mutability, plus using them with standard algorithms for concise code.

Explore generic and template lambdas in C++14 and C++20, using auto parameters for any type, enabling flexibility, code reuse, and type-safe operations especially with standard algorithms.

Explore recursive lambdas and how they call themselves using std::function and the Y combinator, with factorial and fibonacci examples. Also covers std::decay and std::forward as related techniques.

Identify lvalues as objects with a memory location and persistent state. Differentiate rvalues as temporary values on the right side of assignments, including rvalue references.

Explore variadic function templates in C++11 that accept any number of arguments, enabling flexible, reusable, and type-safe printing and summing with recursion and for expressions.

Learn how to perform compile-time assertion checks with static_assert in c++, validating type sizes, template parameters, and array sizes during compilation to catch errors early and improve reliability.

Learn to conditionally compile templates and classes using std::enable_if, enabling integral or floating-point overloads via substitution failure in template metaprogramming.

Select branches at compile time with constexpr if to conditionally compile code in templates and concepts, improving efficiency and readability by removing unnecessary branches.

Master date and time in c++, using chrono and system_clock to get the current date, convert to local time, add 24 hours, and format dates with custom patterns.

use std::chrono high_resolution_clock to measure a function's execution time by capturing start and end timepoints, computing the duration, and printing the elapsed seconds.

Store and retrieve values of any type in C++ safely with std::any, using type checks and safe retrieval to handle integers and strings and manage bad casts.

Explore how to use std::optional to store values that may be present or absent, including header optional, has_value or bool, dereference with the star operator, and value_or for defaults.

Explore how std::variant acts as a type-safe union that can hold int, double, or string, with get and visit to access and apply actions to the stored value.