C++ has been around since the 1980s, and depending on who you ask, it should have been replaced by something newer a decade ago. And yet, it still runs game engines, operating systems, browsers, trading systems, and a huge amount of the software you rely on without ever seeing it. There's a reason it hasn't gone anywhere.

The short version

C++ is a compiled, statically typed language that gives you extremely fine control over how your program uses memory and hardware, at the cost of asking you to manage a lot more yourself compared to something like Python or JavaScript. It was built as an extension of the C language, adding object-oriented features on top, which is where the "++" in the name comes from — literally "C, incremented by one."

A tiny first program

#include <iostream>

int main() {
    std::cout << "Hello, World!" << std::endl;
    return 0;
}

Even this small example shows the flavour of C++: you've to explicitly include the input and output library, main() has to explicitly return an int, and printing text uses that slightly odd-looking << operator instead of a friendlier print() function. None of this is arbitrary, it's just a language built with a very different set of priorities than something like Python.

Why it's harder, and why people accept that trade

C++ makes you think about things many languages hide from you entirely: how memory is allocated, when it gets freed, and exactly what type every single value is. That's more upfront effort. In exchange, you get programs that run extremely fast and use memory extremely efficiently, which matters enormously for things like a game rendering sixty frames a second, or an operating system managing every other program on the machine.

Where C++ actually gets used today

• Game engines, including Unreal Engine, almost entirely built in C++.
• Operating system components and device drivers.
• High-frequency trading systems, where microseconds genuinely matter.
• Performance-critical parts of larger applications, even ones mostly written in other languages.

Should you learn it first?

Probably not as your very first language — Python or JavaScript will get you writing useful things faster with far less frustration early on. But if you already know the basics of programming and want to genuinely understand what is happening underneath the languages that hide memory management from you, C++ is one of the most rewarding, if occasionally humbling, languages to spend real time with.

In Python or JavaScript, you can create a variable and never mention its type. In C++, that's simply not allowed — every variable needs a declared type before you can use it, and the compiler checks this before your program ever runs.

Declaring a variable

int age = 25;
double price = 9.99;
char grade = 'A';
bool isActive = true;

Notice char uses single quotes for one character, while text made of several characters uses a completely different type, std::string, with double quotes:

#include <string>
std::string name = "Sam";

What "compiled" actually means here

Unlike Python, which reads and runs your code line by line, C++ code has to be compiled first — translated entirely into machine code before it can run at all. This step is exactly where type mistakes get caught. Try to assign text to an int variable, and the compiler will refuse to build your program at all, rather than letting it run and fail unexpectedly later, which is genuinely one of C++'s more helpful traits once you get used to it.

The common types you'll actually use

• int — whole numbers.
• double — decimal numbers, more precise than float, and the more common default choice.
• char — a single character.
• bool — true or false.
• std::string — text, once you've included the string header.

const: locking a value down

const double PI = 3.14159;

Marking a variable const tells both the compiler and anyone reading your code that this value is never meant to change after it's set. Try to reassign it, and the compiler stops you, which is a small habit that prevents a surprising number of real bugs.

A gotcha with integer division

int a = 7;
int b = 2;
std::cout << a / b;  // prints 3, not 3.5

Dividing two integers in C++ gives you an integer result, throwing away anything after the decimal point, even if you were hoping for a precise answer. To get 3.5 here, at least one of the values needs to actually be a double.

Why all this rigidity is worth it

It feels like more upfront work compared to a language that just figures types out for you. But that rigidity is exactly what lets the compiler catch a whole category of mistakes before your program ever runs, and it's a big part of why well-written C++ programs can be both extremely fast and, once compiled successfully, surprisingly reliable.

If you've heard one thing about C++ before ever writing a line of it, it's probably that pointers are hard. They have a reputation, and honestly, it's a little deserved — but the core idea is simpler than the reputation suggests.

What a pointer actually is

Every variable lives somewhere in your computer's memory, at a specific address. A pointer is just a variable that stores one of those addresses, rather than storing an actual value like 25 or "hello" directly.

