Writing High-Performance C++ Code

By the end of this lesson you'll be able to make C++ run several times faster the right way: measure first, lay your data out so the CPU cache loves it, stop copying things you don't need to, and turn on the compiler optimisations that do the heavy lifting for you.

1. Measure First — Never Guess

The golden rule of optimisation is measure, don't guess. Programmers are notoriously bad at predicting where time goes — most of a program's runtime hides in a tiny slice of the code, and the rest is irrelevant. So before you change anything, put a clock around the work and get a real number. A std::chrono timer is all you need to compare two versions of the same task.

#include <iostream>
#include <vector>
#include <chrono>
using namespace std;

int main() {
    // RULE #1 of performance: MEASURE, do not guess.
    // A tiny timer lets you compare two versions of the SAME work.
    const int N = 1000000;
    vector<int> data(N, 1);   // a million 1s

    // Record the clock, do the work, record it again.
    auto start = chrono::high_resolution_clock::now();

    long long sum = 0;
    for (int i = 0; i < N; i++) sum += data[i];  // the work we time

    auto 
...

Once you can measure, you can optimise honestly: change one thing, re-run, and keep the change only if the number actually drops. Everything below follows the same pattern — a slow "before" and a fast "after", with a timer proving the difference.

2. Cache Locality — Keep Data Contiguous

The CPU never fetches one byte at a time. It pulls a cache line — usually 64 bytes — into a small, blazing-fast cache. A std::vector stores its elements in one contiguous block, so walking it reads sequential bytes the CPU can prefetch; this is called data-oriented design — laying memory out for how you'll read it. A node-based container like std::list scatters each element somewhere different, so every step risks a cache miss — a trip to RAM that's about 100× slower. The lesson: prefer contiguous containers unless you genuinely need constant-time insertion in the middle.

#include <iostream>
#include <vector>
#include <list>
#include <chrono>
using namespace std;

// Time a block of work and print how long it took, in microseconds.
template <typename Func>
long long timeIt(Func work) {
    auto start = chrono::high_resolution_clock::now();
    work();
    auto end = chrono::high_resolution_clock::now();
    return chrono::duration_cast<chrono::microseconds>(end - start).count();
}

int main() {
    const int N = 1000000;

    // vector = ONE contiguous block -> t
...

3. Avoid Unnecessary Copies

A huge amount of accidental slowness comes from copying data you only meant to read. Passing a big std::vector or std::string by value duplicates the whole thing on every call. The fix is to pass large, read-only arguments by const reference (const T&) — the function gets a read-only alias to the original and copies nothing. Pass small types (int, double, a pointer) by value; pass big ones you won't modify by const&. This is the single highest-value habit in everyday C++ performance.

#include <iostream>
#include <vector>
#include <string>
#include <chrono>
using namespace std;

template <typename Func>
long long timeIt(Func work) {
    auto s = chrono::high_resolution_clock::now();
    work();
    auto e = chrono::high_resolution_clock::now();
    return chrono::duration_cast<chrono::microseconds>(e - s).count();
}

// ❌ BEFORE: takes the vector BY VALUE -> copies all N strings on EVERY call.
long long countLongBefore(vector<string> words) {  // <-- copy!
    long long n = 0
...

Your turn. The function below copies the whole vector — and every string inside it — on every call. Change the parameter to a const reference and the loop item to a const string& so nothing is copied. Fill in the two blanks marked ___:

#include <iostream>
#include <vector>
#include <string>
using namespace std;

// 🎯 YOUR TURN — this function copies the whole vector on every call.
//    Make it take the data BY CONST REFERENCE so nothing is copied.

// 1) Change the parameter type from a copy to a const reference
long long totalLength(___ names) {   // 👉 const vector<string>& names
    long long total = 0;

    // 2) Loop WITHOUT copying each string: use a const reference item
    for (___ name : names)           // 👉 const
...

4. reserve() — Stop Reallocating

When you push_back into a growing std::vector, it occasionally runs out of room, allocates a bigger block, and copies every element it already holds into the new block. Do that as the vector grows from 1 to a million and you've copied a lot of data many times over. If you know roughly how many items you'll add, call vec.reserve(n) once up front: the vector grabs the whole block immediately and never re-copies. It's one line and it's basically free speed.

#include <iostream>
#include <vector>
#include <chrono>
using namespace std;

template <typename Func>
long long timeIt(Func work) {
    auto s = chrono::high_resolution_clock::now();
    work();
    auto e = chrono::high_resolution_clock::now();
    return chrono::duration_cast<chrono::microseconds>(e - s).count();
}

int main() {
    const int N = 2000000;

    // ❌ No reserve: the vector grows, reallocates, and COPIES every
    //    element it already holds, again and again as it expands.
  
...

Now you try. The loop below knows it will add N items, so it should reserve that space first. Fill in the blank with the right call:

#include <iostream>
#include <vector>
using namespace std;

int main() {
    const int N = 1000;
    vector<int> squares;

    // 🎯 YOUR TURN — you already KNOW you will add N items.
    // 1) Reserve room for all of them up front (one allocation, no re-copies)
    squares.___;                 // 👉 reserve(N)

    // 2) Fill the vector — this part already works
    for (int i = 1; i <= N; i++)
        squares.push_back(i * i);

    cout << "Count: " << squares.size() << endl;       // Count: 1
...

5. Inlining, Move & Compiler Flags

Some speed isn't yours to win by hand — it belongs to the compiler. Inlining pastes a small function's body straight into the caller, removing the call overhead; at -O2 the compiler does this for hot functions automatically, so you rarely write inline for speed. Move semantics (std::move) hand ownership of a big buffer across instead of copying it. And the biggest lever of all is the optimisation flag: compile a release build with -O2 and the same source can run several times faster than an unoptimised -O0 build.

#include <iostream>
#include <vector>
#include <string>
using namespace std;

// A tiny "hot" function. At -O2 the compiler INLINES it for you:
// it pastes the body into the caller, removing the call overhead.
// (You almost never need to write 'inline' yourself for speed.)
inline int square(int x) { return x * x; }

vector<int> makeData(int n) {
    vector<int> v;
    v.reserve(n);
    for (int i = 0; i < n; i++) v.push_back(square(i));
    return v;   // returned by MOVE (no copy) thanks to t
...

6. Branch Prediction (Briefly)

Modern CPUs guess which way an if will go before they know the answer, so they can keep working. Guess right (predictable data) and the branch is nearly free; guess wrong (random data) and the CPU throws away ~15–20 cycles of work. You usually don't micro-manage this, but two practical takeaways hold: processing sorted data makes branches predictable, and a branchless expression like sum += (x >= 128) * x; avoids the penalty entirely in a hot loop. As always — measure before reaching for either.

// AoS — good when you touch ALL fields of one object
struct Particle { float x, y, z, mass; };
vector<Particle> aos(N);

// SoA — good when you touch ONE field across all objects
struct Particles { vector<float> x, y, z, mass; };
Particles soa;  // looping over soa.x is pure sequential access

#include <iostream>
#include <vector>
#include <string>
#include <chrono>
using namespace std;

int main() {
    // 🎯 MINI-CHALLENGE: optimise a word counter and prove it is faster
    //
    // 1. Make a vector<string> with ~100000 copies of some word.
    // 2. Write a function that counts words longer than 4 letters,
    //    taking the vector BY CONST REFERENCE (const vector<string>&)
    //    and looping with a const string& item (no per-item copies).
    // 3. Time it with chrono::high_
...