關于C++臨時對象的概念

2020-02-24 14:37:25

字體：大中小

來源：轉載

供稿：網友

關于C++臨時對象或許大家對這個概念還不太了解，那我們就得花一些時間來了解這臨時對象了，因為對于接下來C++的學習挺重要的，在這個學習過程中，或許能增加見識，體驗其中的樂趣喔。

首先看下面一端代碼：

?#include 
?void swap( int &a,int &b)
?{
???? int temp;
???? temp=a;
???? a=b;
???? b=temp;
?}

?int main(int argc,char** argv)
?{
???? int a=1,b=2;
???? swap(a,b);
???? std::cout ???? return 0;
?}

?結果為
?2-----1??
?可能大多數園友，認為"int temp"是"臨時對象"，但是其實不然，"int temp"僅僅是swap函數的局部變量。

臨時對象是代碼中看不到的，但是實際程序中確實存在的對象。臨時對象是可以被編譯器感知的。

為什么研究臨時對象？
主要是為了提高程序的性能以及效率，因為臨時對象的構造與析構對系統開銷也是不小的，所以我們應該去了解它們，知道它們如何造成，從而盡可能去避免它們。

臨時對象建立一個沒有命名的非堆對象會產生臨時對象。（不了解什么是堆對象和非堆對象，可以參考C++你最好不要做的這一博文，這里面有介紹。）這種未命名的對象通常在三種條件下產生:為了使函數成功調用而進行隱式類型轉換時候、傳遞函數參數和函數返回對象時候。

那么首先看看為了使函數成功調用而進行隱式類型轉換。

?#include 
? int countChar(const std::string & s,const char c)
? {
????? int count=0;
????? for(int i=0;i ????? {
????????? if(*(s.c_str( )+i) == c)
????????? {
????????????? count++;
???????? }
??? }
???? return count;
?}

?int main(int argc,char** argv)
?{
???? char buffer[200];
???? char c;
???? std::cout ???? std::cin>>buffer;
???? std::cout ???? std::cin>>c;
???? int count=countChar(buffer,c);
???? std::count ???? return 0;
?}

結果為：

這里調用函數countChar(const std::string& s,const char& c)，那么我們看看這個函數的形參是const std::string &s,形參類型為const std::string,但是實際上傳遞的是char buffer[200]這個數組。其實這里編譯器為了使函數調用成功做了類型轉換，char *類型轉換為了std::string類型，這個轉換是通過一個賦值構造函數進行的，以buffer做為參數構建一個std::string類型的臨時對象。當constChar返回時，即函數撤銷，那么這個std::string臨時對象也就釋放了。但是其實從整個程序上來說臨時對象的構造與釋放是不必要的開銷，我們可以提高代碼的效率修改一下代碼避免無所謂的轉換。所以知道臨時對象的來源，可以對程序性能上有一個小小提升。

?? 注意僅當通過傳值方式傳遞對象或者傳遞常量引用參數，才會發生這類型的轉換，當傳遞非常量引用的參數對象就不會發生。因為傳遞非常量的引用參數的意圖就是想通過函數來改變其傳遞參數的值，但是函數其實是改變的類型轉換建立的臨時對象，所以意圖無法實現，編譯器干脆就直接拒絕。

第二種情況是大家熟悉的函數傳遞參數的時候，會構造對應的臨時對象。看下面一段代碼運行的結果想必就一清二楚了。

?#include
?class People
?{
???? public:
???????? People(std::string n,int a)
???????? :name(n),age(a)
???????? {
???????????? std::count ???????? }
??????? People( )
??????? {
??????????? std::count ??????? }
??????? People(const People& P)
??????? {
??????????? name=p.name;
??????????? age=p.age;
??????????? std::cout ??????? }
??????? std::string name;
??????? int age;
};

void swap(People p1,People p2)
{
??? People temp;
??? temp.age=p1.age;
??? temp.name=p1.name;
??? p1.age=p2.age;
??? p1.name=p2.name;
??? p2.age=temp.age;
??? p2.name=temp.name;
}

int main(int argc, char ** argv)
{
??? People p1("tom",18),p2("sam",19);
??? swap(p1,p2);
??? return 0;
}

結果為：

這里分析下前面兩個"h2"是通過調用構造函數People(std::string n,int a)打印出來的，而"h3"就是通過調用復制構造函數People(const People&)而建立臨時對象打印出來的，h1是調用默認構造函數People( )打印出來的。那么怎么避免臨時對象的建立呢？很簡單，我們通過引用實參而達到目的

void swap(People &p1,People &p2)
第三種情景就是函數返回對象時候。這里要注意臨時對象的創建是通過復制構造函數構造出來的。

例如?? const Rationanl operator+(Rationanl a,Rationanl b)該函數的返回值的臨時的，因為它沒有被命名，它只是函數的返回值。每回必須為調用add構造和釋放這個對象而付出代價。

?#include 
?class Rationanl
?{
???? public:
???????? Rationanl(int e,int d)
???????? :_elemem(e),_denom(d)
???????? {
???????????? std::cout ???????? }
???????? void show( ) const;
???????? int elemem() const {return _elemem;}
???????? int denom() const {return _denom;}
???????? void? setElemon(int e){_elemon=e;}
???????? void? setDenom(int d) {_denom=d;}
???????? Rationanl(const Rationanl &r);
???????? Rationanl & operator=(const Rationanl &r);
???? private:
???????? int _elemem;
???????? int _denom;
?};
?Rationanl::Rationanl(const Rationanl &r)
?{
???? setElemon(r.elemon( ));
???? setDenom(r.denom( ) );
???? std::cout ?}
?Rationanl & Rationanl::operator=(const Rationanl &r)
?{
???? setElemon(r.elemon( ));
???? setDenom(r.denom( ) );
???? std::cout ???? return *this;
?}

?void Rationanl::show( )
?{
???????? std::cout ?}
?const Rationanl operator*(const Rationanl lhs,const Rationanl rhs)
?{
???? return Rational result(lhs.elemen*rhs.elemen,rhs.denom*rhs.denom);
?}

?int main(int argc,char **argv)
?{
???? Rationanl r1(1,2),r2(1,3)
???? Rationanl r3=r1*r2;??? //GCC做了優化，沒有看到臨時變量。編譯器直接跳過建立r3,使用賦值符號
???? r3.show( );
???? //相當于? (r1*r2).show( );
???? return 0;
?}