C++ templates: Specialized member function to resolve case of ambiguous overload in primary template

Question

I have a template where a function is overloaded so it can handle both an std::string parameter and the type of parameter that the template gets instantiated with. This works fine except when the template is being instantiated with std::string, since this results in two member functions with the same prototype. Thus, I have chosen to specialize that function for this particular case. However, it seems like the compiler (g++ 4.8.1 with flag -std=c++0x) never gets to the point where the specialization is actually overriding the primary template and it complains about the ambiguous overload the before it seems to realize that it should use the specialization. Is there a way to get around this?

#include <iostream>

template<class T>
struct A {
    std::string foo(std::string s) { return "ptemplate: foo_string"; }
    std::string foo(T e) { return "ptemplate: foo_T"; }
};

template<> //Error!
std::string A<std::string>::foo(std::string s) { return "stemplate: foo_string"; }

int main() {
    A<int> a; //Ok!
    std::cout << a.foo(10) << std::endl; 
    std::cout << a.foo("10") << std::endl;

    //A<std::string> b; //Error!
    //std::cout << a.foo("10") << std::endl;
    return 0;
}

This results in compile errors, even if I don't instantiate at all with std::string (it seems that the compiler instantiates with std::string as soon as it sees the specialization and that it, before it actually processes the specialization, complains about the ambiguous overload which the specialization, in turn, will "disambiguate").

Compiler output:

p.cpp: In instantiation of 'struct A<std::basic_string<char> >':
p.cpp:10:27:   required from here
p.cpp:6:14: error: 'std::string A<T>::foo(T) [with T = std::basic_string<char>; std::string = std::basic_string<char>]' cannot be overloaded
  std::string foo(T e) { return "ptemplate: foo_T"; }
              ^
p.cpp:5:14: error: with 'std::string A<T>::foo(std::string) [with T = std::basic_string<char>; std::string = std::basic_string<char>]'
  std::string foo(std::string s) { return "ptemplate: foo_string"; }
              ^

I would like it to just skip through the implementation of foo() in the primary template and use the specialization without considering the primary template foo(). Could it be done somehow, maybe with non-type template parameters, or do I have to make a fully specialized class template for std::string with all the code duplication it implies (I prefer not to use inheritance here)... Other suggestions?

Answer 1

When you specilize your member function you still get the double ambiguous declaration. Waht you need is to specialize the struct template:

template<>
struct A<std::string> {
    std::string foo(std::string s) { return "ptemplate: foo_string"; }
};

If there are many members to the A struct maybe you can refactor:

template<typename T>
struct Afoo
{
    std::string foo(T s) { ... }
    std::string foo(std::string s) { ... }
};
template<>
struct Afoo<std::string>
{
    std::string foo(std::string s) { ... }
};
template<typename T>
struct A : Afoo<T>
{
    //a lot of code
};

Answer 2

I'm going to answer this myself since I've been diving deep into this subject today and I think these solutions are nice. All other posts up to this point have been contributive and have had attractive details with potential in other situations. However, I preferred to do it with these things in mind:

• Avoid the use of more than one class template
• Avoid too complicated specializations as far as possible
• Avoid using inheritance and refactor into base and derived classes
• Avoid the use of extra wrappers

Please feel free to comment before I accept it as my answer.

Another good and inspiring post on the subject focusing on the use of member function overloading rather than specializations can be found at explicit specialization of template class member function

Solution 1

template<class T>
struct A {
    template<class V = T> std::string foo(T) { return "foo_T"; }
    std::string foo(std::string) { return "foo_std::string"; }
    std::string foo(const char *) { return "foo_const char *"; }
};

template<> template<> 
std::string A<std::string>::foo(std::string s) { return foo(s); }

I think this is a dense and understandable solution allowing all class instantiations to use foo(std::string) and foo(const char *) (for passing a string as an rvalue). The use of a dummy template parameter effectively stops class instantiations with std::string from resulting in ambiguous overloads at the same time as the actual template argument hinders uncontrolled function instantiations with unpredictable function arguments. The only problem might come from a class instantiation with std::string that might use the template instead of the regular member function if explicitly called with foo<std::string>(std::string) in which way I would want the class to use the regular foo(std::string) instead of the function template for other instantiations. This is resolved by using a single template specialization.

Solution 2

template<class T>
struct A {
        template<class V> std::string foo(V s) { return foo_private(s); } 

    private:
        template<class V = T> std::string foo_private(T) { return "foo_T"; }
        std::string foo_private(const char *) { return "foo_const char *"; }
        std::string foo_private(std::string) { return "foo_std::string"; }
};

This version allows us to skip the specialization to the benefit of a second template in the class declaration.

Both versions used with:

int main() {
    A<int> a;
    std::cout << a.foo(10) << std::endl; 
    std::cout << a.foo("10") << std::endl;

    A<std::string> b;
    std::cout << b.foo<std::string>("10") << std::endl;
    std::cout << b.foo("10") << std::endl;

    return 0;
}

... outputted:

foo_T
foo_const char *
foo_const char *
foo_std::string

Answer 3

The error is saying that you ended up creating two method with the same signature. That is because the struct has been templated with a std::string as parameter.

You should made the function as a templated function, using its own template parameters 'K' not related to the structure template parameter 'T'. Then you can achieve template specialization for the function only.

Answer 4

I admit that the solution I offer below, is a hacky solution indeed, but it does accomplish what you're trying to do and it's kinda funny. Please consider it thoroughly before you use this ;-)

I work around the issue by creating a new type, called FakeType, which can be constructed from your template-type T. The second overload of foo is now for FakeType<T> instead of T, so even when T == string there will be two different overloads:

template <typename T>
struct FakeType
{
    T t;
    FakeType(T const &t_): t(t_) {}
    operator T() { return t; }
};

template <typename T>
struct A
{
    string foo(string s) { return "ptemplate: foo_string"; }
    string foo(FakeType<T> e) { return "ptemplate: foo_T"; }
};

For the case that T != string:

A<int>().foo("string"); // will call foo(string s)
A<int>().foo(1); // will call foo(FakeType<int> e)

In the latter case, the int will be promoted to a FakeType<int>, which can be used as a regular int through the conversion operator.

For the case that T == string:

A<string>().foo("string"); // will still call foo(string s)

Because the compiler will always prefer an overload for which no promotion is necessary.

PS. This approach assumes that foo is going to get its arguments either by value, or by const-reference. It will break as soon as you try to pass by reference (this can be fixed).