这段代码定义明确吗？

Question

此代码取自here 上的讨论。

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

这取决于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，它将变为未定义。让我们 draw a tree 的版本采用 int。

                     <eval body of Fun>
                             |
                             % // pre-call sequence point
                             | 
 { S(increment, k) }  <-  E(++x) 
                             |     
                      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 2

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

我使用Clang/LLVM online demo 和这个代码：

#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 online 没有）

---

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

@.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.x.x 一样，在执行任何函数调用之前首先评估所有参数。

Answer 3

作为一个小测试，考虑：

#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

...与 -O3...

2
3
4
5

因此，要么该版本的 3.4.6 有一个重大错误（这有点难以置信），要么如 Philip Potter 所建议的那样，序列未定义。 （带有/不带 -O3 的 GCC 4.1.1 产生 5、5、5、5。）

编辑 - 我对以下 cmets 讨论的总结：

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

Answer 4

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

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

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

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

Answer 5

我认为，如果您完全了解该标准引用所说的内容，则第一种情况不会被明确定义：

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

这告诉我们的不是“在对函数的参数进行评估后唯一可能发生的事情就是实际的函数调用”，而只是在对参数的评估完成后的某个时间点存在一个序列点, 在函数调用之前。

但如果你想象这样一个案例：

foo(X).bar(Y)

这给我们的唯一保证是：

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

但是这样的订单仍然是可能的：

1. 评估X
2. 评估Y
3. （将X 与foo 通话分开的序列点）
4. 致电foo
5. （将Y 与bar 通话分开的序列点）
6. 致电bar

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

这是我的解释，至少。似乎并没有说在参数评估和函数体之间可能会发生 nothing —— 只是这两者被一个序列点隔开。

Answer 6

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