int age = 25;
int* agePointer = &age;

std::cout << age;          // 25
std::cout << agePointer;   // some memory address, like 0x7ffee...
std::cout << *agePointer;  // 25 — dereferencing gets the actual value back

The & symbol means "give me the address of," and the * symbol, when placed in front of a pointer variable, means "give me the value stored at this address," which is called dereferencing. Yes, * is doing two different jobs depending on context, once when declaring the pointer type, and once when dereferencing it — this is exactly the kind of small detail that makes pointers feel harder than they really are at first.

Why would you ever want this?

Pointers let you refer to the same piece of data from more than one place without copying it, which matters a lot once data gets large or needs to be shared between different parts of a program. They are also how C++ manages memory you allocate yourself, which the tutorial on the stack and the heap covers in more depth.

References: a friendlier alternative

int age = 25;
int& ageRef = age;
ageRef = 26;
std::cout << age;  // 26 — changing ageRef changed age itself

A reference is essentially an alias, another name for an existing variable, rather than a separate pointer variable you've to dereference manually. References are generally easier to use safely than raw pointers, and in modern C++, they are the default choice for a lot of situations where older code would have reached for a pointer.

Passing by reference into a function

void addOne(int& number) {
    number = number + 1;
}

int value = 5;
addOne(value);
std::cout << value;  // 6

Without the &, the function would receive a copy of value, change the copy, and the original would stay exactly as it was. With it, the function is working with the real variable directly.

Don't try to memorise this in one sitting

Pointers and references are genuinely one of those topics that clicks slowly, with practice, rather than all at once from reading. Write a few small programs that pass values around both ways and print the results at each step. Watching what actually happens, rather than just reading about it, is what makes this stick.

Writing a function in C++ looks familiar if you've seen functions anywhere else, but there's one decision baked into every single parameter you write: does this function get its own copy of the data, or does it get direct access to the original?

A basic function

int add(int a, int b) {
    return a + b;
}

int total = add(2, 3);

Every function in C++ needs a declared return type, just like variables need a declared type. Use void when a function doesn't return anything at all.

Pass by value: the default, and a copy

void doubleIt(int number) {
    number = number * 2;
}

int x = 5;
doubleIt(x);
std::cout << x;  // still 5!

By default, C++ passes a copy of the argument into the function. Whatever happens to that copy inside the function stays inside the function; the original variable back where it was called from is completely untouched. This surprises a lot of people coming from languages where everything behaves more like a reference automatically.

Pass by reference: working with the original

void doubleIt(int& number) {
    number = number * 2;
}

int x = 5;
doubleIt(x);
std::cout << x;  // 10

Adding that single & to the parameter changes everything: now the function is operating on the real variable, not a copy, so changes made inside it are visible after the function returns.

const reference: the best of both, for bigger data

void printName(const std::string& name) {
    std::cout << name;
}

For something small like an int, copying is cheap and rarely worth worrying about. For something bigger, like a long string or a large collection of data, copying it every single time a function is called wastes real time and memory. Passing it by reference avoids the copy, and adding const on top promises the function won't accidentally change the original, giving you speed and safety at the same time. This exact pattern, const reference, shows up constantly in real C++ code once you start reading it.

Default parameters

void greet(std::string name = "friend") {
    std::cout << "Hello, " << name;
}

A rule of thumb worth keeping

Pass small, simple types like int, double and bool by value, since copying them costs almost nothing. Pass anything bigger, like strings, vectors or your own custom objects, by const reference unless you specifically need the function to modify the original.

If you've already looked at classes in Java or Python, C++ classes will feel familiar in spirit, though the syntax carries its own particular flavour, with a couple of ideas that are genuinely specific to C++.

A basic class

class Dog {
public:
    std::string name;
    int age;

    void bark() {
        std::cout << name << " says woof!" << std::endl;
    }
};

Dog myDog;
myDog.name = "Rex";
myDog.age = 3;
myDog.bark();

public and private

