重載函數時使用臨時對象作爲參數是否是一種好的做法？

Question

鑑於原型：

void foo(int i); 
void foo(int i, const std::string &s); 

實現：

void foo(int i) 
{ 
    foo(i, std::string()) ; 
    //! ^^^^^^^^^^^^^ ^here? 

    // nothing more. 

     } 
//! ^here? 

void foo(int i, const std::string &s) 
{ 
    //do something 
} 

哪裏由std::string()創建的臨時對象走出去的範圍有多大？以這種方式重載函數是一種很好的做法嗎？

更新：

讓我解釋的情況一點點。作爲練習，我正在嘗試編寫一個類似std::vector的類，而不使用模板。它唯一的類型是std::string。班級正文可在another question找到。

在實現resize()成員函數，我發現std::vector似乎使用了兩個功能：

所以我不知道我是否應該使用的，而不是單一的一個兩個功能。

Answer 1

我不認爲這是不好的做法，特別是如果你使foo(int i)內聯。這是最好的時候，我能想到的理由：當您創建的指針的功能，如果你聲明的第二個參數默認情況下，你只能有指針接受2個參數的功能。

臨時值活着纔有作爲函數調用的參數。

inline void foo(int i) 
{ 
    foo(i, std::string()); 
} 

void foo(int i, const std::string &s) 
{ 
    //do something 
} 

Answer 2

不，這不是一個好的做法，至少在這個特定的情況下。使用一個單一的功能，併爲參數的默認值，而不是兩個功能，其中一個似乎只存在提供一個默認的說法：

void foo(int i, const std::string &s = "") 
{ 
    //do something 
} 

Answer 3

唯一的「危險」，在傳遞一個暫時的const&發生，如果該函數創建一個生存函數調用本身，其存儲本身const&的對象。

認爲

class A 
{ 
    const string& a; 
public: 
    A(const string& a) :a(a) {} 
    void act() { .... /* use a */ } 
}; 

A* foo(const string& s) 
{ return new A(s); } 

int main() 
{ 
    A* pa = foo(string()); 
    //here, pa->act() will act on a dangling reference. 
} 

如果您foo功能只是使用字符串，但不保留供以後使用的參考，通過臨時是絕對安全的。

如果發生這種情況使用「開機功能」或默認臨時值使得對生成的代碼沒有什麼區別。

在這一點上，使用一個或兩個函數更多的是風格和機會問題：在進一步開發過程中，兩個函數有多少區別？

如果答案是「沒有：第二個功能是非常頻繁的情況下，只需定義（或快捷方式）」比默認值完美地完成這項工作。

如果答案是「讓我們回落到其他功能現在，後來更具體」，然後的兩個函數被preferrable。

默認值都是然而，這不是的情況下，有機會的功能是模板，你想類型推演工作：

template<class C, class T> 
void fn(int i, basic_string<C,T>& s = ????); 

你不能使用的std :: string（），因爲它不會爲C其他工作比char，並且不能使用std::basic_string<C,T>()，因爲它不允許在調用fn(5)時知道C和T應該是什麼。

所以，你會最終了

void fn(int i) { fn(i,string()); } 

。