Variable template

 

C++

Language

Standard library headers

Concepts

Utilities library

Strings library

Containers library

Algorithms library

Iterators library

Numerics library

Input/output library

Localizations library

Regular expressions library (C++11)

Atomic operations library (C++11)

Thread support library (C++11)

Filesystem library (C++17)

Technical Specifications

 

C++ language

 

Templates

parameters and arguments

class templates

function templates

class member templates

variable templates(C++14)

template argument deduction

class template deduction(C++17)

explicit (full) specialization

partial specialization

dependent names

parameter packs(C++11)

sizeof... (C++11)

fold-expressions(C++17)

SFINAE

Constraints and concepts(concepts TS)

 

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

Syntax

template < parameter-list > variable-declaration

Explanation

variable-declaration	-	a declaration of a variable. The declared variable name becomes a template name.
parameter-list	-	a non-empty comma-separated list of the template parameters, each of which is either non-type parameter, a type parameter, a template parameter, or a parameter pack of any of those.

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.