The public: label controls which members outside the class are allowed to access. Anything under private, the default if you write nothing at all, can only be used from inside the class itself. Making fields private and only exposing them through methods, the same encapsulation idea found in most object-oriented languages, is generally considered good practice here too, even though the example above kept things public to stay simple.

Constructors

class Dog {
public:
    std::string name;
    int age;

    Dog(std::string dogName, int dogAge) {
        name = dogName;
        age = dogAge;
    }

    void bark() {
        std::cout << name << " says woof!" << std::endl;
    }
};

Dog myDog("Rex", 3);

A constructor shares the class name and runs automatically when an object is created, letting you set up its starting values in one step rather than assigning each field one at a time afterward.

The destructor: something Java and Python don't really have

class Dog {
public:
    ~Dog() {
        std::cout << "A Dog object is being destroyed" << std::endl;
    }
};

A destructor, marked with a tilde before the class name, runs automatically when an object is about to be destroyed, whether that's because it went out of scope or was explicitly deleted. This is a genuinely C++-specific idea, tied closely to how C++ manages memory manually rather than relying on automatic garbage collection the way Java and Python do — the tutorial on the stack and the heap goes deeper into exactly that.

Inheritance

class Puppy : public Dog {
public:
    void bark() {
        std::cout << name << " yips!" << std::endl;
    }
};

The colon followed by public Dog means Puppy inherits everything from Dog, and here it overrides bark with its own version, replacing the parent's behaviour rather than reusing it.

A small honest note

C++ classes have more moving parts than most languages ask of you upfront: constructors, destructors, access levels, and eventually things like copy constructors that this tutorial hasn't even touched yet. Don't feel like you need all of it on day one. Start with the basics shown here, write a few small classes, and let the rest come as you actually need it.

C++ gives you two very different ways to store a list of items: the plain, old-fashioned array inherited from C, and std::vector, a much friendlier tool from the Standard Template Library. Almost all real, modern C++ code reaches for vectors, and once you see why, you'll understand.

The plain array: fixed, and a little unforgiving

int scores[5] = {90, 85, 70, 60, 100};
std::cout << scores[0];  // 90

A plain array has a size fixed at the moment it's created, and it won't stop you from reading or writing past its end — scores[10] on a five-item array won't throw a clean error, it will just quietly read whatever happens to be sitting in memory at that spot, which is exactly the kind of bug that has caused real, serious security problems in C++ software over the decades.

std::vector: the safer, more flexible option

#include <vector>

std::vector<int> scores = {90, 85, 70, 60};
scores.push_back(100);          // grow it
std::cout << scores[0];         // 90
std::cout << scores.size();     // 5

A vector can grow and shrink, just like a Python list or a Java ArrayList, and it keeps track of its own size for you, so you never have to pass a separate length variable alongside it the way you sometimes do with plain arrays.

Looping through a vector

for (int score : scores) {
    std::cout << score << " ";
}

This range-based for loop, added to C++ relatively recently in the language's long history, reads almost identically to a for-each loop in Java or Python, and it's genuinely the nicest way to loop over a vector when you don't need the index itself.

What the STL actually is

vector is just one small piece of the Standard Template Library, a huge collection of ready-made data structures and algorithms that ship with C++. Rather than writing your own sorting function, for example, the STL hands you one already:

#include <algorithm>

std::sort(scores.begin(), scores.end());

Why vectors won over plain arrays

• They resize automatically as items are added or removed.
• They know their own size, so you aren't tracking a separate length variable by hand.
• They work seamlessly with the rest of the STL's algorithms, like sort, find and count.

Plain arrays haven't disappeared entirely — they still show up, especially in older code or in situations where performance needs to be squeezed as tightly as possible — but for everyday C++ written today, reaching for a vector first is the sensible default, and plain arrays become the exception rather than the rule.

This is the tutorial that separates C++ from most of the languages people learn before it. In Java, Python and JavaScript, memory just sort of takes care of itself in the background. In C++, you're handed the keys, and with them, the responsibility.

