Expression templates

Expression templates are a C++ template metaprogramming technique that builds structures representing a computation at compile time, where expressions are evaluated only as needed to produce efficient code for the entire computation. Expression templates thus allow programmers to bypass the normal order of evaluation of the C++ language and achieve optimizations such as loop fusion.

Expression templates were invented independently by Todd Veldhuizen and David Vandevoorde; it was Veldhuizen who gave them their name. They are a popular technique for the implementation of linear algebra software.

Motivation and example
Consider a library representing vectors and operations on them. One common mathematical operation is to add two vectors $u$ and $v$, element-wise, to produce a new vector. The obvious C++ implementation of this operation would be an overloaded  that returns a new vector object:

Users of this class can now write  where   and   are both instances of.

A problem with this approach is that more complicated expressions such as  are implemented inefficiently. The implementation first produces a temporary  to hold , then produces another   with the elements of   added in. Even with return value optimization this will allocate memory at least twice and require two loops.

Delayed evaluation solves this problem, and can be implemented in C++ by letting  return an object of an auxiliary type, say , that represents the unevaluated sum of two  s, or a vector with a  , etc. Larger expressions then effectively build expression trees that are evaluated only when assigned to an actual   variable. But this requires traversing such trees to do the evaluation, which is in itself costly.

Expression templates implement delayed evaluation using expression trees that only exist at compile time. Each assignment to a, such as  , generates a new   constructor if needed by template instantiation. This constructor operates on three ; it allocates the necessary memory and then performs the computation. Thus only one memory allocation is performed.

Example implementation of expression templates :

An example implementation of expression templates looks like the following. A base class  represents any vector-valued expression. It is templated on the actual expression type  to be implemented, per the curiously recurring template pattern. The existence of a base class like  is not strictly necessary for expression templates to work. It will merely serve as a function argument type to distinguish the expressions from other types (note the definition of a  constructor and   below).

The boolean  is there to tag  s  that are "leafs", i.e. that actually contain data. The  class is a leaf that stores the coordinates of a fully evaluated vector expression, and becomes a subclass of.

The sum of two s is represented by a new type, , that is templated on the types of the left- and right-hand sides of the sum so that it can be applied to arbitrary pairs of   expressions. An overloaded  serves as syntactic sugar for the   constructor. A subtlety intervenes in this case: in order to reference the original data when summing two s,   needs to store a const reference to each   if it is a leaf, otherwise it is a temporary object that needs to be copied to be properly saved.

With the above definitions, the expression  is of type

so  invokes the templated   constructor   with its template argument   being this type (meaning  ). Inside this constructor, the loop body

is effectively expanded (following the recursive definitions of  and  on this type) to

with no temporary  objects needed and only one pass through each memory block.

Basic Usage :

Applications
Expression templates have been found especially useful by the authors of libraries for linear algebra, that is, for dealing with vectors and matrices of numbers. Among libraries employing expression template are Dlib, Armadillo, Blaze, Blitz++, Boost uBLAS, Eigen, POOMA, Stan Math Library, and xtensor. Expression templates can also accelerate C++ automatic differentiation implementations, as demonstrated in the Adept library.

Outside of vector math, the Spirit parser framework uses expression templates to represent formal grammars and compile these into parsers.