Why can’t I use float value as a template parameter?

by

THE SIMPLE ANSWER

The standard doesn’t allow floating points as non-type template-arguments, which can be read about in the following section of the C++11 standard;

14.3.2/1      Template non-type arguments      [temp.arg.nontype]

A template-argument for a non-type, non-template template-parameter
shall be one of:

  • for a non-type template-parameter of integral or enumeration type, a converted constant expression (5.19) of the type of the
    template-parameter;

  • the name of a non-type template-parameter; or

  • a constant expression (5.19) that designates the address of an object with static storage duration and external or internal linkage
    or a function with external or internal linkage, including function
    templates and function template-ids but excluding non-static class
    members, expressed (ignoring parentheses) as & id-expression, except
    that the & may be omitted if the name refers to a function or array
    and shall be omitted if the corresponding template-parameter is a
    reference; or

  • a constant expression that evaluates to a null pointer value (4.10); or

  • a constant expression that evaluates to a null member pointer value (4.11); or

  • a pointer to member expressed as described in 5.3.1.

But.. but.. WHY!?

It is probably due to the fact that floating point calculations cannot be represented in an exact manner. If it was allowed it could/would result in erroneous/weird behavior when doing something as this;

func<1/3.f> (); 
func<2/6.f> ();

We meant to call the same function twice but this might not be the case since the floating point representation of the two calculations isn’t guaranteed to be exactly the same.

How would I represent floating point values as template arguments?

With C++11 you could write some pretty advanced constant-expressions (constexpr) that would calculate the numerator/denominator of a floating value compile time and then pass these two as separate integer arguments.

Remember to define some sort of threshold so that floating point values close to each other yields the same numerator/denominator, otherwise it’s kinda pointless since it will then yield the same result previously mentioned as a reason not to allow floating point values as non-type template arguments.

More Related Contents:

  1. Why do i have a random result on this template?
  2. Templated check for the existence of a class member function?
  3. How does `void_t` work
  4. using extern template (C++11)
  5. Does C++ support compile-time counters?
  6. What are the differences between Generics in C# and Java… and Templates in C++? [closed]
  7. What exactly is the “immediate context” mentioned in the C++11 Standard for which SFINAE applies?
  8. How can I write a power function myself?
  9. Why is the template argument deduction not working here?
  10. Difference in floating point arithmetics between x86 and x64
  11. using std::is_same, why my function still can’t work for 2 types
  12. Why did Microsoft abandon long double data type? [closed]
  13. Alias template specialisation
  14. Explicit specialization in non-namespace scope does not compile in GCC
  15. What do compilers do with compile-time branching?
  16. How to detect double precision floating point overflow and underflow?
  17. Can you make custom operators in C++?
  18. Set back default floating point print precision in C++
  19. Is there any difference between “T” and “const T” in template parameter?
  20. String literals not allowed as non type template parameters
  21. (Partially) specializing a non-type template parameter of dependent type
  22. C++ convert integer to string at compile time
  23. Lambda expressions as class template parameters
  24. Do c++ templates make programs slow?
  25. Using export keyword with templates
  26. How to make a variadic is_same?
  27. Understanding (simple?) C++ Partial Template Specialization
  28. Default template parameter partial specialization
  29. Does reinterpret_cast lead to undefined behavior?
  30. C++ template function compiles in header but not implementation

Leave a Comment