c++ - 解决嵌套模板参数函数的基类歧义

Question

我有类 foo_impl、bar_impl 派生自派生类 foo_derived、bar_derived 和一个接受模板模板参数的函数：

#include <iostream>
template <typename T>
struct foo_base
{
    T a;
};

template <typename T>
struct foo_derived: public foo_base<T>
{

};

struct foo_impl: public foo_derived<int>
{

};

template <typename T>
struct bar_base
{
    T a;
};

template <typename T>
struct bar_derived : public bar_base<T>
{
};

struct bar_impl : public bar_derived<int>
{
};

template <typename T, template <class> typename Base>
void useBase(const Base<T>& Arg)
{
    std::cout << Arg.a << std::endl;
}

int main()

{
    foo_impl foo;
    bar_impl bar;

    useBase(foo); // ‘const Base<T>’ is an ambiguous base class of ‘foo_impl’
    useBase(bar); // ‘const Base<T>’ is an ambiguous base class of ‘bar_impl’
}

是否可以指定我希望 foo_base 和 bar_base 是唯一可以传递给 useBase(.) 的类型？

编辑：我尝试引入一个概念以限制接受的类型，但编译器仍然不满意。

template <typename T, template <class> typename Base>
concept is_base = !std::is_same<std::is_same<Base<T>, foo_base<T>>, std::is_same<Base<T>, bar_base<T>>>::value;

template <typename T, template <class> typename Base>
void useBase(const Base<T>& Arg) requires is_base<T, Base>
{
    std::cout << Arg.a << std::endl;
}

标签： c++templatesinheritanceambiguous

Answer 1

正如评论中所述，重载可能是一种可能性：

template <typename T, template <class> typename Base>
void useBaseImpl(const Base<T>& Arg)
{
    std::cout << Arg.a << std::endl;
}

template <typename T>
void useBase(const foo_base<T>& arg)
{
    useBaseImpl(arg);
}

template <typename T>
void useBase(const bar_base<T>& arg)
{
    useBaseImpl(arg);
}