Require return type of function template to be specialization of a template

Question

I've poked around on stackoverflow for a while, but either I don't understand templates enough to find a solution, or it simply hasn't been answered before.

In this example:

template <typename T> T f();

Is it possible to make the function require type T to be a specialization of the std::basic_string template?

I could have the template defined with T as the type of the std::basic_string as so (using std::basic_string<T> internally, of course):

template <typename T> std::basic_string<T> f();

But then I would not be able to pass std::string or std::wstring to the function (expecting the return type to be std::string and std::wstring, respectively), which is the real aim here (to be able to pass any type which derives from the std::basic_string template).

Answer 1

This is not possible in vanilla C++. There was a language construct proposed for C++0x that would allow for this, unfortunately it was dropped.

You can do this to a certain degree with the Boost Concept Check Library, however: http://www.boost.org/doc/libs/1_44_0/libs/concept_check/concept_check.htm

Answer 2

Instead of requiring that T be a specialization of std::basic_string, why not just assume that T is a specialization of std::basic_string and let template instantiation fail if it isn't. Just use the things from std::basic_string that you need.

For example,

template <typename T>
T get_first_three_chars(const T& str) { return str.substr(0, 3); }

Here, we assume that T has a member function substr; if it doesn't, then instantiation will fail, resulting in a compilation error.

Answer 3

Partial specialization allows you to test whether a type is a specialization of a particular template. SFINAE is a trick that can "switch off" a function template declaration. The solution combines these techniques.

template< typename T > // by default,
struct enable_if_basic_string {}; // a type is not a basic_string

template< typename CharT, typename Traits >
struct enable_if_basic_string< basic_string< CharT, Traits > > {
    typedef basic_string< CharT, Traits > type; // same as argument type
};

// enable_if_basic_string<>::type exists only if T specializes basic_string
// if not, compiler ignores function declaration per SFINAE.
template< typename T >
typename enable_if_basic_string< T >::type
F() {
    .....
}

If you mean derivation as well as specialization, you might take a look at std::tr1::is_convertible and enable_if as well.