C++你最好不要做的幾點小結

1、最好不要使用引用傳回值

有同學在傳遞的參數的時候使用引用方式傳遞，避免了臨時對象的建立，提高了效率，那麼在傳回值的時候能不能使用引用呢？

看如下代碼

複製代碼 代碼如下: class Rational{
public:
Raional( int numerator = 0, int denominator =1);
...
private:
int d, d;
friend Rational operator* (const Rational& lhs, const Raional& rhs) ;
};
Rational Rational::operator* (const Rational& lhs,const Raionl&rhs)
{
return Rational result(lhs.n*rhs.n,lhs.d*rhs.d);
}
｝　　

這個類就是我們前面所介紹的有理數類。這裡想想會發生一次類的構造與類的析構，那麼如果使用引用就可以避免這個問題嗎？達到提高效率嗎？

函數建立新對象有兩種方法，一個是在棧（statck）中建立,一個是在堆（heep）中建立。

複製代碼 代碼如下: People p(a,b) //棧中建立
People *p = new People(a,b) //堆中建立

現在首先考慮在棧中建立，但是這個建立的變數是一個局部變數，會在退出函數之前銷毀。複製代碼 代碼如下: const Rational& operator* (const Rational& lhs, const Rational & rhs)
{
Rational result(lhs.n*rhs.n,lhs.d*rhs.d);
return result;
}　　

在函數內以stack方式空間建立對象是局部對象，任何函數如果返回一個引用指向某個局部對象，都會發生錯誤。因為局部對象在函數退出之前被銷毀了，意味著reference所指的對象不存在。
於是考慮在堆中建立 複製代碼 代碼如下:const Rational& operator* (const Rational& lhs, const Rational & rhs)
{
Rational* result=new Rational(lhs.n*rhs.n,lhs.d*rhs.d);
return *result;
}

現在又發現了一個問題，new出來的對象由誰來delete？好這個問題先佔時不考慮看下面情況複製代碼 代碼如下: Rational w,x,y,z;
w=x*y*z; 　　

這裡同時一個語句調用了兩次operator*，意味著new了兩次，也就需要delete兩次。但是這裡沒有合理的辦法讓opertaor*使用者進行那些delete調用，因為無法讓使用者擷取返回的指標，這將導致資源泄漏。
於是考慮返回一個引用，其指向定義於函數內部的static Rational對象。複製代碼 代碼如下:const Rational & operator*(const Rational& lhs,const Rational & rhs)
{
static Rational result;
result = ...;
return result;
}

那麼顯而易見就是多線程，在多線程環境下，這樣寫安全嗎？好如果說不關多線程。那麼如下代碼會發生什嗎？複製代碼 代碼如下: bool operator == (const Rational& lhs, const Rational& rhs);
...
Raional a,b,c,d;
if((a*b) == (c*d)
{
...
}

上述if語句運算式無論a,b,c,d為何值都是true，因為它們都指向同一個靜態值。

2、最好不要將所有變數定義放在語句開頭。

有同學可能上過C語言課程，喜歡學習C的，喜歡將所有的變數定義放在開頭，但是在C++中，我建議最好不要這樣做，因為定義一個變數時，程式便註定需要進行一次構造與析構。例如在下面程式：大概意思我們允許1米8以下並且年齡在60歲以下的同學買票進入。

複製代碼 代碼如下: class People{...};
class Ticket{...};
bool Isvalid(const People&p){...}
void Banding(const People& p,Ticket& t);
Ticket buyTicket(const People& p)
{
Ticket t;
if(Isvalid(p)){ return NULL };
//資訊與票綁定
Banding(p,&t);
return t;
}

假如這裡檢測買票人條件不符合，那麼就不能進入買票從而進行資訊與綁定操作，那麼這裡Ticket t語句就讓該函數白白承受了一次Ticket構造成本與析構的成本。
所以最好不要將變數提前定義，最好在要用到的時候定義，避免不必要的效能開銷。上面例子改成下面這樣即可：

複製代碼 代碼如下: class People{...};
class Ticket{...};
bool Isvalid(const People&p){...}
void Banding(const People& p,Ticket& t);
Ticket buyTicket(const People& p)
{
if(Isvalid(p)){ return NULL };
Ticket t;
//資訊與票綁定
Banding(p,&t);
return t;
}

3、最好不要做過多的類型轉換

C++規則的設計目標之一是，保證“類型錯誤”絕不可能發生。理論上程式通過編譯，就表示它並不企圖在任何身上執行任何不安全，荒謬的操作。可惜類型轉換破環了類型系統，它可能導致任何種類麻煩，有些非常麻煩。就例如本文最後一個代碼例子。C和C++都支援隱形類型轉換，同時C++有四種顯示轉換操作符。成員函數與非成員函數的抉擇裡有介紹。但是建議最好不要做過多的類型轉換，能避免就避免。類型轉換往往也不是按照你的意思，首先看一個例子：

複製代碼 代碼如下: #include <iostream>
class base
{
public:
base():a(0),b(0){}
base(const int& x,const int& y)
:a(x),b(y){}
virtual void init()
{
a=5;
b=5;
std::cout<<"in base a value is "<<a<<std::endl;
std::cout<<"in base b value is "<<b<<std::endl;
}

int get_a() const
{
return a;
}

int get_b() const
{
return b;
}
private:
int a;
int b;
};

class derived:public base
{
public:
derived(int x,int y):base(x,y){}
void init()
{
static_cast<base>(*this).init();
}
};

運行結果為
in base a value is 5
in base b value is 5
a value is 2
b value is 2

這裡將derived類型轉化為base，但是調用base::init()函數並不是當前對象上的函數，而是早前轉型動作所建立的一個"*this對象的base的副本，所以當我們嘗試改變對象內容，其實改變的是副本內容，其對象內容並沒有被改變。

如何解決這個問題呢？我們可以直接聲明調用基類的函數

複製代碼 代碼如下:class derived:public base
{
public:
derived(int x,int y):base(x,y){}
void init()
{
//static_cast<base>(*this).init();
base::init();
}
};

運行結果為：
in base a value is 5
in base b value is 5
a value is 5
b value is 5

或許此時你記起來應該使用dynamic_case（如果看過以前的文章的話：它用於安全地沿著繼承關係向下進行類型轉換）。使用dynamic_cast直接出現錯誤。

複製代碼 代碼如下: class derived:public base
{
public:
derived(int x,int y):base(x,y){}
void init()
{
//static_cast<base>(*this).init();
//base::init();
dynamic_cast<base*>(this)->init();
}
};

運行結果為：

段錯誤 (（主儲存空間）資訊轉儲)假設一個類有五層的單繼承關係，如果在該對象上執行dynaic_cast,那麼會有多達五次的strcmp調用，深度或者多重繼承的越多，成本越高。之所以需要dynamic_cast是因為想在derived class對象上執行 derived class操作函數，但是目前只有一個指向base的指標或者引用，這個時候可以用它們來處理。