Trusted answers to developer questions
Trusted Answers to Developer Questions

Related Tags

template
metaprogramming
c++

What is template metaprogramming?

Educative Answers Team

Grokking Modern System Design Interview for Engineers & Managers

Ace your System Design Interview and take your career to the next level. Learn to handle the design of applications like Netflix, Quora, Facebook, Uber, and many more in a 45-min interview. Learn the RESHADED framework for architecting web-scale applications by determining requirements, constraints, and assumptions before diving into a step-by-step design process.

The ability of C++ to perform compile-time computations ​to create a more generic and optimized code is known as template metaprogramming (TMP).

TMP can be thought of as an embedded language that sits on a layer above the standard C++, is interpreted by a C++ compiler’s template system, and outputs the standard C++ code that is compiled normally. It allows the performance of general-purpose computations with types, templates, functions, constant variables, ​and literals as ​objects.

svg viewer

Runtime and compile-time variables

Before diving into the details of TMP, it is essential to understand the difference between runtime and compile-time variables:

/* Runtime variables. */
char c = 'x';
int *ptr = new int(10);
/* Compile-time values and types. */
const int num = 10;
typedef float t;

The variables c and ptr are dynamic runtime variables that can be assigned any value during the execution of the program. The variables num and t are compile-time variables that can only be assigned once during a compilation. They are immutable throughout compilation ​and in any instantiation that they are used.

Now, let’s consider a runtime function that adds two numbers. The function is only compiled once and can ​be called multiple times with different values.

// A runtime function that returns the sum of two integers.
int add(int num1, int num2) {
return num1 + num2;
}

​However, as shown below, the same function can be made into a compile-time function using TMP:

template <int num1, int num2>
struct add {
static const int value = (num1 + num2);
};

The add function is mapped to a compile-time computation using a class template instantiation where:

  • A class or struct template body is the function body.
  • The template parameters are the function parameters.
  • A static const member is the return value.

The struct template, add, is compiled for each unique instantiation of the template and gathers a unique type each time. The evaluation of the static const member, ‘value’, during instantiation of the struct performs the exact same computation as the runtime function shown above, only this computation is performed during instantiation and is, therefore, performed entirely at compile-time.

Code

The following code snippet executes the compile-time function that was​ made using TMP:

#include <iostream>
using namespace std;
template <int num1, int num2>
struct add {
static const int value = (num1 + num2);
};
int main() {
const int a = 10, b = 20;
const int r1 = add<a, b>::value;
cout << "Sum is: " << r1 << endl;
return 0;
}

RELATED TAGS

template
metaprogramming
c++
Copyright ©2022 Educative, Inc. All rights reserved

Grokking Modern System Design Interview for Engineers & Managers

Ace your System Design Interview and take your career to the next level. Learn to handle the design of applications like Netflix, Quora, Facebook, Uber, and many more in a 45-min interview. Learn the RESHADED framework for architecting web-scale applications by determining requirements, constraints, and assumptions before diving into a step-by-step design process.

Keep Exploring