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

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

原因

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

以整型為例：

?

//?++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;??
}??

?

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

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

內(nèi)置類型

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

pre_inc.cc

?

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

	?

	post_inc.cc

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

	?

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

	

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

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

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

	?

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

	

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

	“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.

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

	自定義類型

	迭代器

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

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

	?

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

	?
#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

	?

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

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

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

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

	?

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

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

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

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

	自定義對象

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

	代碼如下（在最開始的自定義對象中，只有整數(shù)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

	?

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

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

	結語

	在本文中，分別從內(nèi)置類型的前后置操作和自定義類型的后置操作進行性能對比，結果發(fā)現(xiàn)對于內(nèi)置類型，二者在性能上無差異，而對于自定義類型，前置操作的性能遠優(yōu)于后置操作。

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

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

	審核編輯：湯梓紅

	?
,>