What's the point of unnamed non-type template parameters?

Question

According to the reference, the name of a non-type template parameter is optional, even when assigning a default value (see (1) and (2)). Therefore these template structs are valid:

template <int> struct Foo {};
template <unsigned long = 42> struct Bar {};

I haven't seen a possibility of accessing the values of the non-type parameters. My question is: What's the point of unnamed/anonymous non-type template parameters? Why are the names optional?

Answer 1

First, we can split declaration from definition. So name in declaration is not really helpful. and name might be used in definition

template <int> struct Foo;
template <unsigned long = 42> struct Bar;

template <int N> struct Foo {/*..*/};
template <unsigned long N> struct Bar {/*..*/};

Specialization is a special case of definition.

Then name can be unused, so we might omit it:

template <std::size_t, typename T>
using always_t = T;

template <std::size_t ... Is, typename T>
struct MyArray<std::index_sequence<Is...>, T>
{
    MyArray(always_t<Is, const T&>... v) : /*..*/
};

or used for SFINAE

template <typename T, std::size_t = T::size()>
struct some_sized_type;

Answer 2

What's the point of unnamed/anonymous non-type template parameters?

I can think of specialization:

template<int = 42>
struct Foo{
   char x;
};

template<>
struct Foo<0> {
   int x;
};

template<>
struct Foo<1> {
   long x;
};

Then:

Foo<0> a; // x data member is int
Foo<1> b; // x data member is long
Foo<7> c; // x data member is char
Foo<>  d; // x data member is char

Answer 3

Oh, you can access them!

template <int> struct Foo {};

template <int N>
int get(Foo<N>) {
    return N;
}

int main() {
    Foo<3> foo;
    return get(foo);
}

This might be a bit contrived. But in general for some templates you don't want to name them and then it is convenient that you don't have to.

Answer 4

Unamed type and non-type parameters also allow you to delay type instanciation, using template-template parameters.

Take destination_type in the function below for instance.
It can resolve to any type that has a template-type parameter, and 0 to N template-values parameters.

template <template <typename, auto...> typename destination_type, typename TupleType>
constexpr auto repack(TupleType && tuple_value)
{
    return [&tuple_value]<std::size_t ... indexes>(std::index_sequence<indexes...>) {
        return destination_type{std::get<indexes>(tuple_value)...};
    }(std::make_index_sequence<std::tuple_size_v<TupleType>>{});
}
static_assert(repack<std::array>(std::tuple{1,2,3}) == std::array{1,2,3});

Such mechanic comes handy when you need an abstraction on parameters-pack.

Here, for instance, we do not care if Ts... is a parameter-pack containing multiple arguments, or expand to a single type which itself has multiples template parameters.

-> Which can be transposed from template-type parameters to template-value parameters.

See gcl::mp::type_traits::pack_arguments_as_t

Complete example available on godbolt here.

template <template <typename ...> class T, typename ... Ts>
class pack_arguments_as {
    template <template <typename...> class PackType, typename... PackArgs>
    constexpr static auto impl(PackType<PackArgs...>)
    {
        return T<PackArgs...>{};
    }
    template <typename... PackArgs>
    constexpr static auto impl(PackArgs...)
    {
        return T<PackArgs...>{};
    }
    public:
    using type = decltype(impl(std::declval<Ts>()...));
};
template <template <typename ...> class T, typename ... Ts>
using pack_arguments_as_t = typename pack_arguments_as<T, Ts...>::type;

namespace tests
{
    template <typename... Ts>
    struct pack_type {};

    using toto = pack_arguments_as_t<std::tuple, pack_type<int, double, float>>;
    using titi = pack_arguments_as_t<std::tuple, int, double, float>;

    static_assert(std::is_same_v<toto, titi>);
    static_assert(std::is_same_v<toto, std::tuple<int, double, float>>);
    static_assert(std::is_same_v<pack_type<int, double, float>, pack_arguments_as_t<pack_type, toto>>);
}