The Complete C++ Developer Course

Explore the fundamentals of c++ syntax, data storage and manipulation, arithmetic, decision making, and user input/output, including projects like a tip calculator and secret agent ID generator.

Create a simple hello world program in C++ using Visual Studio 2022, featuring a main function, include iostream, and print hello world with cout and endl.

Declare and initialize variables in c++ with data types like int and double, print values to the console with cout, and learn about assignment, initialization, and camel case naming.

Learn text data types by comparing char, a primitive single character, with string, a standard library class, and practice printing and concatenating with cout in a Visual Studio project.

Learn how the boolean data type in C++ stores true and false as one and zero. Use the bool alpha manipulator to print booleans as text and support program logic.

Document your C++ code with single-line and multiline comments that don’t affect execution, explaining variables like a 0.06 sales tax in a Visual Studio project.

Explore arithmetic operators in c++, including addition, subtraction, multiplication, division, modulus, and the impact of integer division and doubles, plus compound operators and compound assignment, increment and decrement.

Learn relational operators in C++ to compare values and produce boolean results, including greater than, less than, and equal to. These form the foundation of conditional logic.

Explore how logical operators in C++ combine boolean values using and, or, and not with truth tables. Apply these binary and unary operators in conditions and loops through boolean scenarios.

Distinguish literal constants from symbolic constants, declare read-only values with the const keyword, and apply camel case for variables and upper snake case for constants to improve readability and maintainability.

Learn to handle user input in C++ using the CN object and getline, echo input, and manage newline issues while building interactive programs that read full names, locations, and scores.

Build a tip calculator in C++ that reads bill amount and tip percentage, computes tip and total using double types, and prints results with clear formatting.

Build a secret agent id generator by using getline and cin to collect string and integer inputs, handle newlines, and format output as a stylized id card.

Review core C++ fundamentals, including console output with cout, variables and data types, comments, operators, symbolic constants, and input with cin, building a foundation for later decision-making.

Master control flow in c++, covering sequential, selection (if, switch), and repetition (while, for, do while) with break, continue, and pseudorandom number generation for games like rock paper scissors.

Explore the three core control statements in c++, including sequential, selection (if else), and repetition (loops), and see how their flow decisions shape program behavior with age-based examples.

Explore C++ selection control statements, including if, if else, and switch, with practical examples of multiway selection, break and fall through, and relational and logical operators.

Explore while, do while, and for loops as pre-test and post-test repetition, featuring counter-controlled and sentinel-controlled patterns with priming reads and running sums.

Use continue to skip odd numbers and break to exit the loop, printing even numbers from 0 to 9 with the modulus operator for parity.

Learn pseudo random number generation in C++ using the standard library. Seed with time, and use rand with modulus, scaling, and shifting to simulate die rolls in loops.

Develop a streaming subscription calculator app that computes a monthly total from packages A, B, or C based on included devices and overage charges, prompting for package and device count.

Develop a c++ leap year checker that prompts for a start and end year and iterates with a for loop to print whether each year is a leap year.

Create a rock, paper, scissors game in C++ where the user enters R, P, or S, the computer generates a random move, and logic prints the winner or a tie.

Wrap up this section by reviewing control structures: sequential, selection (if else, switch), and repetition (do, while, for). Explore break and continue, rand and time, and dice rolls.

Explore data structures: built-in c-style arrays, the array class, and the vector class. Learn to store and process collections with loops, and compare fixed versus dynamic containers for memory safety.

Explore built-in arrays in c++, including zero-based indexing, fixed-size, homogeneous data, and contiguous memory on the stack. Use traditional and range-based for loops, and leverage auto for type inference.

Master the STL array class, initialize and access fixed-size arrays with index operators, and use traditional and range-based for loops; this lecture contrasts with built-in arrays and previews vectors.

Explore the vector class in c++'s stl, enable dynamic resizing with push_back, use front, back, pop_back, and insert, and compare vectors to arrays for scalable data.

Explore multidimensional and 2D arrays in C++, learn how to access, modify, and print elements in a matrix using nested loops, and reverse traversal of a 2D array.

Create a seven-entry temperature converter using a double array to read Fahrenheit values, convert to Celsius with (F-32)*5/9, and display both scales with loops and the array class.

