Master Pointers, Memory Management & Smart Pointers in C++20

Install Visual Studio Community 2022 on Windows, select desktop development with C++, optionally add Unreal Engine or Unity workloads, and ensure compilers are installed.

Set up an empty C++ project in Visual Studio, organize code with real folders, configure output and intermediate directories, and enable C++20 to build and run hello world.

Discover why C++ remains relevant, tracing its history from C with classes to modern C++20 and beyond, and learn about smart pointers, memory management, and compiler support (GCC, Clang).

Explore how C++ libraries provide ready-made code you can download and reuse, with standard library components like containers, algorithms, iterators, streams, and smart pointers, while updates keep your code current.

Understand that statements are the basic unit of a C++ program, end with a semicolon, execute sequentially from main, and can be grouped in statement blocks with nesting.

Write your first c++ program by including iostream, defining int main, using cout and cin to print and read, and returning zero, with proper semicolons and comments.

Explore names and keywords in C++20, distinguishing case-sensitive names from reserved keywords you cannot use as names, and learn naming rules and keyword restrictions for readable code.

Explore data types and variables in C++, from integers and floating points to strings and booleans, and learn how memory, size, and constants shape data handling.

Discover the full range of C++ operators, including unary, binary, and ternary forms. Apply assignment, arithmetic, relational, equality, logical, bitwise, increment and decrement, member access, conditional, pointer, size of, cost, and new and delete in dynamic memory contexts.

Explore arrays as fixed-size containers of the same data type stored contiguously, with zero-based indexing, and learn to determine their size using size and the size operator.

Learn how std vectors provide dynamic size at runtime, require the vector header, and support operations like pushback, resize, pop back, size, empty, clear, front, back, and swap.

Discover how functions in c++20 modularize code, enable reuse, and hide complexity through abstraction. Learn function syntax, parameters, return types, signatures, and overloading with examples from the standard library.

Learn how pointers store the address of variables, use the address-of operator for dynamic memory management, and access values indirectly in C++.

Discover how dereferencing a pointer with the asterisk operator accesses and modifies the value at a memory address, while pointers can switch targets without changing their own address.

Learn to create and use an array of pointers and a pointer to an array in C++20, including addresses, dereferencing, and pointer arithmetic.

Explore constant pointers and pointers to constants in C++20, detailing constness, address handling, and when the pointed value may be modified or not.

Explore pointer arithmetic in C++20 using addition, subtraction, increment, and decrement to navigate by elements rather than bytes, and understand size of data type, pointer differences, and array traversal.

Learn the basics of dynamic memory allocation in C++, using new and delete on the heap for dynamic arrays. Avoid leaks and dangling pointers by deleting and setting to nullptr.

Explore the hazards of dynamic memory allocation in c++20, including memory leaks, dangling pointers, and memory fragmentation in the heap, and learn safe use of new, delete, and delete array.

Explore hazards of dynamic memory allocation with real examples, including memory leaks, dangling pointers, and multiple deallocation. Emphasize safe deletion, null checks, and the move toward smart pointers.

Explore how smart pointers in c++11+ manage dynamic memory, prevent memory leaks and dangling pointers, and fix cyclic references with unique_ptr, shared_ptr, and weak_ptr.

Master unique pointers by declaring std::unique_ptr, using make_unique, and managing memory with reset, get, and release, while avoiding dereferencing null pointers.

Explore shared pointers in C++20, compare with unique pointers, explain use_count and make_shared, demonstrate how multiple pointers share memory, and introduce weak pointers to handle cyclic references.

discover how to create smart pointers for containers like arrays and vectors with shared_ptr and unique_ptr, including use_count, get, release, reset, and arrow vs dot access.

Explore references as aliases to existing objects, learn passing by reference to avoid copies, and use range-based for loops to modify containers without extra memory overhead.

Discover how references and memory management interplay in C++20, including initialization, aliasing, and address sharing, and learn passing by reference vs by value with practical examples and range-based loops.

Learn to pass variables by pointer or reference to functions in c++20, dereference and use arrows, explore returning pointers or references, and avoid returning local variables.

Explore how to pass pointers to functions in C++20 with practical Visual Studio Code examples, dereferencing, and using the address operator to modify variables and observe memory addresses.

Return a pointer from a function by returning the address of a variable, then modify the original value through the pointer. Never return pointers to local variables.

Explore passing by reference as a direct, easier alternative to pointers, showing how references alias variables, avoid dereferencing, and enable or restrict modification with const.

Return a reference from a function using a reference return type and by-reference parameters, but never return a reference to a local variable; use a global or dynamically allocated variable.

Explore function on the left side of an assignment, where a function returns a reference to the larger value, allowing you to assign through the reference and highlighting const parameters.

Explore input and output parameters in C++20, showing how passing by value, const reference, and non-const references or pointers enables or prevents modifying original data, with practical Visual Studio examples.

Pass arrays to functions by value, pointer, or reference using the array name as the address of the first element, with size, const qualifiers, and multi-dimensional array notes.

Explore function overloading with pointers, const pointers, and references, and see how overload resolution selects the correct function. Discover why constness affects binding and lvalue requirements in these overloads.

Learn to build an inventory system in C++ using vectors of unique pointers, with options to add, display, and sell products, manage IDs, and explore move semantics.

Demonstrates managing inventory with std::vector and std::unique_ptr in c++20, implementing add product, display inventory, and sell product using references and move semantics.