运算符 () 的"explicit"和"implicit"调用之间的区别

Difference between "explicit" and "implicit" invocation of operator ()

本文关键字：调用 之间 区别 implicit explicit 运算符      更新时间：2023-10-16

标准中是否有描述从基类调用operator ()的方法之间的以下差异的子句?

#include <iostream>
#include <type_traits>
#include <cstdlib>
#include <cassert>
template< typename visitor, typename ...visitors >
struct composite_visitor
    : std::decay_t< visitor >
    , composite_visitor< visitors... >
{
    //using std::decay_t< visitor >::operator ();
    //using composite_visitor< visitors... >::operator ();
    composite_visitor(visitor && _visitor, visitors &&... _visitors)
        : std::decay_t< visitor >(std::forward< visitor >(_visitor))
        , composite_visitor< visitors... >{std::forward< visitors >(_visitors)...}
    { ; }
};
template< typename visitor >
struct composite_visitor< visitor >
    : std::decay_t< visitor >
{
    //using std::decay_t< visitor >::operator ();
    composite_visitor(visitor && _visitor)
        : std::decay_t< visitor >(std::forward< visitor >(_visitor))
    { ; }
};
template< typename visitor, typename ...visitors >
composite_visitor< visitor, visitors... >
compose_visitors(visitor && _visitor, visitors &&... _visitors)
{
    return {std::forward< visitor >(_visitor), std::forward< visitors >(_visitors)...};
}
int
main()
{
    struct A {};
    struct B {};
#if 1
    struct { int operator () (A) { return 1; } } x;
    struct { int operator () (B) { return 2; } } y;
    auto xy = compose_visitors(x, y);
#else
    auto xy = compose_visitors([] (A) { return 1; }, [] (B) { return 2; });
#endif
    // "implicit":
    assert(xy(A{}) == 1);
    assert(xy(B{}) == 2);
    // "explicit":
    assert(xy.operator () (A{}) == 1); // error: member 'operator()' found in multiple base classes of different types
    assert(xy.operator () (B{}) == 2);
    return EXIT_SUCCESS;
}

"隐式"调用可以编译，但"显式"调用不行。为什么会这样呢?

compose_visitors通过构造由所有参数派生的类，将参数组合成一个类。

取消注释using衍生词可以消除硬错误。

lambda函数和函子函数的行为是相同的。

Compiler is clang 3.6.

"隐式"调用也是格式错误的。事实上，GCC拒绝了它，所以它看起来像是Clang中的一个bug。

标准(N4140， [over.call]/1)明确规定

对于类型为T的类对象x，如果T::operator()(T1, T2, T3)存在并且操作符被重载解析机制(13.3.3)选为最佳匹配函数，则调用x(arg1,...)将被解释为x.operator()(arg1, ...)。

所以两个调用的行为必须相同。

更新:这是Clang中已知的问题。

相关文章：