Шаблоны шаблонов шаблонами

template <template <typename, typename> class Ptr, typename T>
void foo(Ptr<A, T>& ptr)
{
}

template <template <typename, typename> class Ptr>
void foo(Ptr<A, std::default_delete<A> >& ptr)
{
}

template <template <typename> class Ptr>
void foo(Ptr<A>& ptr)
{
}


int main() {
    std::unique_ptr<A> ptr(new A);

    foo(ptr);
}

template<class T>
auto f (T& ptr) -> std::enable_if<std::is_same<decltype(*ptr), A&>::value>::type
{
}

#include <memory>
#include <type_traits>

template <typename Arg, typename T>
struct is_smart_pointer_of : std::false_type {};

template <typename A, typename B>
struct is_smart_pointer_of<std::unique_ptr<A, B>, A> : std::true_type {};

template <typename A>
struct is_smart_pointer_of<std::shared_ptr<A>, A> : std::true_type {};

template <typename A>
struct is_smart_pointer_of<std::weak_ptr<A>, A> : std::true_type {};

class A {
public:
};

class B {
public:
};

template <typename T>
void foo(T& ptr) {
	static_assert(is_smart_pointer_of<T, A>::value, "ptr should be a smart pointer of given type");
}
 
int main() {
	std::unique_ptr<A> a(new A);
	std::shared_ptr<A> b(new A);
	
	A* c = new A();
	
	std::shared_ptr<B> d(new B);

	foo(a);
	foo(b);
//	foo(c);
//	foo(d);
}

#include <memory>

class A {
public:
};

template <template <typename, typename...> class Ptr, typename... D>
void foo(Ptr<A, D...>& ptr)
{
}
 
int main() {
    std::shared_ptr<A> ptr(new A);
    
    foo(ptr);
}