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

Question 1

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

上一期文章
未定义行为和顺序点

让我们重新看一下这个有趣而令人费解的表达（斜体字词来自上面的主题* smile *）：

i += ++i;

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

如果什么类型的i是用户定义类型？说它的类型是本文Index后面定义的类型（请参阅下文）。它仍然会调用未定义行为吗？

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

如果没有，为什么不呢？毕竟，对象在连续的序列点之间i被修改了两次。请回想一下经验法则：表达式只能在连续的“序列点”之间修改对象的值一次。如果 i += ++i是表达式，则它必须调用undefined-behavior。如果是，则它的等效项i.operator+=(i.operator++());也 i.add(i.inc());必须调用undefined-behavior，似乎是不正确的！（据我了解）

或者，i += ++i不是一开始的表达方式吗？如果是这样，那么它是什么，expression的定义是什么？

如果它是一个表达式，并且其行为也得到了很好的定义，则意味着与该表达式关联的序列点数在某种程度上取决于该表达式所涉及的操作数的类型。我是否正确（甚至部分正确）？

顺便说一下，这个表情怎么样？

//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;
        }
};

Question 2

看起来像代码

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

关于顺序点，效果很好。C ++ ISO标准的1.9.17节说明了有关顺序点和功能评估的内容：

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

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

顺便问一个好问题！我真的很喜欢您如何迫使我理解我已经以为自己知道（并且以为我以为自己知道）的语言的所有细微差别。:-)

Question 3

我想到了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 );

Question 4

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

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

Question 5

我认为这是明确的：

根据C ++草案标准（n1905）§1.9/ 16：

“复制返回的值之后，在执行函数外部的任何表达式之前，还有一个序列点。13。即使转换单元中没有相应的函数调用语法，C ++中的多个上下文也会导致函数调用的求值。 [实施例：新的表达式的求值调用一个或多个分配和构造函数;见5.3.4对于另一个例子，一个转换功能（12.3.2）的调用可以在背景中出现的其中没有函数调用的语法出现。 -端示例]无论表达式的语法如何，函数入口和函数出口的序列点（如上所述）都是所求值的函数调用的特征调用该函数可能是。”

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

Question 6

好的。经过先前的回答后，我重新考虑了自己的问题，特别是在这一部分中，只有诺亚（Noah）试图回答，但我并不完全相信他。

a[++i] = i;

情况1：

Ifa是内置类型的数组。那挪亚说的是对的。那是，

a [++ i] =假设a是您的基本数组类型，我不是很幸运， ~~甚至是用户定义的~~ 。您在这里遇到的问题是，我们不知道包含i的表达式的哪一部分首先被求值。

因此，a[++i]=i调用undefined-behavior，或者结果不确定。无论是什么，它都没有明确定义！

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

情况2：

如果a是用户定义类型的对象，该对象使过载operator[]，则再次有两种情况。

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

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

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