重新加载未定义的行为和序列点

Question

将此主题视为以下主题的续集：

上一期
Undefined behavior and sequence points

让我们重温一下这个 funny 和 convoluted 表达式（斜体词组取自上述主题 *smile* ）：

i += ++i;

我们说这调用了未定义的行为。我假设当这样说时，我们隐含地假设 i 的 type 是内置类型之一。

如果i 的type 是用户定义的类型怎么办？假设它的类型是Index，它在本文后面定义（见下文）。它还会调用 undefined-behavior 吗？

如果是，为什么？不等于写i.operator+=(i.operator++());，甚至语法上更简单的i.add(i.inc());？或者，它们是否也调用未定义行为？

如果没有，为什么不呢？毕竟，对象i 在连续序列点之间被修改两次。请记住经验法则：an expression can modify an object's value only once between consecutive "sequence points。如果i += ++i 是一个表达式，那么它必须调用未定义行为。如果是这样，那么它的等价物 i.operator+=(i.operator++()); 和 i.add(i.inc()); 也必须调用 undefined-behavior 这似乎是不真实的！ （据我所知）

或者，i += ++i 一开始就不是一个表达式？如果是，那么它是什么，表达式的定义是什么？

如果它是一个表达式，同时它的行为也是明确定义的，那么它意味着与一个表达式关联的序列点的数量在某种程度上取决于类型 表达式中涉及的操作数。我是否正确（即使部分正确）？

---

对了，这个表达式怎么样？

//Consider two cases:
//1. If a is an array of a built-in type
//2. If a is user-defined type which overloads the subscript operator!

a[++i] = i; //Taken from the previous topic. But here type of `i` is Index.

您也必须在回复中考虑到这一点（如果您确定知道它的行为）。 :-)

---

是

++++++i;

在 C++03 中定义良好？毕竟是这个，

((i.operator++()).operator++()).operator++();

---

class Index
{
    int state;

    public:
        Index(int s) : state(s) {}
        Index& operator++()
        {
            state++;
            return *this;
        }
        Index& operator+=(const Index & index)
        {
            state+= index.state;
            return *this;
        }
        operator int()
        {
            return state;
        }
        Index & add(const Index & index)
        {
            state += index.state;
            return *this;
        }
        Index & inc()
        {
            state++;
            return *this;
        }
};

Answer 1

看起来像代码

i.operator+=(i.operator ++());

在序列点方面工作得很好。 C++ ISO 标准的第 1.9.17 节对序列点和函数求值进行了说明：

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

这将表明，例如，i.operator ++() 作为operator += 的参数在其评估后有一个序列点。简而言之，由于重载运算符是函数，因此适用正常的排序规则。

顺便说一句，好问题！我真的很喜欢你强迫我理解一种我已经认为我知道（并且认为我认为我知道）的语言的所有细微差别。 :-)

Answer 2

http://www.eelis.net/C++/analogliterals.xhtml 我想到了模拟文字

  unsigned int c = ( o-----o
                     |     !
                     !     !
                     !     !
                     o-----o ).area;

  assert( c == (I-----I) * (I-------I) );

  assert( ( o-----o
            |     !
            !     !
            !     !
            !     !
            o-----o ).area == ( o---------o
                                |         !
                                !         !
                                o---------o ).area );

Answer 3

正如其他人所说，您的 i += ++i 示例适用于用户定义类型，因为您正在调用函数，并且函数包含序列点。

另一方面，假设a 是您的基本数组类型，甚至是用户定义的数组类型，a[++i] = i 就没有那么幸运了。您在这里遇到的问题是我们不知道首先评估包含i 的表达式的哪一部分。可能是 ++i 被评估，传递给 operator[]（或原始版本）以便在那里检索对象，然后 i 的值被传递给它（这是在 i 之后递增）。另一方面，可能是先评估后者，存储以供以后分配，然后评估 ++i 部分。

Answer 4

我认为它定义明确：

来自 C++ 草案标准 (n1905) §1.9/16：

"后面还有一个序列点 返回值的复制和 在执行任何 函数外的表达式13) 。 C++ 中的几个上下文导致 函数调用的评估，甚至 虽然没有对应的函数调用 语法出现在翻译中 单元。 [例子：评估一个新的 表达式调用一个或多个 分配和构造函数； 见 5.3.4。再举一个例子， 调用转换函数 (12.3.2) 可能出现在 没有出现函数调用语法。 — end example ] 序列指向 函数入口和函数出口（如 上述）是的特点 评估后的函数调用，随便 表达式的语法 调用函数可能是。 "

注意我加粗的部分。这意味着在增量函数调用（i.operator ++()）之后但在复合赋值调用（i.operator+=）之前确实有一个序列点。

Answer 5

好的。在浏览了之前的回复之后，我重新思考了我自己的问题，特别是只有诺亚尝试answer但我并不完全相信他的部分。

a[++i] = i;

案例一：

如果a 是一个内置类型的数组。那么诺亚说的是对的。也就是说，

a[++i] = i 不是那么幸运，假设 a 是您的基本数组类型， 或 甚至是用户定义的一个。问题 你在这里是我们不知道的 表达式的哪一部分 包含 i 的首先被评估。

所以a[++i]=i 调用未定义行为，或者结果未指定。不管它是什么，它都没有明确定义！

PS：在上面的引用中，删除线当然是我的了。

案例2：

如果a 是重载operator[] 的用户定义类型的对象，那么又有两种情况。

1. 如果重载的operator[]函数的返回类型是内置类型，那么a[++i]=i再次调用undefined-behavior或者结果未指定。
2. 但是如果重载operator[]函数的返回类型是用户定义类型，那么a[++i] = i的行为是明确定义的（据我所知），因为在这种情况下a[++i]=i相当于写a.operator[](++i).operator=(i); 与 a[++i].operator=(i); 相同。也就是说，赋值operator= 在a[++i] 的returned 对象上被调用，这似乎非常明确，因为在a[++i] 返回时，++i 已经被评估，然后 returned 对象调用operator= 函数，将i 的更新值作为参数传递给它。 请注意，这两个调用之间有一个序列点。并且语法确保这两个调用之间没有竞争，operator[] 将首先被调用，随后，传递给它的参数 ++i 也将首先被评估。

将其视为someInstance.Fun(++k).Gun(10).Sun(k).Tun();，其中每个连续的函数调用都返回某个用户定义类型的对象。在我看来，这种情况更像是：eat(++k);drink(10);sleep(k)，因为在这两种情况下，每个函数调用之后都存在序列点。

如果我错了，请纠正我。 :-)