另一个解决方案是稍微放松一下test（）模板函数的要求。
例如：

#include <iostream>
#include <string>

template<typename ...> class Foo;

template<typename T>
class Foo<T>{
public:
    void foo() const {
        std::cout << "foo (1)\n";
    }
};

template<typename T, typename ... Tail>
class Foo<T, Tail...> : public Foo<Tail...>  {
public:
    void foo() {
        std::cout << "foo (2)\n" ;
    }
};

class Bar : public Foo<std::string, int> {
public:
    template<typename T>
    void test(T&& f) {  // more relaxed requirements as temporary fix
        f.foo();        // until upgrade to newer compiler.
    }
};

class Baz : public Foo<int, std::string> {
public:
    template<typename T>
    void test(T&& f) {
        f.foo();
    }
};

class Buzz : public Foo<int>
{
    template<typename T>
    void test(T&& f) {
        f.foo();
    }
};

int main() {
    Bar a;
    Bar b;
    a.test(b);

    Bar c;
    Baz d;
    c.test(d);   

    Buzz e;
    c.test(e);
    
    return 0;
}

输出：

foo (2)
foo (2)
foo (1)

这是GCC和Clang的一个可能的解决方法：为方便起见，我在派生的base* 类中插入了一个类型别名，这样您就可以在两种情况下使用相同的语法调用test。

#include <iostream>
#include <string>

template<typename ...> class Foo;

template<typename T>
class Foo<T>{
public:
    void foo() {
        std::cout << "foo (1)\n";
    }
    using footype = Foo<T>;
};

template<typename T, typename ... Tail>
class Foo<T, Tail...> : public Foo<Tail...>  {
public:
    void foo() {
        std::cout << "foo (2)\n" ;
    }
    using footype = Foo<T, Tail...>;
};

class Bar : public Foo<std::string, int> {
public:
    template<typename ...Args>
    void test(Foo<Args...> f) {
        f.foo();
    }
};

class Baz : public Foo<int, std::string> {
public:
    template<typename ...Args>
    void test(Foo<Args...> f) {
        f.foo();
    }
};

int main() {
    Bar a;
    Bar b;
    a.test(static_cast<decltype(b)::footype>(b));

    Bar c;
    Baz d;
    c.test(static_cast<decltype(d)::footype>(d));   
    
    return 0;
}

用gcc 9.1和clang 9在goldbolt上检查它。

• 评论后编辑。

代码是有效的，而且显然不会模糊到在使用最新的gcc编译器编译时失败。在使用较旧的编译器时，可以使用static_cast〈〉来更显式。
例如：

#include <iostream>
#include <string>

template<typename ...> class Foo;

template<typename T>
class Foo<T>{
public:
    void foo() const {
        std::cout << "foo (1)\n";
    }
};

template<typename T, typename ... Tail>
class Foo<T, Tail...> : public Foo<Tail...>  {
public:
    void foo() {
        std::cout << "foo (2)\n" ;
    }
};

class Bar : public Foo<std::string, int> {
public:
    template<typename ...Args>
    void test(Foo<Args...> f) {
        f.foo();
    }
};

class Baz : public Foo<int, std::string> {
public:
    template<typename ...Args>
    void test(Foo<Args...> f) {
        f.foo();
    }
};

int main() {
    Bar a;
    Bar b;
    a.test(static_cast<Foo<std::string, int>>(b));

    Bar c;
    Baz d;
    c.test(static_cast<Foo<int, std::string>>(d));   
    
    return 0;
}

你可以在这里找到代码：https://godbolt.org/z/YjPqaKdbj