使用模板转换运算符解决歧义

Question

我不得不做一个类似的代码：

#include <type_traits>

template<typename S>
struct probe {
    template<typename T, typename U = S, std::enable_if_t<
        std::is_same<T&, U>::value &&
        !std::is_const<T>::value, int> = 0>
    operator T& () const;

    template<typename T, typename U = S&&, std::enable_if_t<
        std::is_same<T&&, U>::value &&
        !std::is_const<T>::value, int> = 0>
    operator T&& ();

    template<typename T, typename U = S, std::enable_if_t<
        std::is_same<T const&, U>::value, int> = 0>
    operator T const& () const;

    template<typename T, typename U = S&&, std::enable_if_t<
        std::is_same<T const&&, U>::value, int> = 0>
    operator T const&& () const;
};

struct some_type {};
struct other_type {};

auto test_call(some_type const&, other_type) -> std::false_type;
auto test_call(some_type&, other_type) -> std::true_type;

int main() {
    static_assert(decltype(test_call(probe<some_type&>{}, other_type{}))::value, "");
}

它可以在 GCC 和 Clang 下运行，但无法在 visual studio 上编译，并出现解析错误。哪个编译器错误，为什么？

GCC and Clang, Visual studio

这是 msvc 输出：

source_file.cpp(31): error C2668: 'test_call': ambiguous call to overloaded function
source_file.cpp(28): note: could be 'std::true_type test_call(some_type &,other_type)'
source_file.cpp(27): note: or       'std::false_type test_call(const some_type &,other_type)'
source_file.cpp(31): note: while trying to match the argument list '(probe<some_type &>, other_type)'
source_file.cpp(31): error C2651: 'unknown-type': left of '::' must be a class, struct or union
source_file.cpp(31): error C2062: type 'unknown-type' unexpected

Answer 1

代码可以简化为the following:

#include <type_traits>

struct some_type {};

struct probe {
    template<typename T, std::enable_if_t<!std::is_const<T>::value, int> = 0>
    operator T& () const;
};

auto test_call(some_type const&) -> std::false_type;
auto test_call(some_type&) -> std::true_type;

int main() {
    static_assert(decltype(test_call(probe{}))::value, "");
}

根据[temp.deduct.conv]/5 & 6:

In general, the deduction process attempts to find template argument values that will make the deduced A identical to A. However, there are four cases that allow a difference:

If the original A is a reference type, A can be more cv-qualified than the deduced A (i.e., the type referred to by the reference)

...

These alternatives are considered only if type deduction would otherwise fail. If they yield more than one possible deduced A, the type deduction fails.

对于两个函数调用，

T 被推断为 some_type。然后根据[over.ics.rank]/3.3:

User-defined conversion sequence U1 is a better conversion sequence than another user-defined conversion sequence U2 if they contain the same user-defined conversion function or constructor or they initialize the same class in an aggregate initialization and in either case the second standard conversion sequence of U1 is better than the second standard conversion sequence of U2.

probe -> some_type& -> some_type&优于probe -> some_type& -> const some_type&，所以没有歧义，GCC和Clang是对的。

顺便说一句，如果我们删除上面代码中的 std::enable_if_t<...> 部分，MSVC 和 GCC 在 Clang 编译时会失败。为了进一步分析，我关注第一个 test_all:

#include <type_traits>

struct some_type {};

struct probe {
    template<typename T>
    operator T& () const
    {
        static_assert(std::is_const_v<T>);
        static T t;
        return t;
    }
};

auto test_call(some_type const&) -> std::false_type;

int main() {
    test_call(probe{});
}

然后我们发现 static_assert 触发了 only under Clang。也就是说，Clang 将 T 推导为 some_type 而不是 const some_type。我认为这是 Clang 的一个错误。

使用模板转换运算符解决歧义

Ambiguous resolution with template conversion operator

c++

templates

language-lawyer

conversion-operator