前置递增运算符（++）比后置递增运算符效率高的原因

前置递增运算符比后置递增运算符效率高，当然递减运算符也是一样的。我一开始是不理解这句话，而且在接触程序之初，似乎更习惯用后置的情况，即经常会写成i++。

前置的形式是返回递增或递减之后的对象，只需要返回该对象的引用。而后置的形式返回的是递增或递减之前的对象，因此需要额外创建一个对象副本，返回的不是引用，而是这个副本对象。

虽然有点抽象，但是上面这段话可以说就是标题的回答了。下面把上面这段回答翻译成人话，啊，不，翻译的直观一点~。从两个方面来说明，使用效果上和实现方法上。

1. 使用效果上。

对于++i和i++在效果上的区别相信大家都了解，只是我们没有去想为什么。从使用效果上，很好理解++i返回的是对象的引用，而i++返回的是改变前的对象副本。看简单的代码示例。

void printI()
{
    int i = 0;
    cout << i++ <<endl;
    i=0;
    cout << ++i << endl;
}

int main()
{
    printI();
    return 0;
}

输出的结果是0,1。所以i++这种后置的形式返回的是++操作之前的i，而++操作之后的i虽然没有被返回，但是已经替代了原来的i。所以返回++操作之前的i需要进行一次拷贝，即返回的是对象的副本。而++i这种前置的形式，返回的就是++操作之后的i，不需要另外保存原来的结果，所以直接返回对象的引用即可。

2. 从实现方法上分析

这里我参考了《C++ Primer》，对于前置++运算符的重载，是这样实现的。书里的代码写的相对抽象，我已经尽量简化。check()函数不用去管他，A就代表某个类。前置的++的实现是第一个，后置++实现是第二个，后置++的实现中多了一个int类型的形参，是为了对这两种重载进行区别，否则无法区分前置还是后置了。实际中这个int类型的形参不会被用到，编译器可能会为这个形参提供一个值为0的实参。

A& A::operator++()
{
    check();//检查是否已经指向容器的尾后位置，是则无法递增
    ++curr;
    return *this;
}

A& A::operator++(int)
{
    A temp = *this;
    ++*this;
    return temp;
}

虽然有些抽象，但是可以明显看到的是，前置++的重置直接返回了对象的引用，而后置++的重置首先建立了一个temp的临时变量用来存储++之前的对象，然后调用前置++完成++的操作，最后返回temp这个临时的变量。这里面额外创建了临时变量，而实际的操作后置版本还是调用了前置版本完成的。这显然要比前置版本效率低。

当然，上面的代码还是太抽象了些，我们可以自己创建一个类，然后实现一下对于++的重载。对于后置，我认为的实例化了一个Stu类，命名为temp。这里就能够直观看出占用了额外的空间。如果这个类很复杂，那么效率问题可想而知。

public:
    Stu(){};
    Stu(string name, int id)
    {
        this.name = name;
        this.id = id;
    }

    //重载前置运算符
    Stu& operator++()
    {
        ++id;
        return *this;
    }

    //重载后置运算符
    Stu operator++(int)
    {
        Stu temp(name, id);
        // 或者写成Stu temp = *this;
        ++id;
        return temp;
    }
};

最后，如果不需要返回++之前的对象，其实这两种方式的效率应该是没有差别的。另外，对于内置的数据结构，编译器会对前置和后置的操作进行优化，导致效率上差别不大。但是如果是自己定义的数据类型，还是用前置的操作符效率更高。