Modern C++ from Scratch: C++23, STL, OOPS & Multithreading

Explore procedural programming in C++ from fundamentals to modern concepts, starting with your first program in Visual Studio and progressing through data types, control flow, and memory.

Write your first C++ program in Visual Studio, using preprocessor directives, the main function, and input/output streams as the compiler preprocesses, analyzes, translates, and links to an executable.

Learn to create a Visual Studio console app, organize code with header and source files, and declare and define functions across multiple files for building and running a C++ program.

Explore primitive data types in c++, including integers, floating point numbers, and characters, and learn how literals, const, and references shape memory, type safety, and operations.

Explore primitive data types in C++ through a Visual Studio project, examining short, int, long, char, float, double, bool, and void, including numeric limits and precision.

Explore the types of literals in C++, including integer, floating point, character, string, boolean, and pointer literals, and learn how bases, suffixes, escape sequences, and the null terminator shape representation.

Explore c++ literals with a simple program that demonstrates char, int, octal, hex, binary, long, long long, bools, and floating literals with suffixes; visualize results with bitset and formatted output.

Explore const for immutability and references as aliases to variables, enabling no copying, safe parameter passing, and reliable access to the same memory location.

Explore const, references, and const references in a simple C++ program, showing how a normal reference modifies the original number while a const reference reads it.

Explore type casting, aliasing, and inference in C++. Learn how implicit and explicit conversions affect values, how to alias complex types, and how auto and decltype infer types.

Explore implicit and explicit typecasting in C++, focusing on static_cast and const_cast, compare to unsafe C-style casts, and explain narrowing conversions and potential loss of precision.

Explore typecasting in C++ from legacy C-style casts to modern static_cast and const_cast, demonstrating truncation, ASCII conversions, and potential undefined behavior in a hands-on example.

Explore type aliasing in c++ with typedef and using, and preview auto and decltype for type inference, emphasizing readability and portability.

learn how to create type aliases in C++ using typedef and using, improving readability and maintainability for primitive and complex types, with modern using advantages for templates.

Explore type inference in modern c++, introduced in c++11 and enhanced in c++14, using auto to deduce from initializers and decltype auto to handle iterators, references, and qualifiers with precision.

Explore how modern C++ uses type inference with auto, decltype, and decltype auto to deduce types from initializers and expressions, enabling cleaner, more precise code.

Master initialization in C++ by comparing direct, uniform, and value initialization, understanding copy initialization, and preventing narrowing with curly brace syntax for primitives, arrays, and user-defined types.

Explore how initialization works in C++ by covering direct, uniform, value, and copy initialization with primitive types; learn how braces prevent narrowing and why certain conversions are unsafe.

Explore arithmetic operators in c++, including plus, minus, multiply, divide, modulus, and increment/decrement, and learn about expressions, operands, and type conversions. Highlight integer versus floating point division and explicit casting.

Explore arithmetic operations and pre and post increment in C++, differentiate integer and floating point division, modulus, and type casting with static_cast when mixing operands.

Master relational operators in C++ for int, float, char, and bool, including ASCII values and caveats, and apply logical operators &&, ||, and ! with short-circuit evaluation to form conditions.

Explore relational and logical operators in C++, including short circuit evaluation and a floating point precision issue, with ASCII character comparisons and practical code demonstrations.

Explore binary literals, bitwise operators, and the bitset container in C++ for low-level programming and embedded systems, including examples of and, or, xor, not, shifts, and bit manipulation methods.

Explore binary literals, bitwise operators, and the bitset class in C++ for low-level bit manipulation with and, or, xor, not, left and right shifts.

Explore compound assignment operators in c++, including plus-equal, minus-equal, and bitwise variants, to update values concisely and support arithmetic tasks while improving readability and efficiency.

Demonstrate compound assignment operators in C++ by updating x with arithmetic and bitwise operations using y, showing values 10 to 6 to 2 to 8 to 9 to 10.

Explore the ternary operator as a concise conditional expression and the sizeof operator as a compile-time memory size tool in C++. See a max-of-two-numbers example and type sizes.

Explore how the ternary operator selects the smaller of two integers and checks even or odd, then use the sizeof operator to measure type and array memory.

Master cin and cout for console input and output in C++, format numbers with manipulators and flags, read strings and lines, and safely handle input errors.

Explore C++ console input-output with cin and cout, using manipulators and formatting flags to control numbers, bases, and booleans, plus robust string input and error recovery.

Learn to debug c++ programs in visual studio community edition by setting breakpoints, watching variables in the watch window, and stepping through code with f10, f11, and shift f11.

