c++ - Is it possible to emulate template<auto X>?

Question

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

Answer 1

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.