Template deduction with smart pointers - c++

Question

My code looks like this:
#include <iostream>
#include <memory>
using namespace std;
class myClass
{
int a;
};
template <typename T, template<typename ValueType> class SmartPtr> // (1)
void myFunction(const void *pointer, SmartPtr<T>& pointer2)
{
cout<<"with template"<<endl;
}
void myFunction(const void *pointer, unique_ptr<myClass>& pointer2)
{
cout<<"without template "<< *(static_cast<const int*>(pointer))<<endl;
}
int main()
{
int* a = new int(5);
unique_ptr<myClass> myUniquePtr(new myClass);
shared_ptr<myClass> mySharedPtr(new myClass);
myFunction(static_cast<const void*>(a), myUniquePtr); // (2)
myFunction<int, unique_ptr<myClass> >(static_cast<const void*>(a), myUniquePtr); // (3)
myFunction<int, shared_ptr<myClass> >(static_cast<const void*>(a), mySharedPtr); // (4)
delete a;
return 0;
}
Calling 'myFunction' in (2) is OK - it calls 'myFunction' without template. But in (3) and (4) compiler can't deduce template arguments. It generates errors:
no matching function for call to ‘myFunction(const void*, std::unique_ptr<myClass>&)'
and
no matching function for call to ‘myFunction(const void*, std::shared_ptr<myClass>&)'
respectively.
The question is how to change the second argument of template in (1) so I can instantiate template with arbitrary smart pointer? I want to omit ValueType and use T.

Answer 1

There is no need to have two template arguments, and this will cause problems for smart pointers that are using a custom allocator. Just have one template argument: the type of smart pointer.
template <typename T>
void myFunction(const void *pointer, T & pointer2)
{
}
So T is the smart pointer type. If you need access to the type of the managed object (myClass in this case) you can use typename std::pointer_traits<T>::element_type.
template <typename T>
void myFunction(const void *pointer, T & pointer2)
{
typedef typename std::pointer_traits<T>::element_type obj_type;
obj_type & o = *pointer2;
}
(Of course if you are using C++11 you could also just use decltype(*pointer2) or even auto.)
With this approach you can even use raw pointers as T, assuming that none of your logic depends on them being smart pointers.
As a side note, your invocation likely fails because you are supplying int as the T template argument, which doesn't make any sense; you should be using myClass there.

Answer 2

We have template <class T, class D = default_delete<T>> class unique_ptr;
So your function template should look like:
template <template<typename, typename> class SmartPtr, typename T, typename D>
void myFunction(const void *pointer, SmartPtr<T, D>& pointer2)
{
std::cout << "with template" << std::endl;
}
but it may be simpler to use something like in cdhowie's answer.

Answer 3

The reason it is complaining is because you are giving it a type as the second template argument, but it expects a template (because you used template-template syntax.) The following should at least get it past the template expansion step of compilation (warning, not compiled, but you should get the idea)
myFunction<int, unique_ptr>(static_cast<const void*>(a), myUniquePtr); // (3)
myFunction<int, shared_ptr>(static_cast<const void*>(a), mySharedPtr); // (4)
But, as others have said, you probably don't need this. Just let template argument deduction happen instead of spelling it out.