How to generalize object creation in C++ using variadic templates? - c++

Question

I am trying to make a generic factory method in C++, that can create an instance of one of many (but finite number of) objects. Each of the objects require different types of parameters to construct so I want the method to somehow infer the desired type and not want to have the user specify it explicitly.
Here's some code to illustrate what I'm trying to do:
#include <iostream>
using namespace std;
class A {
public:
A(int x, int y) {
cout << "A(" << x << ", " << y << ")\n";
}
};
class B {
public:
B(float a, float b) {
cout << "B(" << a << ", " << b << ")\n";
}
};
template<typename T, typename... Ts>
T * Make(Ts... vs) {
puts(__PRETTY_FUNCTION__); // __FUNCSIG__ or __PRETTY_FUNCTION__
return new T{ vs... };
}
Now the code in, say, main function can create objects of type A * and B * by invoking Make like this:
A *a = Make<A>(3, 4);
B *b = Make<B>(3.14f, 6.28f);
Is there a way I can extend this code to enable other functions to call Make without having to explicitly specify whether they want an instance of A * or B * ? For example,
A * a = Make(3, 4); // (int, int)
B * b = Make(3.14f, 6.28f); // (float, float)
I understand function templates get instantiated using argument type deduction and return type is not involved in this. However, the compiler will not do any type conversions. So Make(int, int) is definitely a different instance from Make(float, float) and I want to be able to leverage this to map the function definition to the right return type.
Here's what I tried:
defining an explicit instantiation
template A * Make(int x, int y);
defining a specialization
template<>
A * Make<A, int, int>(int x, int y);
Both didn't work as expected. Any ideas on how this can be achieved ?

Answer 1

I wrote a Maker helper template that registers which classes are allowed, although I don't exactly know how to disable the base template:
template <typename... Ts>
struct Maker {
using type = void;
};
template <>
struct Maker<int, int> {
using type = A;
};
template <>
struct Maker<float, float> {
using type = B;
};
template<typename... Ts, typename T=typename Maker<Ts...>::type>
T * Make(Ts... vs) {
puts(__PRETTY_FUNCTION__); // __FUNCSIG__ or __PRETTY_FUNCTION__
return new T{ vs... };
}
int main() {
A * a = Make(3, 4); // (int, int)
B * b = Make(3.14f, 6.28f); // (float, float)
}

Answer 2

You might give needed information to the factory, set of class to construct, and needed arguments(*).
(*): (Note: if your classes has correct properties, you might even detect constructor's arguments automatically with magic_get.
template <typename ... Sigs> struct Maker : Maker<Sigs>...
{
using Maker<Sigs>::operator ()...;
// Do we want to accept conversions or not in non ambiguous cases ?
//template <typename ... Ts> operator()(Ts/*&&*/...) const = delete;
};
template <class C, typename ... Args> struct Maker<C(Args...)>
{
C operator()(Args... args) const {
puts(__PRETTY_FUNCTION__); // __FUNCSIG__ or __PRETTY_FUNCTION__
return C(std::forward<Args>(args)...); // not {} to avoid initializer_list constructor
}
};
And then the factory instance:
constexpr Maker<A(int, int), B(float, float)> Make{};
With usage:
A a = Make(3, 4); // (int, int)
B b = Make(3.14f, 6.28f); // (float, float)
Demo