Variable template

A variable template defines a family of variables or static data members.

Syntax

Explanation

A variable template may be introduced by a template declaration at namespace scope, where declaration declares a variable.

template<class T>
constexpr T pi = T(3.1415926535897932385);  // variable template
 
template<class T>
T circular_area(T r) // function template
{
    return pi<T> * r * r; // pi<T> is a variable template instantiation
}

When used at class scope, variable template declares a static data member template.

using namespace std::literals;
struct matrix_constants
{
    template<class T>
    using pauli = hermitian_matrix<T, 2>; // alias template
 
    template<class T> // static data member template
    static constexpr pauli<T> sigma1 = { { 0, 1 }, { 1, 0 } }; 
 
    template<class T>
    static constexpr pauli<T> sigma2 = { { 0, -1i }, { 1i, 0 } };
 
    template<class T>
    static constexpr pauli<T> sigma3 = { { 1, 0 }, { 0, -1 } };
};

As with other static members, a definition of a static data member template may be required. Such definition is provided outside the class definition. A template declaration of a static data member at namespace scope may also be a definition of a non-template data member of a class template:

struct limits {
    template<typename T>
    static const T min; // declaration of a static data member template
};
template<typename T>
const T limits::min = { }; // definition of a static data member template
 
template<class T>
class X {
   static T s; // declaration of a non-template static data member of a class template
};
template<class T>
T X<T>::s = 0; // definition of a non-template data member of a class template

Unless a variable template was explicitly specialized or explicitly instantiated, it is implicitly instantiated when a specialization of the variable template is used.

Default template argument of a variable template is implicitly instantiated when the variable template is used in the context that requires the value of the argument.

Notes

Until variable templates were introduced in C++14, parametrized variables were typically implemented as either static data members of class templates or as constexpr function templates returning the desired values.

Variable templates cannot be used as template template arguments.