I'm trying to use template specialization and enable_if / type_traits to correctly allocate memory for different types, where the template parameter will be one of: 1. boost::intrusive_ptr<U> // create U on the heap, return intrusive_ptr 2. boost::shared_ptr<U> // create U on the heap, return shared_ptr 3. U* // create U on the heap, return raw pointer 4. U // create U on the stack I'm pretty sure I'm just doing something stupid, but I'm getting ambiguous conflicts between my template for types of U and the smart pointer types. Please can you comment on how to fix the code below? TIA Steve #include #include #include #include #include <iostream> template struct alloc; template<typename U> struct alloc::type > { U operator()() { std::cout << __LINE__ << std::endl; return U(); } }; //----------------------------------------------------- template<typename U> struct alloc::type > { U operator()() { std::cout << __LINE__ << std::endl; return new U; } }; //----------------------------------------------------- template< typename U > struct alloc< boost::intrusive_ptr<U> > { boost::intrusive_ptr<U> operator()() { std::cout << __LINE__ << std::endl; return boost::intrusive_ptr<U>(new U); } }; //----------------------------------------------------- template<typename U > struct alloc< boost::shared_ptr<U> > { boost::shared_ptr<U> operator()() { std::cout << __LINE__ << std::endl; return boost::shared_ptr<U>(new U); } }; //----------------------------------------------------- template<typename T> struct test { alloc<T> create; T fun() { return create(); } }; struct foo { uint32_t refs; foo() : refs() { std::cout << "foo" << std::endl; } }; inline void intrusive_ptr_add_ref(foo* p) { ++p->refs; } inline void intrusive_ptr_release(foo* p) { if (!--p->refs) delete p; } int main() { test a; int* p = a.fun(); *p = 5; test<int> b; int d = b.fun(); d = 5; test< boost::intrusive_ptr<foo> > c; boost::intrusive_ptr<foo> z = c.fun(); z.get(); test< boost::shared_ptr<int> > gd; boost::shared_ptr<int> x = gd.fun(); x.get(); return 0; }