这段代码定义明确吗？

Question

此代码取自此处的讨论。

someInstance.Fun(++k).Gun(10).Sun(k).Tun();

这段代码定义明确吗？ Fun() 中的 ++k 是否先于 Sun() 中的 k 计算？

如果 k 是用户定义类型而不是内置类型怎么办？上面的函数调用顺序在哪些方面与此不同：

eat(++k);drink(10);sleep(k);

据我所知，在这两种情况下，每个函数调用之后都存在一个序列点。如果是这样，那么为什么第一种情况不能像第二种情况一样被明确定义呢？

C++ ISO 标准的第 1.9.17 节对序列点和函数求值进行了如下说明：

当调用函数时（无论是 不是内联函数），有 评估后的序列点 所有函数参数（如果有） 这发生在执行之前 中的任何表达或陈述 函数体。还有一个 复制后的序列点 返回值和之前 执行外部的任何表达式 函数。

Answer 1

我认为，如果您准确阅读该标准引用的内容，第一种情况将无法明确定义：

当调用函数时（无论函数是否内联），在所有函数参数（如果有）的计算之后有一个序列点，该序列点发生在函数体中的任何表达式或语句执行之前

这告诉我们的不是“在对函数的参数求值之后唯一可能发生的事情是实际的函数调用”，但简单地说，在参数求值完成之后、函数调用之前的某个时刻存在一个序列点。

但如果你想象这样的情况：

foo(X).bar(Y)

这给我们的唯一保证是：

• X 在调用 foo 之前评估，并且
• Y在调用 bar 之前进行评估。

但这样的顺序仍然是可能的：

1. 评估X
2. 评估Y
3. （将X与foo分开的序列点call)
4. call foo
5. (将 Y 与 bar 分开的序列点 call)
6. call bar

当然，我们也可以交换前两项，在 X 之前评估 Y。为什么不呢？该标准仅要求在函数体的第一个语句之前对函数的参数进行完全评估，并且上述序列满足该要求。

至少这是我的解释。似乎并没有说参数求值和函数体之间不会发生任何其他事情 - 只是这两者被序列点分隔开。

Answer 2

这取决于 Sun 的定义方式。以下是明确定义的，

struct A {
  A &Fun(int);
  A &Gun(int);
  A &Sun(int&);
  A &Tun();
};

void g() {
  A someInstance;
  int k = 0;
  someInstance.Fun(++k).Gun(10).Sun(k).Tun();
}

如果将Sun的参数类型更改为int，则变为未定义。让我们绘制一棵采用 int< 的版本树/代码>。

                     <eval body of Fun>
                             |
                             % // pre-call sequence point
                             | 
 { S(increment, k) }  <-  E(++k) 
                             |     
                      E(Fun(++k).Gun(10))
                             |
                      .------+-----.       .-- V(k)--%--<eval body of Sun>
                     /              \     /
                   E(Fun(++k).Gun(10).Sun(k))
                              |
                    .---------+---------. 
                   /                     \ 
                 E(Fun(++k).Gun(10).Sun(k).Tun())
                              |
                              % // full-expression sequence point

可以看出，我们读取了 k（由 V(k) 指定），并且对 k 产生了副作用（在最上面）不被序列点分隔：在此表达式中，相对于其他子表达式，根本不存在序列点。最底部的 % 表示完整表达序列点。

Answer 3

这是未定义的行为，因为 k 的值在同一表达式中被修改和读取，而没有中间序列点。请参阅这个问题的精彩长答案。

1.9.17 的引用告诉您，所有函数参数在调用函数体之前都会被求值，但没有说明同一表达式中不同函数调用的参数求值的相对顺序 - 不能保证“++k Fun() 在 Sun() 中的 k 之前计算”。

eat(++k);drink(10);sleep(k);

有所不同，因为 ; 是一个序列点，因此评估的顺序是明确定义的。

Answer 4

作为一个小测试，请考虑：

#include <iostream>

struct X
{
    const X& f(int n) const
    {
        std::cout << n << '\n';
        return *this;
    }
};

