自入行以來，無論是查閱資料、技術博客亦或是同事間的技術交流，都有一個共識:在循環的時候，務必使用前置操作符，因為其性能優于后置操作符，久而久之，這個就像一個不成文的規定，大家都在遵循，久而久之，成為潛移默化的編碼習慣。而使得大家持有這個觀點的原因就是后置操作會產生臨時變量，而后置操作則不會。

今天，借助本文，來分析或者證明下該結了正確與否~~

原因

后置操作和前置操作，一個會產生臨時變量，一個不會產生臨時變量，其原因是：前置操作遵循的規則是change-then-use，而后置操作遵循的規則是use-then-change。正因為后置操作的use-then-change原則，使得編譯器在實現該操作的時候，先把之前的值進行拷貝備份，然后對值進行更改操作，最后返回之前備份的值。

以整型為例：

?

//?++i
i?=?i+1;
return?i;

//?i++
temp?=?i;
i=i+1;
return?temp;

?

同樣，對于復雜類型：

?

//?++i
Object?&operator++()?{?????
??++value_;?????
??return?*this;???
}????
//?i++????
Object?operator++(int)?{?????
??Object?old?=?*this;????
??????++*this;?????
??return?old;??
}??

?

也正是基于上述原因，我們通常會得出一個結論：前置操作比后置操作更快。

那么，真的是這樣么？下面將分別從內置類型和非內置類型兩個方面進行分析。

內置類型

為了便于分析二者的性能，寫了個測試代碼，用來比較前置++和后置++的性能差異，代碼如下：

pre_inc.cc

?

void?PreInc()?{
??for?(int?i?=?0;?i?

	?

	post_inc.cc

	?
void?PostInc()?{
??for?(int?i?=?0;?i?

	?

	編譯運行之后，比較二者的運行時間，對比圖如下：

	

	耗時竟然一樣，顛覆了之前對這塊的認知。

	使用下述命令生成匯編代碼(使用-O0禁用優化以免結果產生偏差)：

	?
$?g++?-O0?-S?pre.cc
$?g++?-O0?-S?post.cc

	?

	查看上述兩個匯編文件的不同點(使用vimdiff):

	

	通過上述對比，發現前置++和后置++的匯編結果一致，這也就是說至少對于內置類型(上述代碼使用的是int)，前置++和后置++的性能一樣。在進行搜索的時候，發現了下面這段話：

	“The compiler will optimize it away” is an?incredibly?lazy justification for using i++ instead of ++i. Moreover, it is basically only true for built-in types, not for class types.

	從上述可以看出，對于內置類型的后置++操作，編譯器會進行優化，而對于非內置內存，則不會進行優化，那么到底是不是這樣呢？

	自定義類型

	迭代器

	對于C++開發人員，在遍歷vector、list或者set等結構的時候，都習慣于使用迭代器即iterator進行遍歷，而gcc實現中，對iterator(此處只羅列了vector相關)的定義如下：

	?
typedef?__gnu_cxx::__normal_iterator?iterator;,>

	?

	從上述定義可以看出，iterator不是內置類型，同內置類型一樣，**iterator也支持前置++和后置++**，所以，在本節中使用迭代器的前置++和后置++對容器進行遍歷，以測試其性能，代碼如下：

	?
#include?
#include?
#include?
#include?

int?main(int,?char**)
{
??std::vector?v1(?1000000?);
??std::vector?v2(?1000000?);

??std::iota(?v1.begin(),?v1.end(),?1?);
??std::iota(?v2.begin(),?v2.end(),?2?);

??std::time_point?t1,?t2,?t3;

??t1?=?std::now();

??for(?auto?it?=?v1.begin();?it?!=?v1.end();?++it?)
????*it?*=?2;

??t2?=?std::now();

??for(?auto?it?=?v2.begin();?it?!=?v2.end();?it++?)
????*it?*=?2;

??t3?=?std::now();

??std::duration?d1?=?t2?-?t1;
??std::duration?d2?=?t3?-?t2;

??std::cout?<

	?

	編譯并運行：

	?
?g++?--std=c++11?test.cc?-o?test;?./test
?pre?time?cost:?44008us
?post?time?cost:??58283us

	?

	通過上述結果可以看出，對于非內置類型（或者更確切的說對于迭代器類型），前置操作的性能優于后置。

	上面從執行時間的角度分析了迭代器的前置操作和后置操作對性能的影響，下面是STL中對iterator的源碼：

	?
__normal_iterator&
???????operator++()?//?前置操作
???????{
?????++_M_current;
?????return?*this;
???????}

?__normal_iterator
???????operator++(int)?//?后置操作
???????{?return?__normal_iterator(_M_current++);?}

	?

	從上面代碼可以看出，迭代器的前置和后置操作主要有以下兩個區別：

	??返回值：前置操作返回對象的引用，后置操作返回類型為對象，

	??拷貝：前置操作無拷貝操作，后置操作存在一次對象拷貝

	正式因為這兩個原因，前置操作符就地修改對象，而后置操作符將導致創建臨時對象，調用構造函數和析構函數（某些情況下編譯器會做優化，此處不做討論），導致了前置操作和后置操作的性能差異。

	自定義對象

	在上一節中，我們通過迭代器(前置遞增和后置遞增)遍歷對vector進行遍歷，證明了前置遞增的性能優于后置遞增，在本節中，將自定義一個對象，然后進行測試。

	代碼如下（在最開始的自定義對象中，只有整數value_而沒有v_變量，這就導致測試結果很相近，所以為了更加明顯的看出其差異，所以增加了vector）：

	?
class?Object?{
??public:
????Object(int?value)
??????:?value_(value)?{
????????v_.emplace_back(value_);
??????}

????int?Get()?{?return?value_;?}

????Object?&operator++()?//?前置操作
????{
??????++value_;
??????v_.emplace_back(value_);
??????return?*this;
????}

????Object?operator++(int)?//?后置操作
????{
??????Integer?tmp?=?*this;?//?拷貝，注意此處這個拷貝行為以及臨時變量
??????++value_;
??????v_.emplace_back(value_);
??????return?tmp;?//
????}

??private:
????std::vector?v_;
????int?value_;
};

int?main()?{
??std::time_point?t1,?t2,?t3;

??t1?=?std::now();
??Integer?i(0);
??for?(int?j?=?0;?j?

	?

	編譯并運行：

	?
g++?--std=c++11?test.cc?-o?test;?./test
pre?time?cost:?188us
post?time?cost:??29625us

	?

	從上述測試結果可以進一步看出，前置++的性能優于后置++。

	對于內置類型來說，前置++和后置++的性能一樣，這是因為編譯器會對其進行優化；而對于自定義類型的前置和后置操作，你可能會有疑問，為什么編譯器不能像優化內置類型一樣，優化自定義類型呢？這是因為依賴于場景。在某些場景下編譯器可以進行優化（主要是拷貝部分），但是在某些情況下，編譯器無法在不更改代碼含義的情況下對其進行優化。所以，除非需要后置操作，否則建議使用前置操作。

	結語

	在本文中，分別從內置類型的前后置操作和自定義類型的后置操作進行性能對比，結果發現對于內置類型，二者在性能上無差異，而對于自定義類型，前置操作的性能遠優于后置操作。

	除非必須使用i++以滿足編碼場景，否則，在任何情況下都建議使用++i這種前置操作。

	很多人都會認為前置操作性能優于后置操作，這是錯誤的觀點，在此進行下糾正，準確的說法應該是前置操作不會比后置操作性能差。

	審核編輯：湯梓紅

	?
,>