Infer type of non-type template argument

user_2462437 0
Viewed 59

I'm not great at template metaprogramming, so apologies if this is a dumb question.

I have a type like

template<int n>
struct S
{
  typedef decltype(n) type_of_n;

  // ...
};

and I'd like to write functions that look something like

template<
  typename T, 
  typename T::type_of_n n,
  typename = std::enable_if_t<std::is_same<T, S<n>>::value>>
void f(const T &) { /* ... */ }

with the idea being that if the type of the non-type template argument to S changes at some point in the future (say to std::size_t or int64_t or something) then calling code will just continue working. But I'm not sure how to get the compiler to infer both T and n in tandem here.

The only things I've come up with are basically hacks:

  • Do something like typedef int type_of_S_n outside of S.
  • Write something like S<0>::type_of_n instead of actually inferring the type

Is what I'm trying to do possible? If not, is there a "cleaner" way to do it than the hacks above?

template-meta-programming type-inference c++
4 Answers

if the type of the non-type template argument to S changes at some point in the future (say to std::size_t or int64_t or something) then calling code will just continue working.

You can use the placeholder type auto with C++17 as shown below:

template<auto n>  //note the auto here
struct S
{
  typedef decltype(n) type_of_n;

  // ...
};
user_120025700

You can do a traits to know if a type is a S<n>:

template <typename T>
struct is_a_S : std::false_type {};

template <int N>
struct is_a_S<S<N>> : std::true_type {};

Then your SFINAE can be done like that:

template<
  typename T, 
  std::enable_if_t<is_a_S<T>::value, int> = 0>
void f(const T &) { /* ... */ }
user_26845390

C++20 concepts make things easier

#include <concepts>

template<int n>
struct S {
  typedef decltype(n) type_of_n;
};

template<class T>
  requires std::same_as<T, S<typename T::type_of_n{}>>
void f(const T &) { /* ... */ }

Demo

user_116387180

If you are looking to only accepts S and want to also deduce the value of n, then you can since c++17 use auto to deduce the type of a non-type template parameter.

template<auto n>
void f(const S<n> &) { /* ... */ }

You can also make it more generic and accept any type with a single non-type parameter by using a template template parameter.

template<template <auto> typename T, auto n>
void f(const T<n> &) { /* ... */ }
user_77030240
Related