Ambiguous overload accessing argument-less template functions with variadic parameters

Question

Yeah, the title can scare babies, but it's actually quite straightforward.

I am trying to store a function pointer to a specialized template function, namely boost::make_shared (boost 1.41), as illustrated:

boost::shared_ptr<int> (*pt2Function)() = boost::make_shared<int>;

However, it won't compile (GCC 4.4.1) due to the fact that boost::make_shared has the following two specializations which the compiler can't tell apart in this context:

template< class T > boost::shared_ptr< T > make_shared()
...
template< class T, class... Args > boost::shared_ptr< T > make_shared( Args && ... args )

The error, for reference:

In function ‘int main()’:
error: converting overloaded function ‘make_shared’ to type ‘class boost::shared_ptr<int> (*)()’ is ambiguous
boost/smart_ptr/make_shared.hpp:100: error: candidates are: boost::shared_ptr<X> boost::make_shared() [with T = int]
boost/smart_ptr/make_shared.hpp:138: error:                 boost::shared_ptr<X> boost::make_shared(Args&& ...) [with T = int, Args = ]

If I comment out the non-variadic variation, the code compiles fine.

Does anyone know the proper syntax for resolving the ambiguity between two argument-less functions like this?

Answer 1

Variadic template arguments mean you take 0..n template arguments, thus both your versions are matches.
You could resolve the ambiguity by adding another template parameter to the second version, so that it takes 1..n arguments.
Something like this should work:

template< class T, class Arg1, class... Args > 
boost::shared_ptr< T > make_shared(Arg1&& arg1, Args && ... args )

But as UncleBens correctly pointed out, you don't even need two versions. The following should be enough in your case:

template< class T, class... Args > 
boost::shared_ptr<T> make_shared(Args && ... args );

If you use only one template argument (i.e. T), you get the 0-argument version of make_shared().