为什么前后递增/递减运算符分开实现？

Question

我试图找出让递增和递减运算符的重新版本和后期版本分别可重载的理由。
在我看来，在我所见过的任何类型的类的这些运算符的每个实现中，它们都是相同的运算符（= 做同样的事情），只是在调用时有所不同。
对我来说，C++ 的设计者应该有 one ++ 运算符似乎更合乎逻辑，编译器会根据需要在读取值之前或之后调用它（或者，更有可能，在上一个或下一个序列点，我认为是等效的）

所以，问题是：有没有人有可能不以相同方式实现的案例/类的示例？或者有没有人知道/猜测这种设计选择背后的基本原理？

---

对于那些更喜欢看代码而不是阅读问题文本的人，这里是摘要：

对于什么类型的T（代表你想要的任何东西的用户定义类）是否有意义，以下两行不具有相同的副作用：

T v;

v++;
++v;

---

编辑
引用下面@Simple 的评论，我希望能澄清这个问题：

为什么编译器会在语言中使用后增量（重载） 可以自己做一个副本并做预增量

---

编辑 2
由于许多人显然不清楚这个问题，这里有另一种解释：

考虑以下两行：

b = a++;
b = ++a;

如果是一个操作符（为了论证，我称操作符为+a+），第一行会被编译器翻译成

b = a;
+a+;

第二个进入

+a+;
b = a;

Answer 1

也许在延迟实现的线程环境中有些东西？对于 ++a 您希望它阻塞直到它更新 a 以便您获取更新的值，但对于 a++ 您只需发送发出信号并继续做事。

Answer 2

它们是两个独立的运算符，因为它们执行两种不同（尽管相关）的事情。

预递增/递减将递增/递减变量并返回新值。

int i = 0;
int j = ++i; // j is now 1

后递增/递减将递增/递减变量并返回旧值。

int i = 0;
int j = i++; // j is now 0

一般来说，这些运算符的实现如下所示（对于某些类型T）：

T& T::operator++() // prefix overload
{
    *this = *this + 1;
    return *this;
}

T T::operator++(int) // postfix overload
{
    T prev = *this;
    ++(*this); // call prefix overload
    return prev;
}

如您所见，前缀重载不需要类型的额外副本，而后缀版本则需要。

由于大部分 cmets 都围绕着为什么会这样的问题：

简短的回答是：因为 C 标准是这样说的（而 C++ 从 C 继承了它）。

更长的答案是：

++a 和a++ 只是调用特定函数的简写符号。 ++a（对于给定类型T）映射到T& T::operator++() 或T& operator++(T&)，a++ 映射到T T::operator++(int) 或T operator(T&, int)。与所有运算符一样，您（作为程序员）可以将它们定义为针对相应类型执行 anything（注意：通常认为重载运算符以执行某些操作是不好的做法 奇怪，但标准并没有阻止你这样做）。通常，如果您要定义一个类型（例如迭代器），您可以通过提供类似的接口（即重载适当的运算符）使其与内置类型（例如指针）的行为相匹配。但是，您可以决定让operator++() 执行二次公式，而operator++(int) 进行傅里叶变换。因为它们是 2 个独立的功能，所以这是允许的。如果允许编译器根据operator++() 定义的前提来推断operator++(int)，则它们将绑定在一起。

C++ 中的运算符只不过是函数调用的简写符号。虽然根据其他运算符来实现多个运算符是很常见的，但标准并不要求这样做，因此编译器无法做出这样的假设。如果标准要求它，那么就会有很多假设的行为需要跟踪。

此外，++a 和 a++ 的行为是从 C 中继承而来的。存在很多代码利用其中一个或另一个的行为，并且不断变化在 C++ 标准中会破坏与 C 的兼容性（除非您也在 C 标准中进行了更改）。由于有 大量 现有代码利用了这些运算符的行为，因此您可能会做出重大的重大更改。

虽然在前增量方面实现后增量是很常见的，但您确实应该将这两个函数视为不同的函数（与您对 operator== 与 operator!=、operator< 的看法非常相似, operator> 等。仅仅因为某些东西很常见并不意味着该标准将，甚至应该将其作为要求。

Answer 3

看下面的例子

int i = 5;
int x = i++;
cout << i << " " << x;

这将打印出来

6 5

int i = 5;
int x = ++i;
cout << i << " " << x;

这将打印出来

6 6

那么我们可以推断出什么？
在后缀中，i 的值首先分配给 x，然后 i 递增
在prefix中，i的值先递增后赋值给x

Answer 4

这种区别在复杂类型的迭代器中变得很重要。表达式

*it++

给我迭代器当前指向的对象，并递增迭代器。如果迭代器前进后数据通常不会保存在内存中，则返回前一个对象变得困难。有两种方法：

1. 在后增量中保留一份副本
2. 延迟后提前

前一个方法仍然必须返回一些行为类似于迭代器的东西（至少对于operator* 和operator->，但不能是指针，因为它还必须保留对象副本的所有权，所以返回一个代理：

struct iterator {
    value_type value;

    struct proxy {
        value_type value;
        value_type &operator*() { return value; }
        value_type *operator->() { return &value; }
    };

    value_type &operator*() { return value; }
    value_type *operator->() { return &value; }
    iterator &operator++(); // actual increment code
    proxy operator++(int) { proxy ret = { value }; ++*this; return ret; }
};

如果创建副本也很昂贵并且应该避免，您也可以延迟增量：

struct iterator {
    value_type value;
    bool needs_increment;

    value_type &operator*() { if(needs_increment) ++*this; return value; }
    value_type *operator->() { if(needs_increment) ++*this; return &value; }
    iterator &operator++(); // actual increment code, resets needs_increment
    value_type *operator++(int) { needs_increment = true; return &value; }
};

Answer 5

我认为问题与（子）表达式的评估顺序和应用副作用的时间有关。例如，在 C# 中，（子）表达式的求值顺序是确定性的，并且会立即应用副作用。例如考虑以下 C# 代码

int x = 0;
int y = x++ + ++x;

此代码在 C# 中定义了行为。所以你可以只实现一个增量运算符，编译器会以适当的方式使用它。

C++ 没有这种可能性。 （子）表达式的求值顺序未指定，并且不会立即应用副作用。

Answer 6

您将如何实现后增量的通用版本？

我猜：T operator++(int) { T tmp(*this); ++*this; return tmp; }

如果我的类型不可复制或复制成本高怎么办？

好吧，我更喜欢：

Proxy operator++(int) { return Proxy(++*this, 1); }

然后有类似的东西：

bool operator==(Proxy const& left, T const& right) {
    return left.value - 1 == right.value;
}

如果编译器可以自己进行复制并进行预增量，为什么语言中有后增量（重载）？

因为您认为编译器可以进行复制的假设是错误的，即使它持有也可能成本太高。

Answer 7

Pre increment 在语句的其余部分之前递增变量，例如

x = 2;
y = ++x;

y == 3;
x == 3;

而 post increment 在语句的其余部分之后进行增量，

x = 2;
y = x++;

y == 2;
x == 3;

预增量稍微快一些，所以应该是首选。需要注意的是，当两个运算符都在一个语句中使用时，行为是未定义的，所以像

x = 5;
x = x++ + ++x;

会在不同的语言中给出不同的结果。

Answer 8

因为这些运算符对于内置类型的不同语义。表达式的值在前后递增/递减之间是不同的，即使两者都改变​​了操作数。

int a = 1;
(a++) == 1;
a = 1;
(++a) == 2;

允许单独重载它们允许为返回值创建类似的语义。