int main()
{
    int n = 1;

    X x;

    x.f(++n).f(++n).f(++n).f(++n);
}

我使用 gcc 3.4.6 运行它，没有优化，并得到：

5
4
3
2

...with -O3...

2
3
4
5

因此，该版本的 3.4.6 有一个主要错误（这有点难以解决）相信），或者如菲利普·波特所建议的那样，序列未定义。 （带/不带 -O3 的 GCC 4.1.1 生成了 5, 5, 5, 5。）

编辑 - 我在下面的评论中对讨论的总结：

• 3.4.6 确实可能有一个错误（嗯，是的）
• 许多较新的编译器碰巧产生 5/5/5/5...这是一个定义的行为吗？
  • 可能不会，因为它对应于在进行任何函数调用之前“执行”所有增量副作用，这不是这里任何人建议的标准可以保证的行为
• 这不是一个非常好的行为。调查标准要求的好方法（特别是使用像 3.4.6 这样的旧编译器）：同意，但这是一个有用的健全性检查

Answer 5

我知道编译器的行为不能真正证明任何事情，但我认为检查编译器的内部表示会给出什么会很有趣（仍然比汇编检查更高级别）。

我已将 Clang/LLVM 在线演示 与此代码一起使用：

#include <stdio.h>
#include <stdlib.h>

struct X
{
  X const& f(int i) const
  {
    printf("%d\n", i);
    return *this;
  }
};

int main(int argc, char **argv) {
  int i = 0;
  X x;
  x.f(++i).f(++i).f(++i);         // line 16
}

并使用标准优化进行编译（在 C++ 模式下），它给出：

/tmp/webcompile/_13371_0.cc：在函数“int main(int, char**)”中：
/tmp/webcompile/_13371_0.cc:16：警告：“i”上的操作可能未定义

，我确实觉得有趣（是否有任何其他编译器对此发出警告？Comeau在线没有）

---

顺便说一句，它还生成了以下中间表示（向右滚动）：

@.str = private constant [4 x i8] c"%d\0A\00", align 1 ; <[4 x i8]*> [#uses=1]

define i32 @main(i32 %argc, i8** nocapture %argv) nounwind {
entry:
  %0 = tail call i32 (i8*, ...)* @printf(i8* noalias getelementptr inbounds ([4 x i8]* @.str, i64 0, i64 0), i32 3) nounwind ; <i32> [#uses=0]
                                                                                                             ^^^^^
  %1 = tail call i32 (i8*, ...)* @printf(i8* noalias getelementptr inbounds ([4 x i8]* @.str, i64 0, i64 0), i32 3) nounwind ; <i32> [#uses=0]
                                                                                                             ^^^^^
  %2 = tail call i32 (i8*, ...)* @printf(i8* noalias getelementptr inbounds ([4 x i8]* @.str, i64 0, i64 0), i32 3) nounwind ; <i32> [#uses=0]
                                                                                                             ^^^^^
  ret i32 0
}

显然，Clang 的行为类似于 gcc 4.xx，并且在执行任何函数调用之前首先评估所有参数。

Answer 6

一个有点老的问题，但这使它更有趣，因为正确的答案是：
这取决于！

当这个问题最初于 2011 年提出时，答案显然是否定的！ someInstance.Fun(++k).Gun(10).Sun(k).Tun(); 是未指定的行为，导致变量 k 被修改并读取同样的表情。

但在 C++17 中，情况发生了变化：
https://wg21.link/p0145
这样，函数的参数计算被指定为在任何进一步的链式函数调用之前进行排序。
这意味着现在 someInstance.Fun(++k).Gun(10).Sun(k).Tun(); 计算顺序是明确定义且明确的：
someInstance>> ++k>>乐趣（）>> 10>>枪()>> k>>太阳（）>>敦()

Answer 7

第二种情况当然是明确定义的。以分号结尾的标记字符串是 C++ 中的原子语句。每个语句在下一个语句开始之前都会被解析、处理和完成。