Free, Unlimited Access

Comprehensive course covering advanced concepts, and how to use them on large-scale projects.

Professional C++





<Excerpt>


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:


```c++
constexpr double Pi {
  3.141592653589793238462643383279
}
```


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.


</Excerpt>


We could create different versions of our variable:


```c++
constexpr int PiInt {
  3
};

constexpr double PiFloat {
  3.141592f
};

constexpr double PiDouble {
  3.141592653589793
};
```


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.


<Ad />


## 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`:


```c++
template <typename T>//<h>
constexpr T Pi {//<h>
  3.141592653589793238462643383279
};
```


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:


```c++
template <typename T>
constexpr T Pi{3.141592653589793238462643383279};

int main() {
  // Will be an integer initialized to 3
  auto IntegerPi{Pi<int>};//<h>
}
```


## 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`:


```c++
#include <iostream>

template <typename T>
constexpr T Pi{3.141592653589793238462643383279};

struct CustomType {
  constexpr CustomType(double InitialValue)//<h>
    : Value{int(InitialValue)} {}//<h>

  int Value;
};

int main() {
  auto Container{Pi<CustomType>};//<h>

  std::cout << "Container Value: "
    << Container.Value;
}
```


```c++
//<o>
Container 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:


```c++
template <int x, int y>//<h>
constexpr int Result{x + y};//<h>

int main() {
  int MySum{Result<1, 2>};
}
```


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.


<Aside>


### FAQ: `constexpr` with Template Variables


In almost all scenarios, we will want to mark template variables as `constexpr`, preventing them from being modified.  Similar to class templates, variable templates deduplicate themselves based on their arguments.


For example, if we have multiple invocations of `Result<1, 2>`, only a single variable will be generated.  All references to `Result<1, 2>` will share that same variable.  Therefore, if one of those locations modifies the variable, it can create unexpected behaviour elsewhere in our code:


```c++
#include <iostream>

template <int x, int y>
int Result{x + y}; // not const //<w>

int main() {
  ++Result<1, 2>;//<w>

  // ...

  int MySum{Result<1, 2>};//<h>
  std::cout << "MySum: " << MySum;
}
```


```c++
//<o>
MySum: 4
```


Marking our variable `const` (or `constexpr`) prevents this from happening:


```c++
template <int x, int y>
constexpr int Result{x + y};//<h>

int main() {
  ++Result<1, 2>;//<e>
}
```


```c++
//<oe>
error: increment of read-only variable 'Result<1, 2>'
```


It does not prevent variables created from our template from being modified  A non-const variable like `MySum` can be created from a `const` template.  Because `MySum` is _**not**_ a reference, it is created by _**copying**_ the value `Result<1, 2>`.


Therefore, modifications to `MySum` are not modifying `Result<1, 2>` - they’re acting on a copy:


```c++
#include <iostream>

template <int x, int y>
constexpr int Result{x + y};

int main() {
  int MySum{Result<1, 2>};
  std::cout << "MySum is now: " << ++MySum;//<h>

  std::cout << "\nResult<1, 2> is still: "
    << Result<1, 2>;//<h>
}
```


```c++
//<o>
MySum is now: 4
Result<1, 2> is still: 3
```


</Aside>


<Aside>


### `consteval` Functions (C++20)


Since the introduction of `consteval` in C++20, we now have an additional way to implement compile-time calculations.  Our previous variable template could be replaced with this function, if preferred:


```c++
consteval int Result(int x, int y) {//<h>
  return x + y;//<h>
}//<h>

int main() {
  int MySum{Result(1, 2)};
}
```


This is more suitable for complex use cases, as it gives us the full flexibility of a function body.  That can include `if` statements, local variables, and more to determine the resulting value.


It won’t work if our parameter list needs to include a `typename`, but we’ll see how we can solve that later in the chapter when we introduce function templates.


</Aside>


## 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.

<FAQ>


```javascript
//<m>
{
  slug: 'variable-templates-vs-variables',
  title: 'Variable Templates vs Variables',
  question: 'How do I choose between using a variable template and a regular variable?',
}
```


The choice between using a variable template and a regular variable depends on your specific use case.


If you need a variable that can work with different types and provide flexibility to the user of your code, a variable template is a good choice. It allows you to create a single variable definition that can be instantiated with different types based on the user's needs.


On the other hand, if you have a variable that always uses a fixed type and doesn't require any templating, a regular variable is sufficient. Regular variables are simpler to define and use when type flexibility is not necessary.


</FAQ>


<FAQ>


```javascript
//<m>
{
  slug: 'variable-templates-custom-types',
  title: 'Variable Templates with Custom Types',
  question: 'Can I use variable templates with user-defined types?',
}
```


Yes, you can use variable templates with user-defined types. The type used in a variable template can be any valid C++ type, including user-defined types such as classes or structs. However, there are a few requirements for using user-defined types with variable templates:

- The user-defined type must have a `constexpr` constructor that can accept the arguments passed to the variable template.
- The user-defined type must be default-constructible if no arguments are provided to the variable template.

Here's an example of using a variable template with a user-defined type:


```c++
struct MyType {
  constexpr MyType(int value) : value(value) {}
  int value;
};

template <typename T>
constexpr T myVariable = T(42);

