非类型的模板专业化

Question

Considering I have a simple class template:

template <typename T>
class foo
{
    T t;
};

Is it possible to specialize foo such that T is not a type but a non-type value so that:

foo<float> my_foo;

Uses the class template shown above, while

foo<20> my_other_foo;

Uses a different template specialization? Is this possible, and if yes, what would the template specialization code look like?

Answer 1

Is this possible, and if yes, what would the partial specialization code look like?

As you exactly want, no: it's impossible.

But, if you can use C++17, you can make almost the contrary: receiving an auto value ( T become the declval() of the value)

template <auto Val>
struct foo
 {
   using T = decltype(Val);

   T t { Val }; // or also decltype(Val) t {Val};

   static constexpr bool isSpecialized { false };
 };

you can specialize for 20 (where 20 is an int ; doesn't match (by example) 20L or 20U )

template <>
struct foo<20>
 {
   static constexpr bool isSpecialized { true };
 };

The problem of this solution is that you can't have foo<float> because a float value can't be a template not-type parameter (so you can't write foo<0.0f> , by example).

You can roughly bypass this problem adding a second template type parameter with a default value (the type of the first parameter)

template <auto Val, typename T = decltype(Val)>
struct bar
 {
   T t { Val };

   static constexpr bool isSpecialized { false };
 };

and the 20 specialization remain

template <>
struct bar<20>
 {
   static constexpr bool isSpecialized { true };
 };

but now you can call bar<0, float> as substitute of the old foo<float>

The following is a full compiling (C++17, obviously) example

#include <iostream>

template <auto Val>
struct foo
 {
   using T = decltype(Val);

   T t { Val }; // or also decltype(Val) t {Val};

   static constexpr bool isSpecialized { false };
 };

template <>
struct foo<20>
 {
   static constexpr bool isSpecialized { true };
 };

template <auto Val, typename T = decltype(Val)>
struct bar
 {
   T t { Val };

   static constexpr bool isSpecialized { false };
 };

template <>
struct bar<20>
 {
   static constexpr bool isSpecialized { true };
 };

int main ()
 {
   std::cout << foo<0>::isSpecialized << std::endl;   // print 0
   std::cout << foo<20>::isSpecialized << std::endl;  // print 1
   std::cout << foo<20L>::isSpecialized << std::endl; // print 0

   std::cout << bar<0>::isSpecialized << std::endl;         // print 0
   std::cout << bar<20>::isSpecialized << std::endl;        // print 1
   std::cout << bar<20L>::isSpecialized << std::endl;       // print 0
   std::cout << bar<20, float>::isSpecialized << std::endl; // print 0

 }

Answer 2

#include <type_traits>
#include <iostream>

template <typename T>
struct foo
{
    foo(T x) : t(x) {};

    T t;
};

// specialise for integral constant
template<class T, T N>
struct foo<std::integral_constant<T, N>>
{
    // same interface
    static constexpr T t = N;
};

// test
int main()
{
    auto foo1 = foo<float>(10.0);
    auto foo2 = foo<std::integral_constant<int, 20>>();

    std::cout << foo1.t << std::endl;
    std::cout << foo2.t << std::endl;
}