decltype 从表达式列表中评估错误的类型

Question

在尝试 This post 的答案时， 最终得到以下代码：

#include <iostream>
#include <typeinfo>
 
 namespace Test
 {
    struct MyPtr
    {
        double operator, (int Input)
        {
            std::cout << "Operator, called" << std::endl;
            return 1.0;
        }

        MyPtr operator* ()
        {
            std::cout << "operator* called" << std::endl;
            return *this ;
        }

        MyPtr operator++ ()
        {
            std::cout << "operator++ called" << std::endl;
            return *this;
        }

        MyPtr operator!= (const MyPtr& Other)
        {
            std::cout << "operator!= called" << std::endl;
            return *this;
        }
    };

    struct Foo
    {
        MyPtr Ptr;
    };

    MyPtr begin(Foo& t)
    {
        return t.Ptr;
    }

    MyPtr end(Foo& t)
    {
        return t.Ptr;
    }
 }
 
int main()
{
    std::cout << typeid(decltype(++begin(std::declval<Test::Foo&>()),
                                 *begin(std::declval<Test::Foo&>()), 
                                  std::true_type{})).name() <<std::endl;
}

产生：

d

这里，d 来自逗号运算符。然而，由于 decltype 说明符中的最后一个表达式是 std::true_type{}，为什么 decltype 说明符解析为逗号运算符返回的类型而不是 std::true 类型。

我的理论是 std::true_type 可以隐式转换为 int，此处的 operator,() 作为参数，因此 decltype 表达式等效于：

    std::cout << typeid(decltype(++begin(std::declval<Test::Foo&>()),
                                 declval<double&>())).name() <<std::endl;

你能确认这是正确的吗？

当我更好地了解编译器的行为时，我打算做什么，我计划用以下内容替换 decltype 说明符的内容：

    std::cout << typeid(decltype(void(++begin(std::declval<Test::Foo&>())),
                                 void(*begin(std::declval<Test::Foo&>())), 
                                  std::true_type{})).name() <<std::endl;

这将阻止 operator,() 匹配，即使它被覆盖。你也可以确认这是正确的吗？

Answer 1

我添加了一个成员到MyPtr 以获取更多信息。实际评估表达式会告诉您发生了什么：

#include <iostream>
#include <typeinfo>

struct MyPtr {
    int value;
    MyPtr(int x) : value(x) {}

    double operator,(int Input) {
        std::cout << "Operator, called value = " << value
                  << " Input = " << Input << std::endl;
        return 1.0;
    }
    MyPtr operator*() {
        std::cout << "operator* called value = " << value << std::endl;
        return *this;
    }
    MyPtr operator++() {
        std::cout << "operator++ called value = " << value << std::endl;
        return *this;
    }
    MyPtr operator!=(const MyPtr& Other) {
        std::cout << "operator!= called" << std::endl;
        return *this;
    }
};

struct Foo { MyPtr Ptr; };

MyPtr begin(Foo& t) { return t.Ptr; }

MyPtr end(Foo& t) { return t.Ptr; }

int main() {
    Foo f1{10};
    Foo f2{20};
    ++begin(f1), *begin(f2), std::true_type{};
    ++begin(f1), *begin(f2), std::false_type{};
}

Output:

operator++ called value = 10
operator* called value = 20
Operator, called value = 20 Input = 1
operator++ called value = 10
operator* called value = 20
Operator, called value = 20 Input = 0

你的“理论”是正确的。让我们删除++和*以使其更简单，然后您可以将f1,f2,std::true_type{}视为f1.operator,( f2.operator,(std::true_type{})。 std::true_type 有 operator bool 和 bool 可以隐式转换为 int。为了说明，我还在代码中添加了带有false_type 的示例。