Explore control flow constructs in C++, including if, if-else, if-else-if, nested ifs, and switch. Learn how these decisions drive code, use break to prevent fall-through, and apply default switch cases.

Explore five C++ control flow constructs—if, if-else, if-else-if, nested ifs, and switch through hands-on code demos. Use the Visual Studio debugger to set breakpoints, watch variables, and step through scenarios.

Master C++ loop constructs, including while, do-while, and for loops, with nested loops and control statements like break and continue, illustrated by a multiplication table and practical examples.

Explore debugging loops in C++ using Vigil Studio, set breakpoints, and step through while, do-while, for, and nested loops to observe runtime behavior and variable updates.

Explore how c++ control flow interruptions like break, continue, goto, exit, and return alter execution in loops and blocks, exit loops, skip iterations, and terminate functions.

Explore how break, continue, goto, exit, and return shape control flow in C++ loops with the Visual Studio debugger, showing iterations, unconditional goto jumps, and function returns.

Explore how C++17 introduces initializers in if, while, and switch statements to declare variables with restricted scope, reducing clutter and improving readability.

Explore why functions are essential in C++, organizing code into modular, reusable blocks, reducing duplication, supporting the DRY principle and the single responsibility principle, and improving readability, debugging, and maintenance.

Learn how to declare, define, and call functions in C++ to write modular, readable code. Explore function prototypes, return types, parameters, and examples like add to practice clean, reusable programming.

Watch a C++ code demo of function calls, declarations versus definitions, and how arguments, scope, and returned values flow between main, greet, and square.

Explore how a function call transfers control, creates a new stack frame, and passes arguments by value, reference, or pointer, shaping memory and execution.

Explore parameter passing in c++ through pass by value and pass by reference. Compare copies versus aliases and note efficiency for large data types.

Explore call-by-value and call-by-reference in C++ with a live debugger demo, showing how copies versus references change variables like a, x, and b, and why this matters for bug-free code.

Learn function overloading in C++ by showing how the same function name handles different parameter types and counts. See how default arguments enable flexible, concise calls and reduce overloads.

Demonstrate function overloading and default parameters in C++, showing how the same function name resolves to int, double, string, or two-int variants, with defaults applied at compile time.

Explore inline functions and recursion in C++, showing how the compiler inlines small functions, how recursion uses the call stack and base cases, and when loops are more efficient.

Explore inline and recursive functions in C++, observe call stack behavior in the debugger, and learn how base cases prevent stack overflow.

Explore how a program loads into memory and divides into the stack, heap, initialized data, uninitialized data, and the code segment.

Explore storage classes in c++ and how auto, register, static, and extern define scope, lifetime, and memory location, including stack, data segment, and cross-file access.

Explore C++ storage classes with code examples, covering auto, register, static, and extern. See how auto infers types since C++11, how static preserves values, and how extern enables cross-file sharing.

Explore one-dimensional arrays in C++, including declaration and indexing. Understand contiguous memory, fixed size, and initialization options; contrast with vectors for dynamic resizing.

Explore one-dimensional arrays in C++ by declaring a fixed-size array, populating it with values, and iterating with traditional and range-based for loops.

Master how to declare, access, and iterate two-dimensional arrays in C++, using nested loops to print matrices. Learn passing two-dimensional arrays to functions, and explore initialization methods and multidimensional arrays.

Explore a two-dimensional C++ array with a 3x4 matrix initialized by uniform initialization, and learn row-wise and column-wise traversal plus Visual Studio debugging steps.

Explore strings in modern C++, from character arrays to string classes, and learn null terminators, c-string functions like strCopy and strCat, cin.getLine, cin.ignore, and string streams.

Explore strings in C++ using character arrays and the C string library, including strcat, strlen, strcmp, and strchr; see hello world after concatenation, length 11, index 6.

Discover modern string handling in C++ with the std::string class, dynamic memory management, operator overloading, and flexible syntax. Learn size, empty, at, front, back, push back, and c_str.

Demonstrate declaring, initializing, and manipulating strings in C++ with methods like size, empty, clear, at, front, back, push_back, pop_back, and c_str to reveal string behavior and outputs.

Master raw string literals in C++, simplifying escape sequences and multiline strings for readable, maintainable code, with custom delimiters and embedded JSON or code exactly as written.

Learn how raw string literals in C++ simplify writing strings with line breaks, tabs, quotes, and backslashes, demonstrated through a code demo with custom delimiters and a JSON example.

Explore how to use the StringStream class from the SStream header to parse, format, and convert data within strings, and to simulate input-output operations for testing in C++.

Explore string streams in modern C++, treating strings as streams with insertion and extraction, formatting, parsing, and converting data; learn tokenizing sentences and reusing streams with clear.