一文带你彻底搞懂i++和++i的区别，谁的效率更高？

作者简介：Codebowl靓仔，学妹的工具人，C++开发误入数据开发，梦想30岁退休的靓仔就是我啦。

i++和++i对于初学者来说，一直是一个特别容易搞混的内容，相信很多人现在也没有完全搞清(作者初学的时候就一直稀里糊涂的，老师在讲这个的时候也一笔带过了)。
不过今天不用怕，看完这篇文章，相信你一定能搞清楚这俩个的区别！

基本概念

两者的作用都是自增加1。
单独拿出来说的话，++i和i++，效果都是一样的，就是i=i+1。

int main()
{
	int i = 0;
	i++;
}

int main()
{
	int i = 0;
	++i;
}

最后的结果都是1。

那么它们的区别又体现在什么地方呢？
请继续往下看！

++i和i++的区别

单独使用的时候是没有区别的，但是如果当成运算符，就会有区别了！
如图所示，我们用a=i++和a=++i举例说明

1.先说a=i++，这个运算的意思是先把i的值赋予a，然后在执行i=i+1；

• 当i初始等于3时，执行a=i++，最终结果a=3，i=4.

2.而a=++i，这个的意思是先执行i=i+1，然后在把i的值赋予a；

• 当i初始等于3时，执行a=++i，最终结果a=4，i=4.

所以说两者参与运算时的区别就是：

1. a=i++ , a 返回原来的值a=i,i=i+1;
   a=++i , a 返回加1后的值,a=i+1,i=i+1。
   也就是i++是先赋值，然后再自增；++i是先自增，后赋值。
2. 第二个区别就是： i++ 不能作为左值，而++i可以。

i++和++i的原理

实现原理我们要分俩部分看，因为单独使用和参与运算时是不一样的。

单独使用时

通过下图汇编代码所示，单独使用时，都是先进性加法，在进行赋值，所以体现出来的结果是一样的。

参与运算时

我们通过汇编代码，就可以很清楚地看到两者的不同了。
a=i++，先将i赋值给了a，然后才进行了+1操作，把加1结果赋值给了i。
b=++i，先进行加1操作，然后将加1结果先赋值给i，在赋值给了b。

其实，看汇编代码是学习C++的一个很好的方法，当我们对于某些实现原理存在疑惑的时候，就可以通过看汇编代码来学习！

i++和++i那个效率更高？

我们通过上面的两张图，单独使用的时候，两者没有区别，参与运算时，也不过是语句的执行顺序换了，但是执行的步骤是一样的，效率都是一样的啊，没有什么不同啊？


有这个疑问的小伙伴已经发现了在简单使用的时候，确实俩者的效率是没有什么不同的！
（之前存在的说法是++i比i++的效率高，但是当编译器优化之后，两者简单应用时的效率确实是没有什么不同的）

但是，答案是两者效率在某些情况下仍有不同！
当我们考虑自定义类的时候，就不一样了。
i++是先用临时对象保存原来的对象，然后对原对象自增，再返回临时对象，不能作为左值；++i是直接对于原对象进行自增，然后返回原对象的引用，可以作为左值。
由于要生成临时对象，i++需要调用两次拷贝构造函数与析构函数（将原对象赋给临时对象一次，临时对象以值传递方式返回一次）；
++i由于不用生成临时变量，且以引用方式返回，故没有构造与析构的开销，效率更高。
所以在使用类等自定义类型的时候，应尽量使用++i。

实验证明：

#include<iostream>
using namespace std;

class increment {
	int x_;
	int y_;
public:
	increment(int x = 0, int y = 0);
	increment(const increment&);
	~increment();
	increment& operator++();//前置
	const increment operator++(int);//后置
	increment operator+(const increment&);
	increment& operator+=(const increment&);
	void Displayincrement();
};

increment& increment::operator+=(const increment& _right)
{
	this->x_ += _right.x_;
	this->y_ += _right.y_;
	return *this;
}

increment increment::operator+(const increment& _right)
{
	increment temp;
	temp.x_ = this->x_ + _right.x_;
	temp.y_ = this->y_ + _right.y_;
	return temp;
}


increment& increment::operator++()
{
	++x_;
	++y_;
	return *this;
}

const increment increment::operator++(int)
{
	increment temp(*this);
	this->x_++;
	this->y_++;
	return temp;
}

increment::increment(int x, int y)
{
	x_ = x;
	y_ = y;
	cout << "this is constructor" << endl;
}

increment::increment(const increment& b)
{
	this->x_ = b.x_;
	this->y_ = b.y_;
	cout << "this is copy constructor" << endl;
}

increment::~increment()
{
	cout << "this is destructor" << endl;
}

void increment::Displayincrement()
{
	cout << "x: " << this->x_ << endl;
	cout << "y: " << this->y_ << endl;
}

int main()
{
	increment i(1, 1);
	cout << endl << "this is i++: " << endl;
	i++;
	cout << endl << "this is ++i: " << endl;
	++i;
}

运行结果：
可以看到，i++将会有两次的拷贝构造与析构的调用，效率非常低。

总结如下：

1. 简单使用时，俩这效率没有什么区别！
2. 对于自定义类型，在类里使用的时候，++i的效率更高！

Codebowl是个靓仔，快要毕业的大四仔。
希望可以帮助到您，喜欢的话，可以给个关注收藏或点赞哦，有不懂或发现错误的可以在评论区或私信交流哦！