C ++将constexpr函数的参数用作模板的常量

Question

Since C++ does not allow template class with a value parameter template of "auto" type (you can template<int N> , or template <EnumFoo E> , but you cannot really match both), I wanted to write a wrapper for a type+value.

The real problem is, no one wants to write both value and its type, and I tried to write a function a bit similar with make_unique , except that creating a std::unique object, it was supposed to have a return type being the wrapper.

Here is what I wrote:

enum class E1
{
  First
};

enum class E2
{
  First
};

/*
 * Here, the goal is to be able to have a ClassTemplatedOnAnyValueNoMatterType
 * you can template on E1::First, or E2::First, and the template instances
 * are NOT the same one.
 * We need a wrapper (EnumValueWrapper).
*/
template <typename T>
struct ClassTemplatedOnAnyValueNoMatterType
{};

template <typename T, T Value>
struct EnumValueWrapper
{
  static const T value = Value;
};

/*
 * Since it's annoying to write EnumValueWrapper<E1, E1::First>, we'd like to
 * have a utility function that generates the EnumValueWrapper type.
*/
template <typename T>
// does NOT compile, t outside of function body
constexpr auto makeEnumValueWrapper(const T t) -> EnumValueWrapper<T, t>;

typedef ClassTemplatedOnAnyValueNoMatterType<decltype(makeEnumValueWrapper(E1::First))> MyClass;

int main()
{
  MyClass s;
}

This does not compile, and I'd like to know if there are any alternatives, using as few macros as possible (no MACRO(E1, First) , since I'd like to be able to use not only litterals, and would like to be able to use int type too).

Got any ideas to do that?

Answer 1

Wait for a later iteration of C++.

Proposals to allow type parameters to depend on the type of value parameters have been proposed. As yet, none have managed to pass muster.

If waiting doesn't sound like a good idea, dive into the standardization process and add it to C++ yourself.

Until then, continue to pass the type of your template constants into the template .

Answer 2

I know you don't like macros, but a very simple solution is:

#define WRAP_VALUE(...) EnumValueWrapper<decltype(__VA_ARGS__), (__VA_ARGS__)>

typedef ClassTemplatedOnAnyValueNoMatterType<WRAP_VALUE(E1::First)> MyClass;

I don't believe it's possible to do it without boilerplate without macros. My reasoning is that if you don't use a macro, you can only use your "value" expression once - either as a function argument, a template parameter, or as part of decltype. And neither alone is useful. If you use it as a function argument, you can't retrieve its value as a constant expression. You can't use it as a template parameter in the first place, since there is no way to declare a template parameter that will accept a value of arbitrary type - not without another template parameter representing that type. And finally, if you use it within decltype(), the value will be lost.

The macro is using __VA_ARGS__ instead of a single argument so that you can use commas within the expression. For example, when invoked as WRAP_VALUE(std::is_same<float, bool>::value) , the preprocessor would otherwise complain that the macro is called with two arguments.

Answer 3

wouldn't this work for your problem:

template <typename T>
struct Dummy
{
    template <T t>
    friend EnumValueWrapper<T, t> makeEnumValueWrapper();
};
template struct Dummy<E1>;
typedef ClassTemplatedOnAnyValueNoMatterType<decltype(makeEnumValueWrapper<E1::First>())> MyClass;

you still need the explicit instantiation of the Dummy on each of the relevant classes, but the typedef for MyClass is free of redundant type/value specification.