Variable Templates

Let's see an example of creating our first template. We'll start with variable templates.

Variable templates are perhaps the least useful, but they're the most simple to create.

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}
4

But, how did we decide to use a double here? We don’t know how our library is going to be used by our consumers, so the preferred type was really just a guess. Maybe they’d prefer float? We could create different versions of this:

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

There are some disadvantages here. Aside from the code duplication and the verbose names, this approach requires us to know all the types our users will want in advance.

This may not be possible to know. For example, anyone using our Pi code could be defining their own numeric types, rather than using the built-in types.

So, variable templates can help us here.

Creating Variable Templates

To create a variable template, let's replace the type with a template parameter. To do this, we state that we're going to use a template in place of a type name. For now, we will call that parameter SomeType.

1template <typename SomeType>
2

Then, anywhere we want to refer to that type, we will instead refer to our template parameter:

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

We can call our parameter whatever we want but, by convention, templated types are often called T:

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

Using Variable Templates

Now, we can ask our variable template to create new variables, using the < and > syntax. Given that the template requires a type as its parameter, we need to specify what type the variable should be:

1Pi<int>;
2Pi<float>;
3Pi<double>;
4Pi<SomeCustomType>;
5

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 double 3.141... to that type's constructor.

So, for Pi<SomeCustomType> to be valid, SomeCustomType would need to have a constructor that can accept a double.

In the above example, the compiler will create 4 new variables.

In isolation, a statement like Pi<double>; is not particularly useful. However, this expression also returns the value of the variable that was created, so they can immediately be used like any other value:

1auto MyValue { Pi<int> };
2SomeFunction(Pi<float>);
3