如何模板化C ++构造函数以实现完美转发

Question

I know how to create a global function that forwards arguments to class ctor using variadic templates (its similar to make_shared<> for shared_ptr template class):

template<typename T, typename... Args>
T Create (Args&&... args)
{
  return T(args...);  // RVO takes place here
}

Is it possible to use similar approach to create template for static factory method inside the class? I want to use similar variadic templates syntax to forward all arguments combinations to all possible constructors (I'd like to NOT overload or explicitly link all possible ctors to static methods and just use the templates & compiler to do this work) ie in pseudocode (!)

class Class {
public: 
static Class create(Args&&... args) 
{
     Class(args...);
}
Class(int) {} // ctor 1
Class(int, float) {} // ctor 2 
//... etc

to have similar forwarding of arguments

If I use variadic template directly it looks like this

template <typename... Args>
class Class {
public:
    static Class create(Args&&... args)
    {
        return Class(args...);
    }
    Class(int) {} // ctor 1
    Class(int, float) {} // ctor 2
};

but it gives ugly usage syntax, where I need explicitly provide types to the template...

int main()
{
    Class<int,float> a = Class<int,float>::create(1,2);
}

Can it be just like this ??

Class a = Class::create(1,2);

Answer 1

Just make the create function a template rather than the class:

class Class {
public:
    template <typename... Args>
    static Class create(Args&&... args)
    {
         //actually do perfect forwarding
        return Class(std::forward<Args>(args)...);
    }
    Class(int) {} // ctor 1
    Class(int, float) {} // ctor 2
};

Live Demo

Answer 2

Can it be just like this ??

Class a = Class::create(1,2);

No, function templates can deduce their arguments, but you wrote Class as a class template and you cannot deduce template arguments for class templates.

You cannot just say Class without saying which specialization of Class you mean, and you cannot create a variable of type Class , because Class is not a type, it's a template, ie a family of possible types.

You can create a free function to do it though:

template<typename... Args>
  inline
  Class<typename std::decay<Args>::type...>
  create_Class(ARgs&&... args)
  {
    return Class<typename std::decay<Args>::type...>{ std::forward<Args>(args)... };
  }

NB I added perfect forwarding, which you mentioned in your question title but failed to use anywhere.

Now you can do:

auto a = create_Class(1, 2);

This will create a Class<int, int> object.

But maybe you didn't want to make Class a template in the first place?