C++14 Variable Templates: what is their purpose? Any usage example?

by

And other than the pi example, how would it work with non-const
variables?

Currently, it seems to instantiate the variables separately for the type. i.e., you could assign 10 to n<int> and it would be different from the template definition.

template<typename T>
T n = T(5);

int main()
{
    n<int> = 10;
    std::cout << n<int> << " ";    // 10
    std::cout << n<double> << " "; // 5
}

If the declaration is const, it is readonly. If it’s a constexpr, like all constexpr declarations, it has not much use outside constexpr(ressions).

Besides that we can have this feature just by wrapping a variable
within a templated struct or class, how does this mix with type
conversions?

It’s meant to be a simple proposal. I am unable to see how it affects type conversions in a significant way. As I already stated, the type of the variable is the type you instantiated the template with. i.e., decltype(n<int>) is int. decltype((double)n<int>) is double and so on.

Any usage example to understand how to make the most of such a feature
and what its purpose is?

N3651 provides a succinct rationale.

Alas, existing C++ rules do not allow a template declaration to
declare a variable. There are well known workarounds for this
problem:

• use constexpr static data members of class templates

• use constexpr function templates returning the desired values

These workarounds have been known for decades and well documented.
Standard classes such as std::numeric_limits are archetypical
examples. Although these workarounds aren’t perfect, their drawbacks
were tolerable to some degree because in the C++03 era only simple,
builtin types constants enjoyed unfettered direct and efficient
compile time support. All of that changed with the adoption of
constexpr variables in C++11, which extended the direct and efficient
support to constants of user-defined types. Now, programmers are
making constants (of class types) more and more apparent in programs.
So grow the confusion and frustrations associated with the
workarounds.

…

The main problems with “static data member” are:

• they require “duplicate” declarations: once inside the class
template, once outside the class template to provide the “real”
definition in case the con- stants is odr-used.

• programmers are both miffed and confused by the necessity of providing twice the same
declaration. By contrast, “ordinary” constant declarations do not need
duplicate declarations.

…

Well known examples in this category are probably static member
functions of numeric_limits, or functions such as
boost::constants::pi<T>(), etc. Constexpr functions templates do not
suffer the “duplicate declarations” issue that static data members
have; furthermore, they provide functional abstraction. However, they
force the programmer to chose in advance, at the definition site, how
the constants are to be delivered: either by a const reference, or by
plain non- reference type. If delivered by const reference then the
constants must be systematically be allocated in static storage; if
by non-reference type, then the constants need copying. Copying isn’t
an issue for builtin types, but it is a showstopper for user-defined
types with value semantics that aren’t just wrappers around tiny
builtin types (e.g. matrix, or integer, or bigfloat, etc.) By
contrast, “ordinary” const(expr) variables do not suffer from this
problem. A simple definition is provided, and the decision of
whether the constants actually needs to be layout out in storage only
depends on the usage, not the definition.

More Related Contents:

  1. How does `void_t` work
  2. static_assert dependent on non-type template parameter (different behavior on gcc and clang)
  3. How to make std::make_unique a friend of my class
  4. details of std::make_index_sequence and std::index_sequence
  5. Fallback variadic constructor – why does this work?
  6. How do we use void_t for SFINAE?
  7. what is the concept of evaluation of expression z = (y = 30) + (y = 10) + (y = 20); [closed]
  8. Why can’t the template argument be deduced when it is used as template parameter to another template?
  9. How to detect whether there is a specific member variable in class?
  10. Why not infer template parameter from constructor?
  11. Explicit template instantiation – when is it used?
  12. C++ Static member initialization (template fun inside)
  13. Is auto as a parameter in a regular function a GCC 4.9 extension?
  14. Uses of a C++ Arithmetic Promotion Header
  15. check if member exists using enable_if
  16. Inheritance and templates in C++ – why are inherited members invisible?
  17. Why can’t templates be within extern “C” blocks?
  18. Get index of a tuple element’s type?
  19. Best introduction to C++ template metaprogramming? [closed]
  20. C++ type registration at compile time trick
  21. When instantiating a template, should members of its incomplete argument types be visible?
  22. Template default arguments
  23. Which headers in the C++ standard library are guaranteed to include another header?
  24. Default template argument when using std::enable_if as templ. param.: why OK with two template functions that differ only in the enable_if parameter?
  25. compile time loops
  26. Class template for numeric types
  27. C++ class with template member variable
  28. calculating factorial using template meta-programming
  29. Can I use the result of a C++17 captureless lambda constexpr conversion operator as a function pointer template non-type argument?
  30. Check if a type is passed in variadic template parameter pack

Leave a Comment