The stack: fast, automatic, and temporary

void doSomething() {
    int x = 5;
    std::string name = "Sam";
} // x and name are automatically destroyed right here

Any variable declared normally, without anything special, lives on the stack. The moment the function it belongs to finishes, that memory is automatically cleaned up. You never have to think about freeing it yourself — this is the easy, safe default, and honestly it's what you should reach for whenever it fits your needs.

The heap: manual, flexible, and your responsibility

int* number = new int(5);
std::cout << *number;  // 5
delete number;           // you MUST do this yourself

new allocates memory on the heap, a separate region that survives beyond the function that created it, and hands you back a pointer to it. Unlike the stack, nothing cleans this up automatically. If you forget to call delete, that memory stays reserved for as long as your program keeps running, even though nothing can reach it anymore. This is a memory leak, and in a long-running program, a steady trickle of these can eventually eat up all the memory on a machine.

Why would you ever use the heap, then?

The stack is limited in size and everything on it disappears the moment its function returns. Sometimes you genuinely need data to outlive the function that created it, or you need an amount of memory that's only known while the program is actually running, not something you can hardcode ahead of time. That's exactly what the heap, accessed through new, is for.

The rule that saves you from most of the pain

Every single new needs exactly one matching delete. Not zero, and not two — exactly one. Calling delete twice on the same pointer, or using a pointer after it has already been deleted, causes undefined behaviour, which is a polite way of saying "anything could happen, including your program crashing in a way that's very hard to trace back."

Modern C++ has a much better answer

#include <memory>

std::unique_ptr<int> number = std::make_unique<int>(5);
// no delete needed — it cleans itself up automatically

Smart pointers like unique_ptr wrap up a heap allocation and automatically delete it the moment nothing is using it anymore, giving you the flexibility of the heap without manually tracking every delete yourself. Modern C++ code leans on these heavily, and honestly, if you're writing new C++ today, reaching for a smart pointer instead of a raw new is usually the right instinct.

Imagine writing the exact same function twice, once for int and once for double, purely because C++ makes you declare types upfront. Templates exist specifically so you don't have to do that.

The problem, without templates

int maxInt(int a, int b) {
    return (a > b) ? a : b;
}

double maxDouble(double a, double b) {
    return (a > b) ? a : b;
}

These two functions are identical except for one word. Multiply this by every type you might ever want to compare, and you end up copying the same logic over and over, which is exactly the kind of repetition that should set off alarm bells.

The same thing, with a template

template <typename T>
T findMax(T a, T b) {
    return (a > b) ? a : b;
}

std::cout << findMax(3, 7);        // 7
std::cout << findMax(3.5, 2.1);    // 3.5

T here isn't a real type — it's a placeholder, filled in automatically by the compiler based on whatever you actually pass in. Call findMax with two ints, and the compiler generates an int version behind the scenes. Call it with two doubles, and it generates a double version instead, all from this one piece of code you wrote once.

Templates on classes, too

template <typename T>
class Box {
public:
    T value;
    Box(T v) { value = v; }
};

Box<int> intBox(5);
Box<std::string> stringBox("hello");

This might already look familiar — std::vector<int> and std::vector<std::string>, which you've already seen in the vectors tutorial, are themselves built using exactly this template mechanism. vector isn't magic; it's a template class from the standard library, the same idea shown here, just written by people who thought about it very carefully.

A word of honesty

Templates can get genuinely complicated fast once you start combining several of them together, and template error messages have a well-earned reputation for being some of the least friendly in all of programming — a single mistake can produce a wall of text that seems to haven'thing to do with the actual problem. None of that should stop you from using basic templates like the ones shown here; it's just worth knowing that the deep end exists, so you aren't caught off guard later.

Why bother learning this at all

Templates are exactly how C++'s standard library manages to give you containers like vector, and algorithms like sort, that work with practically any type you throw at them. Understanding roughly how templates work demystifies a lot of what is actually happening every time you use std::vector or std::sort, rather than treating them as unexplainable built-in magic.