
Already know some of this? A 2-minute test skips the lessons you know.
Take the placement testA free 50-lesson course built from Bro Code's 6h 00m of YouTube video. 4 days at 90 minutes a day, with study notes and a quiz in every lesson. A 2-minute placement test skips what you already know.
Taught by Bro Code on YouTube. Videos play in YouTube's own player, so the creator keeps every view.
Learner will understand why C++ is used, install VS Code with C++ extensions, and install a compiler (GCC/Clang/MSYS2) for their OS.
Learner will write a basic C++ program using iostream, main function, std::cout, std::endl, newline characters, and single/multi-line comments.
Learner will declare and initialize variables of type int, double, char, bool, and std::string, and combine text with variables in output.
Learner will create namespaces to avoid naming conflicts, access members via the scope resolution operator (::), and understand why 'using namespace std' is discouraged.
Learner will create type aliases with typedef and the modern using keyword to improve readability and reduce typos for complex types.
Learner will apply +, -, *, /, %, ++, --, and compound assignment operators, and evaluate expressions using correct operator precedence.
Learner will perform implicit and explicit type conversions (casts) between numeric types and char, and use casting to compute a percentage score.
Learner will accept user input with std::cin and std::getline, handle the newline buffer issue using std::ws, and choose the appropriate input method.
Learner will use std::max, std::min, std::pow, std::sqrt, std::abs, std::round, std::ceil, and std::floor from the <cmath> header.
Learner will write conditional logic using if, else if, and else, compare values with relational operators, and control program flow based on conditions.
Learner will implement a switch statement to handle multiple discrete cases and build a simple four-function calculator with a default error case.
Learner will replace simple if-else statements with the ternary operator (condition ? exprTrue : exprFalse) for concise conditional expressions.
Learner will combine conditions with &&, ||, and ! to evaluate complex boolean logic, such as checking temperature ranges or sunny/cloudy states.
Learner will build a program that converts between Celsius and Fahrenheit using if/else, char input validation, and arithmetic formulas.
Learner will manipulate std::string objects using common member functions to inspect, modify, and search string content.
Learner will write while loops that repeat until a condition becomes false, and use them to force valid user input (non-empty name).
Learner will use do-while loops to execute a block at least once before checking the condition, ideal for menus or repeated prompts.
Learner will write standard for loops with initialization, condition, and increment, and apply operator precedence rules in arithmetic expressions.
Learner will use break to exit a loop early and continue to skip the current iteration, demonstrated with a number guessing game.
Learner will write nested for loops to iterate over rows and columns, printing a rectangular grid of symbols based on user input.
Learner will seed the RNG with srand(time(nullptr)), generate numbers with rand() % range, and build a 'guess the number' game using a do-while loop.
Learner will create reusable functions with parameters, pass arguments by value, declare functions before main, and understand function scope.
Learner will write functions that return values (double, std::string), match return types in declarations, and use the return keyword to send data back to the caller.
Learner will overload functions by varying parameter lists, create a pizza class with multiple topping constructors, and understand function signatures.
Learner will distinguish local vs global variables, explain shadowing, and use the scope resolution operator (::) to access a global variable from a local scope.
Learner will integrate switch, functions, and a do-while loop to build a menu-driven banking program with deposit, withdraw, and balance inquiry.
Learner will implement a complete Rock-Paper-Scissors game using functions, random computer moves, switch logic, and win/tie detection.
Learner will declare fixed-size arrays, initialize with brace-enclosed lists, compute element count with sizeof, and iterate with index-based for loops.
Learner will use the range-based for loop (for (auto& e : arr)) to traverse arrays cleanly when index manipulation is not needed.
Learner will pass arrays to functions, understand pointer decay, and pass the array size as a separate parameter to enable iteration inside the function.
Learner will implement linear search, use sizeof to get array byte size and element count, and declare/iterate 2D arrays with nested loops.
Learner will build a multiple-choice quiz game using a 1D questions array, a 2D options array, an answer key, score tracking, and percentage calculation with double casting.
Learner will use the address-of operator (&) to print memory addresses, observe variable spacing in memory, and apply sizeof to variables and arrays.
Learner will explain why pass-by-value fails to swap original variables, and implement a successful swap using reference parameters (&) to modify the original memory locations.
Learner will apply const to reference and value parameters to enforce read-only intent, prevent accidental modification, and improve code security.
Learner will allocate single variables and arrays on the heap using new, release memory with delete to avoid leaks, and size allocations based on user input.
Learner will implement recursive functions with base cases, compare recursion to iterative loops, and recognize stack overflow risk from missing base cases.
Learner will write function templates using the template keyword, use typename (or class) for generic types, and understand how templates generate overloaded functions.
Learner will define structs to group related variables, instantiate struct objects, access members with the dot operator, and create arrays of structs.
Learner will pass structs to functions by reference to avoid copying, modify original members, and understand the performance benefit for larger structs.
Learner will define enum types to create named integer constants, use them in switch statements for readability, and prevent invalid values.
Learner will define a class with attributes and methods, instantiate objects, assign attributes, invoke methods, and use a constructor to initialize objects with arguments.
Learner will write multiple constructors with different parameter lists to allow flexible object creation (e.g., pizza with 0, 1, or 2 toppings).
Learner will hide attributes with private, provide public getter/setter methods, add validation logic in setters, and call setters from constructors.
Learner will create a base class (Animal, Shape) and derived classes (Dog, Cat, Cube, Sphere) that inherit attributes/methods, add their own, and override behavior.