C ++ 11 method template specialization for return type

Question

I have the following class:

class Foo { public: template <typename T> T bar() { cout << "Called with return type: " << typeid(T).name() << endl; T t = //... (some implementation here) return t; } } 

It is called as follows:

 Foo foo; int i = foo.bar<int>(); long l = foo.bar<long>(); 

Now I would like to have a different specialization for cases when a function is called using shared_ptr<T>

 Foo foo; foo.bar<shared_ptr<int>>(); foo.bar<shared_ptr<long>>(); 

But, of course, I do not want to create a complete specialization for each type. Is it possible to implement such behavior (if necessary, it can be based on signs)?

Answer 1

Since no one has proposed it yet, you can use SFINAE to distinguish between T and std::shared_ptr<U> :

 template <typename T> struct is_shared_ptr_impl : std::false_type {}; template <typename T> struct is_shared_ptr_impl<std::shared_ptr<T>> : std::true_type {}; template <typename T> using is_shared_ptr = typename is_shared_ptr_impl<typename std::decay<T>::type>::type; class Foo { public: template <typename T> auto bar() -> typename std::enable_if<!is_shared_ptr<T>{}, T>::type { std::cout << "T is " << typeid(T).name() << std::endl; return {}; } template <typename T> auto bar() -> typename std::enable_if<is_shared_ptr<T>{}, T>::type { using U = typename std::decay<T>::type::element_type; std::cout << "T is shared_ptr of " << typeid(U).name() << std::endl; return {}; } }; 

Demo

Answer 2

You cannot partially specialize functions. For a story about why, see GOTW .

You can partially specialize classes, so you can do this:

 template <typename T> T bar() { return bar_impl<T>::apply(this); } 

Where:

 template <typename T> struct bar_impl { static T apply(Foo* ) { // whatever } } template <typename T> struct bar_impl<std::shared_ptr<T>> { static std::shared_ptr<T> apply(Foo* ) { // whatever else } } 

Answer 3

Of course, there are many ways to do this. The first way that comes to my mind is simply overloading the functions. Since you do not have a parameter for overloading, you will have to create it. I like pointers that act effectively as a way to pass types to functions.

 class Foo { //regular overload template<typename T> T bar(T*) { //takes a pointer with an NULL value cout << "Called with return type: " << typeid(T).name() << endl; T t = //... (some implementation here) return t; } //shared_ptr overload - NOTE THAT T IS THE POINTEE, NOT THE SHARED_PTR template<typename T> std::shared_ptr<T> bar(std::shared_ptr<T>*) { //takes a pointer with an null value cout << "Called with return type: " << typeid(T).name() << endl; std::shared_ptr<T> t = //... (some implementation here) return t; } public: template <typename T> T bar() { T* overloadable_pointer = 0; return bar(overloadable_pointer); } }; 

I have never heard anyone else use pointers to pass types, so if you decide to do this, comment it out completely to be safe. This is a weird code.

It may be more intuitive to simply use an auxiliary structure to specialize templates, which most people will do. Unfortunately, if you need access to Foo members (which you presumably do), using template specialization will require that you pass all of these members to a function or to a friend template helpers. Alternatively, you can pass the type_traits specialization to another member, but that ends with just the complicated version of the pointer trick above. Many people find this more normal and less confusing, so here's what:

 template<typename T> struct Foo_tag {}; class Foo { //regular overload template<typename T> T bar(Foo_tag<T>) { } //shared_ptr overload - NOTE THAT T IS THE POINTEE, NOT THE SHARED_PTR template<typename T> std::shared_ptr<T> bar(Foo_tag<std::shared_ptr<T>>) { } public: template <typename T> T bar() { return bar(Foo_tag<T>{}); } }