Template specialization with non-type - c++

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;
}