C++ Essentials

Write notes in your code, print special characters, and learn to read your first compiler errors.

Give your program a memory: named boxes that store values you can read and change.

Add, subtract, multiply, divide — plus integer division, the remainder operator, and shortcuts like += and ++.

int, double, char, bool — choosing the right kind of box for each piece of data.

Store words and sentences with std::string — joining, measuring, and peeking at characters.

Make programs interactive: read numbers and words from the keyboard with cin, and whole lines with getline.

Lock values with const and constexpr, and let the compiler deduce types with auto.

What happens when int meets double: safe conversions, silent truncation, static_cast, and integer limits.

The six comparison operators, the bool answers they produce, and the == vs = trap.

Run code only when a condition is true — and chain alternatives with else if and else.

Combine conditions with AND, OR, and NOT — and dodge the 'between two values' trap.

A compact if/else for choosing between two values: condition ? a : b.

Cleaner branching on fixed values with switch/case — and the fall-through rule.

Repeat code while a condition holds — and learn why loops must move toward their exit.

The counted loop: initializer, condition, and update in one tidy header.

The run-first, ask-later loop — perfect for input validation.

Exit a loop early with break, or skip one iteration with continue.

Loops inside loops: grids, tables, and patterns — and how the iteration counts multiply.

Loop over every character of a string — no counters, no indexes, no off-by-one errors.

Name a block of code once, run it anywhere — defining and calling your first functions.

Pass information into functions — parameters, arguments, and why order matters.

Functions that compute and hand back answers — return types, early returns, and composing results.

Where variables live and die — and why functions receive copies of your arguments.

One name, several versions — and parameters that fill themselves in.

Declarations vs definitions, and decomposing a real program into small, single-job functions.

Fixed-size collections: declaring arrays, zero-based indexing, and the out-of-bounds danger.

The growable array: push_back, size, safe access with .at(), and range-based loops.

The four algorithms you'll write a thousand times — plus sort() from the standard library.

The string toolbox: substr, find, npos, and in-place modification.

Combine loops, chars, and string-building: counting, transforming, and reversing text.

Consolidate the module: vectors of strings, combined patterns, and a gradebook walkthrough.

The mental model behind everything: memory as numbered boxes, and the address-of operator &.

A second name for the same variable — and the key to functions that modify their arguments.

A variable that holds an address: declaring pointers, dereferencing with *, and re-aiming them.

The three pointer accidents — null, uninitialized, and dangling — and the habits that prevent them.

Two kinds of memory, manual allocation with new, cleanup with delete — and the memory leak.

Modern C++ memory management: unique_ptr deletes for you — leaks become impossible by design.

Bundle related values into one type of your own — members, dot access, and structs in vectors.

Data plus behavior: member functions, the class keyword, and your first objects.

Protect your data with private members and a public interface that enforces the rules.

Guarantee every object is born valid — constructor syntax, member initializer lists, and defaults.

The goodbye method: automatic cleanup at scope end, and the pattern that powers all of modern C++.

Assemble the whole module into one well-designed class — and learn the design checklist.

Build new classes on top of existing ones — base and derived classes, and the is-a test.

Let derived classes replace base behavior — and why virtual is the keyword that makes it real.

One interface, many behaviors: heterogeneous collections and code that never needs to know the concrete type.

Base classes as pure contracts: = 0 methods, uninstantiable bases, and interface design.

Write a function once, use it for every type — template<typename T> and type deduction.

Types parameterized by types — build your own Box<T>, and finally read vector<int> fluently.

Key-value lookup and uniqueness — the two containers that replace a hundred search loops.

Replace hand-written loops with named, tested tools: find, count, max_element, and friends.

The whole course on one page, the modern-C++ decision tables, and your roadmap onward.