问：

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

上一期
未定义的行为和序列点

让我们重温一下这个有趣而复杂的表达方式（斜体短语取自上面的主题*微笑*）：

i += ++i;

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

如果类型是用户定义的类型，该怎么办？假设它的类型是本文后面定义的类型（见下文）。它是否仍会调用未定义的行为？iIndex

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

如果不是，为什么不呢？毕竟，对象在连续的序列点之间被修改了两次。请记住经验法则：表达式只能在连续的“序列点”之间修改对象的值一次。如果是一个表达式，那么它必须调用 undefined-behavior。如果是这样，那么它的等价物也必须调用似乎不真实的未定义行为！（据我了解）ii += ++ii.operator+=(i.operator++());i.add(i.inc());

或者，一开始就不是一个表达式吗？如果是这样，那么它是什么，表达的定义是什么？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;
        }
};

C 未定义行为 C++-FAQ 序列点

“之后还有一个序列点复制返回值和在执行任何之前函数外部的表达式13）。 C++ 中的多个上下文导致函数调用的评估，甚至虽然没有相应的函数调用语法出现在翻译中单位。[ 示例：评估新的 expression 调用一个或多个分配和构造函数; 参见 5.3.4。再举一个例子，转换函数的调用（12.3.2）可能出现在未显示函数调用语法。 — 结束示例 ] 序列指向 function-entry 和 function-exit（如如上所述）是函数调用已评估，无论表达式的语法 调用函数可能是。"

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

11赞 Edward Strange 1/9/2011 #3

正如其他人所说，您的示例使用用户定义类型，因为您正在调用函数，而函数由序列点组成。i += ++i

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

@Philip：结果是UB，因为5/4中的规则：“对于完整表达式的子表达式的每个允许顺序，应满足本款的要求;否则，行为是未定义的。如果所有允许的排序在修改和读取分配的 RHS 之间都有序列点，则该顺序将未指定。因为其中一个允许的排序在没有干预序列点的情况下执行这两件事，所以行为是未定义的。++ii

1赞 Steve Jessop 1/12/2011

@Philip：它不仅将未指定的行为定义为未定义的行为。同样，如果未指定行为的范围包括一些未定义的行为，则整体行为是未定义的。如果在所有可能性中都定义了未指定行为的范围，则未指定整体行为。但你在第二点上是对的，我正在考虑一个用户定义的和内置的.ai

6赞 Nawaz 1/9/2011 #4

好。在浏览了之前的回答之后，我重新思考了我自己的问题，尤其是只有诺亚试图回答的这一部分，但我并不完全相信他。

a[++i] = i;

案例一：

If 是内置类型的数组。那么挪亚说的是对的。那是a

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

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

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

案例二：

如果是重载的用户定义类型的对象，则同样有两种情况。aoperator[]

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

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

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

@Nawaz，并且不由序列点分隔。它们都可以在评估之前进行评估，也可以在评估之前进行评估。该语言只要求 that 在之前被求值，而不是的参数在的参数之前被求值。我又在解释同样的事情，但无法提供参考，所以我们不会从这里开始。k++kSunFunFunSunFunSun

1赞 Philip Potter 1/10/2011

@Nawaz：因为没有任何东西可以定义将它们分开的序列点。在执行之前和之后都有序列点，但的参数可以在此之前或之后进行计算。在执行之前和之后都有序列点，但的参数可以在此之前或之后进行计算。因此，一种可能的情况是，在计算 OR 之前计算 AND ，因此两者都在函数调用序列点之前，因此没有分隔和的序列点。SunFun++kFunSunkk++kSunFunk++k

1赞 Nawaz 1/10/2011

@Philip ：我再说一遍：这种情况与？...即使是现在，你也可以说可能在那之前或之后进行评估？eat(i++);drink(10);sleep(i);i++

1赞 Philip Potter 1/10/2011

@Nawaz：我怎样才能让自己更清晰？在 Fun/Sun 示例中，和之间没有序列点。在 eat/drink 示例中，在和之间有序列点。k++kii++

3赞 Nawaz 1/10/2011

@Philip：这完全没有意义。在 Fun（）和 Sun（）之间存在一个序列点，但在它们的参数之间不存在序列点。这就像说，在和之间存在序列点，但其中甚至没有一个参数。由序列点分隔的两个函数调用的参数如何属于相同的序列点？eat()sleep()

12赞 Industrial-antidepressant 1/10/2011 #5

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 );

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

Undefined behavior and sequence points reloaded

评论

评论

案例一：

案例二：

评论

评论