C++ Full Course for free ⚡️

Video overview

A beginner-to-intermediate C++ tutorial by Bro (Bro Code) covering setup, language basics, data structures, OOP and a number of small projects and demos. The video demonstrates tools, common pitfalls, and practical examples you can run and modify.

Quick topics covered

• Setup / tools
• First program and I/O fundamentals
• Basic language elements (types, constants, namespaces)
• Operators and expressions
• Control flow (if/switch/loops)
• Input gotchas and handling
• Strings and common methods
• Math utilities (cmath)
• Arrays, searching, sorting, multi-dimensional arrays
• Pointers, dynamic memory, and memory safety
• Structs and enums
• Functions, templates, recursion
• Object-oriented programming (classes, inheritance, encapsulation)
• Many worked example programs (games, calculators, utilities)

Setup / tools

• Editors:
  • VS Code (demoed) — recommended extensions: Microsoft C/C++ and Code Runner.
  • Alternatives: Code::Blocks, Notepad.
  • VS Code tip: enable Code Runner “Run In Terminal” to allow cin input.

• Compilers and platform notes:

  • Linux: GCC (apt install gcc g++).
  • macOS: clang (xcode-select --install).
  • Windows: MinGW-w64 via MSYS2 — download installer, use pacman to install packages, add bin to PATH; test with: g++ --version

• References for installation and setup:

  • VS Code C++ docs: code.visualstudio.com
  • MSYS2 / MinGW-w64 installer pages

First program / I/O fundamentals

• Basic program structure:
  • #include <iostream>
  • int main() { ... return 0; }
• Output:
  • std::cout, << operator
  • newline: prefer '\n' for performance; std::endl also flushes the stream
• Comments: // and /* ... */
• String literals and semicolon-terminated statements

Basic language elements

• Variables and types: int, double, char (use single quotes), bool, std::string
• Constants: const keyword; naming convention for constants often ALL_CAPS
• Namespaces:
  • scope resolution ::
  • avoid using namespace std; in larger projects (prefer std:: or selective using)
• Type aliases: using preferred over typedef, especially with templates
• sizeof operator: returns byte size of a type or variable; common trick for array length: int len = sizeof(array) / sizeof(array[0]);

Operators & expressions

• Arithmetic and compound assignments: + - * /, +=, ++, --
• Modulus % (e.g., test even/odd)
• Precedence and parentheses
• Type conversion and casting:
  • implicit conversions vs explicit (int)x
  • watch integer division; cast to double to retain decimals
• Logical and comparison: &&, ||, !, == (vs = assignment)
• Ternary operator: condition ? expr1 : expr2

Control flow

• Conditionals: if / else if / else (order matters)
• switch / case / default — use break to prevent fall-through
• Loops:
  • while, do { } while (executes body at least once), for
  • Range-based for (for-each) for arrays/vectors
  • break and continue usage
  • Nested loops

Input details & gotchas

• std::cin >> var stops at whitespace; use std::getline to read full lines
• To handle leftover newline before getline, use std::ws or std::cin.ignore()
• Clearing bad input state:
  • std::cin.clear();
  • std::cin.ignore(...) (or fflush in some contexts) to discard invalid input

Strings & common methods

• std::string useful methods:
  • length(), empty(), clear(), append(), at(), insert(), find(), erase()
  • Indexing via operator[]
• Use std::getline to capture multi-word input

Math utilities

• <cmath> functions shown: std::max, std::min, pow, sqrt, abs, round, ceil, floor
• Example: hypotenuse = sqrt(pow(a, 2) + pow(b, 2))

Arrays and related algorithms

• Single-dimensional arrays:
  • declaration, 0-based indexing, static size vs initializer lists
  • iterate with classic for or range-based for
• Array length trick: sizeof(array) / sizeof(array[0]) (works only where array has static storage in scope)
• Passing arrays to functions: arrays decay to pointers — pass size separately
• Searching: linear search example
• Sorting: bubble sort implementation and simple optimization
• Utilities: std::fill to fill ranges
• Multi-dimensional arrays (2D grids) and nested loops for rows/columns

Pointers & memory

• Addresses &, pointer types T*, dereference *ptr
• Null pointer: nullptr and checking before dereference
• Dynamic allocation:
  • new / delete for single objects
  • new[] / delete[] for arrays
  • Use heap for runtime-sized arrays; be careful to delete to avoid leaks
• Avoid memory leaks; check for allocation failures where applicable

Data structures: structs & enums

• struct to group mixed-type members; access via dot operator
• Passing structs to functions by value or by reference
• enum for named integer constants; useful in switch statements

Functions & advanced topics

• Declarations, definitions, and prototypes
• Parameters vs arguments; return types and using return values
• Function overloading (same name, different parameters)
• Function templates (generics) and multiple template parameters
• auto for deduced return types (where appropriate)
• Passing: value vs reference (&) — use references to modify caller variables
• Use const parameters when a function should not modify input
• Recursion examples (factorial, walking steps) — pros and cons (clarity vs stack depth)

Object-oriented programming (OOP)

• Classes and objects: members (attributes) and methods
• Access control: public vs private — use getters/setters for encapsulation and validation
• Constructors (including overloaded constructors) and default members
• Example patterns: Car, Student classes with constructors, getters, setters
• Inheritance: class Child : public Parent to reuse attributes/methods (examples: animal → dog/cat; shape → cube/sphere)
• Avoid duplicating logic by placing shared behavior in parent classes

Practical projects / worked examples

A selection of the many demo programs included:

• Hello World and basic printing
• Variable demos
• Circumference calculator (using const)
• Hypotenuse calculator
• Basic calculator (switch-based)
• Temperature conversion (C ↔ F)
• User input handling (getline, std::ws)
• Random numbers (srand(time(NULL)), rand() % range + 1)
• Random-event generator / prize giveaway
• Rock-Paper-Scissors (user vs random computer choice)
• Number guessing game (random + do-while)
• Banking demo (show balance, deposit, withdraw, std::fixed + std::setprecision)
• Tic-tac-toe (board array, win/tie detection)
• Quiz game (questions array, options 2D array, scoring with casting)
• Credit card validator (Luhn algorithm implementation)
• Sorting and searching demos (bubble sort)
• Multi-dimensional array exercises
• Simple class examples and inheritance demos
• Recursion examples (walking steps, factorial)
• Memory/pointer demos and dynamic arrays for user input

Practical tips & best practices

• Prefer const for values that shouldn’t change
• Avoid global variables when possible
• Prefer using over typedef in modern code
• Avoid using namespace std; in global scope; prefer explicit std::
• For performance, prefer '\n' over std::endl unless flushing is required
• When passing arrays to functions, pass the size separately; consider std::vector for flexible sizing
• Seed random generator with current time; note rand() is pseudo-random
• Always validate and check user input
• Use std::fixed and std::setprecision to format currency and decimals

Main speaker / referenced resources

• Presenter: Bro (Bro Code)
• Web resources referenced:
  • VS Code C++ setup and downloads: code.visualstudio.com
  • C++ references (e.g., cmath): cplusplus.com
  • MSYS2 / MinGW-w64 installer pages (Windows toolchain)
  • ASCII/character code concepts (char ↔ int conversions)

Note: examples in the video are hands-on and combine many of these concepts into small projects to demonstrate practical usage.

Next steps / offers

• I can extract a short checklist to get started (editor + compiler + test command).
• Or produce a compact list of the sample programs (with suggested filenames) and what each demonstrates so you can run them step-by-step.