Develop a flexible shopping list using a vector of strings and a sentinel-controlled while loop. Collect multi-word items with getline until the user types done, then display the list.

Practice using parallel vectors to store movie titles and ratings, collect five entries, and print each rating with aligned indices. Learn getline and cin input handling and newline consumption.

Explore data structures in C++, from built-in arrays and the array class to vectors, including 2D arrays, bounds checking, and parallel containers, with practical loops and input examples.

Explore functions as reusable, named blocks that modularize code, then define your own functions with parameters, return values, scope and overloading, and recursion, plus a tic tac toe project.

Master function prototypes and definitions to build modular C++ programs, declaring functions before main and implementing them below, and calling them from main.

Master returning and non-returning functions, using parameters and arguments, with prototypes and main calls; classify functions by return type and parameter lists for modular, readable C++ code.

Explore parameter passing schemes, including pass by value and pass by reference, with examples that show copying versus referencing and how to modify the original variable.

Understand scope and lifetime in C++, distinguishing global, local, and static local variables, and see how accessibility and memory duration influence program behavior.

Learn function overloading in C++, using the same name with different parameter lists to select the right version, including int, string, and cube overloads.

Explore the cmath library's predefined math functions such as pow, sqrt, ceil, floor, and log2, and apply them in the Math Fun project.

Explore recursion in C++ by building a countdown, understanding base and recursive cases, and visualizing the call stack with activation records; compare with loops and apply to factorial.

Create a Visual Studio project named average of three and implement a function double average(double a, double b, double c). Call it from main and print the result.

Write a function count_evens that takes a built-in array and its size, uses the modulus operator to count evens, returns the total, and prints the result for an eight-element array.

Learn to compute the product of six integers using a std::array, a range-based for loop, and a function returning int; call from main and display 720 for test data.

Multiply all elements in a six-element int array and return the product through a by-reference parameter in a void function using the standard array class.

Build a modular tic tac toe game in C++ using 2D arrays passed to functions, a game loop, to detect a winner or a cats game.

Master function fundamentals—from syntax and prototypes to pass by value and by reference, overloading, and recursion—through practice projects with arrays and vectors, plus a capstone tic tac toe game.

Explore object-oriented programming in C++, focusing on encapsulation, inheritance, and polymorphism, with constructors, destructors, and UML design through hands-on projects.

Explore the theoretical foundations of object-oriented programming, contrasting procedural paradigms with OOP, and learn encapsulation, inheritance, and polymorphism through classes, objects, and access control with public and private.

Explore encapsulation in C++ by modeling houses as objects that bundle data and behavior, using public getters and setters and const correctness for safe, efficient access.

Learn separate compilation in modern c++, using header files for class declarations and cpp files for definitions, with include guards and the scope resolution operator.

Explore how constructors initialize objects and how destructors clean up as objects go out of scope, including default, no-arg, and parameterized constructors, with virtual and final options for safe inheritance.

Learn to design a rectangle class by applying encapsulation, UML diagrams, and separate compilation with header and source files, including constructors, getters, setters, and an area method.

Create an immutable book class in C++ with a parameterized constructor and getters, no mutators, then refactor to print details as a member function and test with instances.

Implement a library card class with holder name and books checked out initialized to zero; enforce validation and non-negative counts, and provide const getters, plus checkout and return operations.

Create an ice cream sundae class with a flavor set at construction, a toppings vector, and add, get, and print methods to demonstrate encapsulation and const correctness.

Create a triangle class with no-arg and parameterized constructors, implement getters and setters, and provide a bool is valid method using triangle inequality. Compute perimeter and area with Heron's formula.

Advance through object oriented programming fundamentals, encapsulation, inheritance, and polymorphism, using getters, setters, constructors, and destructors, with UML diagrams and hands-on projects like rectangle, book, library card, and triangle.

Explore C++ exception handling and debugging, including try catch blocks, exception hierarchy, and custom exceptions; implement month name and fuel monitor projects to practice robust, graceful error handling.

Explore the C++ exception hierarchy and inheritance, learn to throw and catch exceptions, and see a practical example with out of range and runtime error to demonstrate graceful error handling.

Explore logic errors in C++, focusing on length error as a derived logic error, and learn to catch them with try-catch, use what(), and distinguish see error from see out.

