GCC称将功能与多个继承过载时，称其为模棱两可，但Clang和MSVC没有

When overloading a function with multiple inheritance, GCC says calling it is ambiguous, but Clang and MSVC do not

本文关键字：模棱两可 没有 MSVC Clang 功能 GCC 继承      更新时间：2023-10-16

我正在使用此变体库：https：//github.com/cbeck88/strict-variant。它提供了类似于std::variant和boost::variant的类。给定此struct：

struct S
{
    explicit S(double) {}
};

我想这样做：

strict_variant::variant<double, S> v = 2.0;

这与Clang 5.0.1和MSVC 19.12.25831.00一起使用，但无法与GCC 7.2.1进行编译。

我查看了库的代码，并将问题减少了：

#include <iostream>
struct S
{
    constexpr S() {}
    constexpr explicit S(double) {}
};
template<unsigned i> struct init_helper;
template<> struct init_helper<0> { using type = double; };
template<> struct init_helper<1> { using type = S; };
template<unsigned i>
struct initializer_leaf
{
    using target_type = typename init_helper<i>::type;
    constexpr unsigned operator()(target_type) const
    {
        return i;
    }
};
struct initializer : initializer_leaf<0>, initializer_leaf<1>
{
};
int main()
{
    std::cout << initializer()(double{}) << " = double" << 'n';
    std::cout << initializer()(S{}) << " = S" << 'n';
    return 0;
}

输出为

0 = double
1 = S

GCC说：

strict_variant_test.cpp: In function ‘int main()’:
strict_variant_test.cpp:29:37: error: request for member ‘operator()’ is ambiguous
  std::cout << initializer()(double{}) << " = double" << 'n';
                                     ^
strict_variant_test.cpp:17:21: note: candidates are: constexpr unsigned int initializer_leaf<i>::operator()(initializer_leaf<i>::target_type) const [with unsigned int i = 1; initializer_leaf<i>::target_type = S]
  constexpr unsigned operator()(target_type) const
                     ^~~~~~~~
strict_variant_test.cpp:17:21: note:                 constexpr unsigned int initializer_leaf<i>::operator()(initializer_leaf<i>::target_type) const [with unsigned int i = 0; initializer_leaf<i>::target_type = double]
strict_variant_test.cpp:30:32: error: request for member ‘operator()’ is ambiguous
  std::cout << initializer()(S{}) << " = S" << 'n';
                                ^
strict_variant_test.cpp:17:21: note: candidates are: constexpr unsigned int initializer_leaf<i>::operator()(initializer_leaf<i>::target_type) const [with unsigned int i = 1; initializer_leaf<i>::target_type = S]
  constexpr unsigned operator()(target_type) const
                     ^~~~~~~~
strict_variant_test.cpp:17:21: note:                 constexpr unsigned int initializer_leaf<i>::operator()(initializer_leaf<i>::target_type) const [with unsigned int i = 0; initializer_leaf<i>::target_type = double]

但是，当我将initializer的定义更改为：

struct initializer
{
    constexpr unsigned operator()(double) const
    {
        return 0;
    }
    constexpr unsigned operator()(S) const
    {
        return 1;
    }
};

我对C 的理解说这是同等的，所以我认为这是GCC中的一个错误，但是我经常遇到问题，标准表现出令人惊讶的事情而我的假设是错误的。所以，我的问题是：这是谁的错？GCC是否有错误？如果代码是错误的，如何修复？

这实际上是一个clang bug。

经验法则是，不同的范围中的名称不超载。这是一个简化的例子：

template <typename T>
class Base {
public:
    void foo(T ) { }
};
template <typename... Ts>
struct Derived: Base<Ts>...
{};
int main()
{
    Derived<int, double>().foo(0); // error
}

这应该是一个错误，因为类成员查找规则状态基本上只有一个基类可以包含一个给定的名称。如果多个基类具有相同的名称，则查找是模棱两可的。这里的分辨率是将两个 base类名称带入衍生的类中，并使用使用量表。在C 17中，使用声明可以是包装扩展，这使此问题变得更加容易：

template <typename T>
class Base {
public:
    void foo(T ) { }
};
template <typename... Ts>
struct Derived: Base<Ts>...
{
    using Base<Ts>::foo...;
};
int main()
{
    Derived<int, double>().foo(0); // ok! calls Base<int>::foo
}

对于特定库，此代码：

template <typename T, unsigned... us>
  struct initializer_base<T, mpl::ulist<us...>> : initializer_leaf<T, us>... {
      static_assert(sizeof...(us) > 0, "All value types were inelligible!");
  };

应该看起来像：

template <typename T, unsigned... us>
struct initializer_base<T, mpl::ulist<us...>> : initializer_leaf<T, us>... {
    static_assert(sizeof...(us) > 0, "All value types were inelligible!");
    using initializer_leaf<T, us>::operator()...; // (*) <==
};

（尽管我猜图书馆的目标是C 11，所以我提交了C 11符合条件的修复程序...这只是更多的冗长）。

相关文章：