int main() {
  // v.value will be 42
  MyType v = myVariable<MyType>;
}
```


In this example, `MyType` is a user-defined type with a `constexpr` constructor that accepts an `int` value. The variable template `myVariable` is defined with a type parameter `T` and initializes the variable with `T(42)`. When `myVariable` is instantiated with `MyType`, it creates an instance of `MyType` with the value `42`.


</FAQ>


<FAQ>


```javascript
//<m>
{
  slug: 'variable-template-restrictions',
  title: 'Variable Template Restrictions',
  question: 'Are there any limitations or restrictions when using variable templates?',
}
```


While variable templates provide a lot of flexibility and power, there are a few limitations and restrictions to keep in mind:

- Variable templates are a compile-time feature, so the arguments passed to the template must be known at compile-time. This means that the arguments must be constant expressions or constexpr variables.
- The type used in a variable template must be a complete type at the point of instantiation. If the type is incomplete or not yet defined, it will result in a compilation error.
- Variable templates cannot be specialized in the same way as function templates or class templates. The template arguments must match exactly for the variable template to be instantiated.
- Variable templates are not allowed to have default template arguments. Each template parameter must be explicitly provided when instantiating the variable template.
- The initialization of a variable template must be done with a constant expression. Non-constant expressions or runtime values cannot be used to initialize a variable template.

It's important to be aware of these limitations when using variable templates to ensure that your code compiles successfully and behaves as expected.


</FAQ>


<FAQ>


```javascript
//<m>
{
  slug: 'variable-templates-vs-constexpr',
  title: 'Variable Templates vs Constexpr Variables',
  question: 'How do variable templates differ from constexpr variables?',
}
```


Variable templates and constexpr variables are related but have some key differences:

- Variable templates allow you to define a variable that can be instantiated with different types. They provide a way to create variables with parameterized types, similar to how function templates allow functions to work with different types. Variable templates are defined using the `template` keyword followed by template parameters.
- Constexpr variables, on the other hand, are variables that are evaluated at compile-time and have a constant value. They are defined using the `constexpr` keyword and must be initialized with a constant expression. Constexpr variables can be of any type, but their value must be known at compile-time.

Here's an example to illustrate the difference:


```c++
// Variable template
template <typename T>
constexpr T pi = T(3.14159265358979323846);

// Constexpr variable
constexpr double e = 2.71828182845904523536;

int main() {
  // Instantiating the variable template with double
  double pi_double = pi<double>;
  
  // Instantiating the variable template with float
  float pi_float = pi<float>;

  // Using the constexpr variable
  double result = e * 2;
}
```


In this example, `pi` is a variable template that can be instantiated with different types, such as `double` or `float`. Each instantiation creates a separate variable with the specified type and initializes it with the provided value.


On the other hand, `e` is a constexpr variable of type `double`. Its value is fixed and known at compile-time. The key difference is that variable templates allow for type parameterization, while constexpr variables have a fixed type and value determined at compile-time.


Both variable templates and constexpr variables are useful for creating compile-time constants and performing compile-time computations, but variable templates offer additional flexibility in terms of type parameterization.


</FAQ>


<FAQ>


```javascript
//<m>
{
  slug: 'compile-time-constants',
  title: 'Compile Time Constants using Templates',
  question: 'Can I use variable templates to create compile-time constants?',
}
```


Yes, variable templates can be used to create compile-time constants. By defining a variable template with a constexpr value, you can create variables that are evaluated at compile-time and have a constant value. Here's an example of using a variable template to create compile-time constants:


```c++
template <typename T>
constexpr T pi = T(3.14159265358979323846);

template <int N>
constexpr int factorial = N * factorial<N - 1>;

template <>
constexpr int factorial<0> = 1;

int main() {
  constexpr double pi_double = pi<double>;
  constexpr float pi_float = pi<float>;

  constexpr int fact_5 = factorial<5>;
  constexpr int fact_10 = factorial<10>;
}
```


In this example, we have two variable templates: `pi` and `factorial`. The `pi` variable template is defined with a type parameter `T` and initialized with a constant expression that represents the value of pi. When instantiated with a specific type, such as `double` or `float`, it creates a compile-time constant of that type with the value of pi.


The `factorial` variable template is defined with a non-type template parameter `N` and calculates the factorial of `N` at compile-time. It uses recursion to multiply `N` with the factorial of `N-1` until the base case of `factorial<0>` is reached, which is defined as a specialization that returns 1.


In the `main` function, we instantiate the variable templates with specific arguments, such as `pi<double>`, `pi<float>`, `factorial<5>`, and `factorial<10>`. These instantiations create compile-time constants that can be used in constant expressions. Using variable templates in this way allows you to define compile-time constants with parameterized types or values, providing flexibility and reusability in your code.


It's important to note that the expressions used to initialize variable templates must be constant expressions that can be evaluated at compile-time. This ensures that the variable templates are true compile-time constants and can be used in contexts that require constant expressions.


</FAQ>



An introduction to variable templates, allowing us to create variables at compile time.

Variable Templates vs Variables

Variable Templates with Custom Types

Variable Template Restrictions

Variable Templates vs Constexpr Variables

Compile Time Constants using Templates

Variable template

constexpr specifier

typename specifier

Templates in C++

Variable Templates

C++14's Variable Templates

What exactly is a variable template

UPDATED FOR C++23 | Beginner’s Guide to C++ variable templates, allowing us to create variables at compile time | Clear explanations and simple code examples

Variable Templates with Custom Types

Can I use variable templates with user-defined types?

Variable Templates

How do I choose between using a variable template and a regular variable?

Are there any limitations or restrictions when using variable templates?

How do variable templates differ from constexpr variables?

Can I use variable templates to create compile-time constants?

Variable Templates

Professional C++

This course includes:

Professional C++