Initializer list as a variadic template argument - c++11

Question

I have a couple of classes A, B, and F, all having different constructor signatures, like these:
class A {
public:
A() {}
};
class B {
double x_, y_;
public:
B(double x, double y) : x_(x), y_(y) {}
};
class F {
vector<unsigned> factors_;
public:
F(std::initializer_list<unsigned> factors) : factors_(factors) {}
};
The objects of these classes need to be registered somewhere, so the construction should go through a factory, like this:
template<class R, typename... Args>
inline R & factory(Args &&... args)
{
R * rp = new R(std::forward<Args>(args)...);
/* do fancy stuff with rp... */
return *rp;
}
This works fine for classes A and B, but not for F, because typename... wants to take one or more types:
A & a = factory<A>(); // okay
B & b = factory<B>(0.707107, 0.707107); // okay
F & f = factory<F>({2, 3, 5, 7, 11}); // error: no matching function for call to ‘F::F()’ in factory
Question: Is there any way to make it work with the general factory<R>(args...) syntax?
I tried a full specialization of the factory function for <F, std::initializer_list>, but either messed up the syntax or, when it compiled, wasn't picked up as factory by the compiler.
Any other ideas?

Answer 1

To answer the question: I can't see a simple way of reusing your factory method which takes an initializer_list.
I would personally add a constructor in class F taking a std::vector
F(const std::vector<unsigned>& factors) : factors_(factors) {}
and rewrite a factory method :
template<class R>
inline R & factory(const std::vector<unsigned>& factors)
{
R *rp = new R(factors);
/* do fancy stuff with rp... */
return *rp;
}
Now it compiles fine.
Live code
If you want to avoid code duplication you should consider writing your /* do fancy stuff with rp... */ in another function.
Edit
I don't know what you want to do, but why don't you simply use here :
F f2{2, 3, 5, 7, 11};
You don't need a factory if you just want to populate your class F vector with some values.

Answer 2

It might not be your preferred syntax, but you can force the factory method to pass an initializer list:
F & f = factory<F>(std::initializer_list<unsigned>{2u, 3u, 5u, 7u, 11u});
I explicitly made the literals unsigned here - although they could be coerced by the std::initializer_list<unsigned>, that isn't the case with the following version.
I was able to get it working with an overload of factory():
template<class R>
inline R& do_fancy_stuff_with(R *r)
{
/* do fancy stuff here... */
return *r;
}
template<class R, typename... Args>
inline R & factory(Args &&... args)
{
R * rp = new R(std::forward<Args>(args)...);
return do_fancy_stuff_with(rp);
}
template<class R, typename T>
inline R & factory(std::initializer_list<T> args)
{
R * rp = new R(std::move(args));
return do_fancy_stuff_with(rp);
}
A & a = factory<A>();
B & b = factory<B>(0.707107, 0.707107);
F & f = factory<F>({2u, 3u, 5u, 7u, 11u});
I'm surprised that variadic templates don't play more nicely with initializer lists.