派生递归模板类遇‘ambiguous base class’错误：原因、合法性及兼容方案

问题背景 #

以下C++代码在GCC 9.1、Clang 9.0中编译失败，但在GCC 12.1、Clang 12.0等新版本编译器中可正常运行：

#include <iostream>
#include <string>

template<typename ...> class Foo;

template<typename T>
class Foo<T>{
public:
    void foo() {
        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(b);

    Bar c;
    Baz d;
    c.test(d);   
    
    return 0;
}

编译器测试结果：

• GCC 9.1 -> 编译失败（NOK）
• Clang 9.0 -> 编译失败（NOK）
• GCC 12.1 -> 编译通过（OK）
• Clang 12.0 -> 编译通过（OK）

代码是否符合C++标准？ #

这段代码完全符合C++标准，新版编译器的行为是正确的，旧版编译器存在标准实现缺陷。

歧义原因分析 #

旧版编译器在处理模板参数包展开的继承结构时，错误触发了“ambiguous base class”歧义错误。具体来说：
Foo<T, Tail...>继承自Foo<Tail...>，形成一层套一层的继承链。当test()函数接收Bar（即Foo<std::string, int>）或Baz（即Foo<int, std::string>）类型的参数时，旧版编译器无法正确识别最派生类的foo()函数，反而错误认为继承链中所有基类的foo()都参与重载解析，导致名称查找出现歧义。

这是因为旧版编译器对C++标准中依赖名称查找和最派生类优先调用的规则实现不完整，没有正确处理模板继承下的成员函数名称解析逻辑。

旧版GCC和Clang兼容解决方案 #

方案1：显式限定调用最派生类的foo() #

在test()函数中，通过类名限定明确指定调用最派生类的foo()，避免编译器查找基类的同名函数：

template<typename ...Args>
void test(Foo<Args...> f) {
    f.Foo<Args...>::foo(); // 显式限定调用当前实例的foo
}

方案2：用final修饰foo()函数 #

给Foo类的foo()函数添加final关键字（C++11及以上支持），禁止基类的foo()被重载或覆盖，从根源上消除歧义：

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

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

方案3：调整继承结构为CRTP模式 #

使用奇异递归模板模式（CRTP）重新设计Foo类，让每个派生类明确关联到自身的继承层次，帮助编译器正确解析名称：

#include <iostream>
#include <string>

template<typename Derived, typename ...> class Foo;

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

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

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

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

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

    Bar c;
    Baz d;
    c.test(d);   
    
    return 0;
}

内容的提问来源于stack exchange，提问作者Delgan