Explore runtime errors and exception handling in C++, learn defensive programming by throwing and catching runtime exceptions, and practice with class examples.

Learn how rethrowing catches, responds to, and propagates exceptions across main and helper functions. See how to handle multiple exception types, preserve data with throw, and centralize user feedback.

Define a custom exception class derived from runtime error, with a no-argument and a string message constructor to throw and catch descriptive kitty errors.

Master testing for compile-time, runtime, and logic bugs, and debug with breakpoints, watch lists, and stepping, while using try and catch blocks.

Map 1 to 12 to January through December with getMonthName; throw out of range exception for invalid input. Catch in main with a try-catch and print a friendly error message.

Create and use a custom exception fuel level critical derived from runtime error to signal fuel below 10%, with throwing and catching in a fuel monitor project.

Refreshes concepts on exceptions and debugging in C++, detailing std::exception hierarchy, try-catch blocks, constructors and the what method, and custom exceptions, with practical projects and debugging practice.

Explore raw pointers in C++, learn memory addresses, address-of and dereference operators, and dynamic memory with new and delete, plus a first look at smart pointers like unique_ptr and shared_ptr.

Explore pointers in C++, declare pointers with an asterisk, reference memory addresses, and dereference to access and modify values, while noting raw pointers, hex addresses, and shift toward dynamic memory.

Learn how dynamic memory uses the heap with new, how delete frees it, and how to avoid leaks and dangling pointers by using nullptr.

Allocate dynamic objects and arrays with new and delete, using a dog class and dynamic int arrays to explore pointers, arrow versus dot notation, and heap memory management.

Explore const correctness with pointers in C++, examining const pointer, pointer to const data, const int, and variations, and how these affect safety and readability.

Learns to manage dynamic memory by building a museum exhibit tracker with a class and a static array of pointers to dynamically allocated exhibits, plus delete-based cleanup.

Create a drone fleet simulator that dynamically allocates an array of drone pointers and each drone object, uses double pointers, prints fleet data, and cleans up all allocations.

Master memory management in c++ by using pointers, the address-of operator, dereferencing, and heap allocation with new and delete across projects like exhibit tracker and drone fleet.

Learn to write and read files with file i/o, format output using set w, set precision, and fixed, and safely handle file errors.

Learn sequential file output in C++, writing text with ofstream and stream manipulators like set width, precision, fixed, and showpoint, while handling errors and designing functions.

Learn to read numbers from a file with ifstream and the file stream extraction operator in a while loop, store them in a vector with push_back, print them, and sum.

Combine data from two input files, names.txt and ages.txt, to produce name-age pairs in output.txt, and illustrate a bonus program that doubles numbers from Input.txt to output.txt.

Learn to read salaries from a file with ifstream, validate data and skip invalid entries, and compute total employees, total payroll, average salary, and high earners over 100k, printing report.

Revisit object oriented skills and file handling by reading students.txt, dynamically creating student objects stored in a vector of pointers, printing a report with average gpa and honor roll.

Count movie genre votes from genres.txt using a map, compute percentages of total votes, and present an aligned table for this final C++ course project.

Review file input and output with ifstream and ofstream, format output with setw, setprecision, fixed, and showpoint, and use maps to build reports while preparing for inheritance and polymorphism.

Master inheritance and polymorphism in C++, exploring base and derived classes, access specifiers, and enum class, then apply through safe casting and an RPG character creation project.

Explore inheritance in c++, defining a base animal class and derived classes, using public, protected, and private access, and test make noise in a main function.

Extend the animal class with a dog subclass using public inheritance, adding breed and dig hole, providing a constructor for name, weight, and breed, and overriding makenoise to woof.

Explore polymorphism in C++, using virtual and override, and learn how base class pointers call derived methods at runtime with dynamic binding and abstract classes.

Learn how enumerated types define a set of named constants in C++ and enhance code safety and readability. Compare regular enums to enum classes using a direction example.

Extend the animal base class with a derived cat, override makenoise and eat, and demonstrate downcasting via dynamic cast using a polymorphic animal pointer.

Learn to build an RPG character creator in C++, using inheritance and polymorphism with an abstract player base class and derived warrior, priest, and mage, plus a race enum class.

Advance through inheritance and polymorphism in c++, using base and derived classes, virtual and pure virtual functions, and enum class types to build a cat and an RPG character creator.