Expression Templates in C++: Eliminate Temporaries, Maximize Speed

High-performance numerical code in C++ has a dirty secret: the cleaner your math looks, the slower it can run. Write result = a + b + c + d with naively overloaded operators on a vector class and you've silently created three temporary vectors behind the scenes, each one a heap allocation and a full-array traversal. For a 10-million-element simulation running thousands of times per second, that's the difference between shipping and not shipping. This isn't a hypothetical — it's the exact wall that early scientific computing libraries like BLAS wrappers hit in the 1990s, and why entire frameworks were rewritten.

Expression Templates (ETs) solve this by moving the description of a computation into the type system itself. Instead of evaluating a + b eagerly and returning a temporary vector, an overloaded operator+ returns a lightweight proxy object that represents the addition without performing it. By the time the expression is assigned to a result variable, the compiler has woven all the operations into a single loop. No temporaries. No extra passes over memory. Just the math you wrote, compiled into the machine code you'd have written by hand.

By the end of this article you'll understand exactly how to design an ET system from scratch — the proxy types, the recursive template machinery, the assignment trick that triggers evaluation — and you'll know the real-world traps around dangling references, compile times, and debuggability that library authors deal with every day. You'll also be ready to answer the ET questions that come up in quantitative finance, games, and HPC interviews.

The Performance Bottleneck: Naive Operator Overloading

To appreciate Expression Templates, you must first understand the 'Temporary Problem.' When you overload operator+ to return a new Vector object, an expression like R = A + B + C evaluates as temp1 = A + B, then temp2 = temp1 + C, and finally R = temp2.

Each addition involves a loop over the data and a memory allocation for the temporary. This is O(3N) traversal when O(N) is mathematically possible. Expression Templates transform this into a single loop by delaying evaluation until the assignment operator is invoked.

#include <iostream>
#include <vector>
#include <cassert>

namespace io::thecodeforge::hpc {

// 1. The Proxy Class: Represents an addition without performing it
template <typename L, typename R>
class VecAdd {
    const L& lhs;
    const R& rhs;
public:
    VecAdd(const L& l, const R& r) : lhs(l), rhs(r) {}

    // Lazy evaluation of a single element
    double operator[](size_t i) const {
        return lhs[i] + rhs[i];
    }

    size_t size() const { return lhs.size(); }
};

// 2. The Base Vector Class
class ForgeVector {
    std::vector<double> data;
public:
    ForgeVector(size_t n) : data(n) {}
    
    double& operator[](size_t i) { return data[i]; }
    double operator[](size_t i) const { return data[i]; }
    size_t size() const { return data.size(); }

    // The Assignment Trigger: This is where the magic loop happens
    template <typename Expr>
    ForgeVector& operator=(const Expr& expr) {
        assert(size() == expr.size());
        for (size_t i = 0; i < data.size(); ++i) {
            data[i] = expr[i]; // Single pass, no temporaries!
        }
        return *this;
    }
};

// 3. Overloaded Operator: Returns the Proxy, not a ForgeVector
template <typename L, typename R>
VecAdd<L, R> operator+(const L& l, const R& r) {
    return VecAdd<L, R>(l, r);
}

}

int main() {
    using namespace io::thecodeforge::hpc;
    
    ForgeVector A(100), B(100), C(100), R(100);
    // Initialize values...
    A[0] = 1.0; B[0] = 2.0; C[0] = 3.0;

    // This produces NO temporary ForgeVector objects
    R = A + B + C; 

    std::cout << "Result[0]: " << R[0] << " 🔥" << std::endl;
    return 0;
}

Frequently Asked Questions