Is it possible to emulate template<auto X>?

c++, templates, type-inference

Solution

After your update: no. There is no such functionality in C++. The closest is macros:

#define AUTO_ARG(x) decltype(x), x

f.bar<AUTO_ARG(5)>();
f.bar<AUTO_ARG(&Baz::bang)>();

Sounds like you want a generator:

template <typename T>
struct foo
{
    foo(const T&) {} // do whatever
};

template <typename T>
foo<T> make_foo(const T& x)
{
    return foo<T>(x);
}

Now instead of spelling out:

foo<int>(5);

You can do:

make_foo(5);

To deduce the argument.

Problem

Is it somehow possible? I want that to enable compile-time passing of arguments. Suppose it's only for user convenience, as one could always type out the real type with `template<class T, T X>`, but for some types, i.e. pointer-to-member-functions, it's pretty tedious, even with `decltype` as a shortcut. Consider the following code: ``` struct Foo{ template<class T, T X> void bar(){ // do something with X, compile-time passed } }; struct Baz{ void bang(){ } }; int main(){ Foo f; f.bar<int,5>(); f.bar<decltype(&Baz::bang),&Baz::bang>(); } ``` Would it be somehow possible to convert it to the following? ``` struct Foo{ template<auto X> void bar(){ // do something with X, compile-time passed } }; struct Baz{ void bang(){ } }; int main(){ Foo f; f.bar<5>(); f.bar<&Baz::bang>(); } ```

Original source