Variable Templates

Let's introduce our second type of template - variable templates. Let's imagine we were creating a library for our colleagues to use. Our library needs mathematical constants, such as Pi:

1constexpr double Pi {
2  3.141592653589793238462643383279
3}

We elected to use a double here, but that might be presumptuous. We don’t know how our library is going to be used by our consumers, so the preferred type was just a guess. In some scenarios, they might prefer a float, or a custom type.

That conversion could be done at run time, but it would have a performance cost, and may reduce type safety.

We could create different versions of our variable:

1constexpr int PiInt {
2  3
3};
4
5constexpr double PiFloat {
6  3.141592f
7};
8
9constexpr double PiDouble {
10  3.141592653589793
11};

But, this has the same disadvantages we saw when trying to create classes to accommodate different data types. Aside from the code duplication and the verbose names, this approach requires us to know all the types our users will want in advance.

Creating Variable Templates

Instead, we could create a variable template, using a template parameter in place of the type. In this example, our parameter will be a typename and we’ll call it T:

1template <typename T>
2constexpr T Pi {
3  3.141592653589793238462643383279
4};

Now, we can ask our variable template to create new variables, using the < and > syntax. Given that this template requires a type as its parameter, would provide that type as an argument:

1template <typename T>
2constexpr T Pi{3.141592653589793238462643383279};
3
4int main() {
5  // Will be an integer initialized to 3
6  auto IntegerPi{Pi<int>};
7}

Variable Templates with Custom Types

Any time the compiler encounters the Pi template being invoked with a type that it hasn't seen, it will use the template to create a new variable, passing the literal 3.141... to that type's constructor.

Given this happens at compile time, the type must have a constructor that can accept that argument at compile time. In the following example, we instantiate Pi<CustomType>, where CustomType has a constexpr constructor that can accept the double:

1#include <iostream>
2
3template <typename T>
4constexpr T Pi{3.141592653589793238462643383279};
5
6struct CustomType {
7  constexpr CustomType(double InitialValue)
8    : Value{int(InitialValue)} {}
9
10  int Value;
11};
12
13int main() {
14  auto Container{Pi<CustomType>};
15
16  std::cout << "Container Value: "
17    << Container.Value;
18}

1Container Value: 3.14159

Non-Typename Parameters

Variable templates are not restricted to just setting the type of the generated variable. Our templates can have multiple parameters, and use them as needed to create a variable.

Below, we define a template that creates integers whose value is initialized to the result of calling the + operator on two integer parameters:

1template <int x, int y>
2constexpr int Result{x + y};
3
4int main() {
5  int MySum{Result<1, 2>};
6}

Given this calculation is done at compile time, we can ensure there is no runtime performance impact which is ideal if our calculation is expensive, or performed frequently.

However, it also means the expressions we use in our template variable must be evaluable at compile time. In the previous example, operator+(int, int) meets this criterion, so our template is valid.

1#include <iostream>
2
3template <int x, int y>
4int Result{x + y}; // not const 
5
6int main() {
7  ++Result<1, 2>;
8
9  // ...
10
11  int MySum{Result<1, 2>};
12  std::cout << "MySum: " << MySum;
13}

1MySum: 4

1template <int x, int y>
2constexpr int Result{x + y};
3
4int main() {
5  ++Result<1, 2>;
6}

1error: increment of read-only variable 'Result<1, 2>'

1#include <iostream>
2
3template <int x, int y>
4constexpr int Result{x + y};
5
6int main() {
7  int MySum{Result<1, 2>};
8  std::cout << "MySum is now: " << ++MySum;
9
10  std::cout << "\nResult<1, 2> is still: "
11    << Result<1, 2>;
12}

1MySum is now: 4
2Result<1, 2> is still: 3

1consteval int Result(int x, int y) {
2  return x + y;
3}
4
5int main() {
6  int MySum{Result(1, 2)};
7}

Summary

In this lesson, we learned about variable templates in C++. Here are the key takeaways:

• Variable templates allow us to create variables with parameterized types, similar to class templates.
• They provide flexibility and reusability by allowing the user to specify the desired type when instantiating the variable.
• Variable templates can have multiple parameters and perform compile-time calculations.
• It's recommended to mark variable templates as constexpr to prevent unexpected behavior due to shared instances.
• Variable templates offer an alternative to creating multiple versions of variables for different types.
• They enable us to create variables with custom types that have constexpr constructors.
• Variable templates can be used for compile-time calculations, ensuring no runtime performance impact.

Next Lesson

Function Templates

Understand the fundamentals of C++ function templates and harness generics for more modular, adaptable code.

ContinueView Course