临时对象与拷贝构造函数

拷贝构造函数主要应用在以下场景中： 

1 根据一个同类型的对象新建一个对象时。

注意与=赋值运算符的区别，=不会生成一个新的对象。下面实例：

#include<iostream> using namespace std; class Single { private: int a; public: Single():a(0){ cout << "default constructing..." << endl; } Single(int i):a(i){ cout << "constructing with parameter ..." << i << endl; } Single(const Single& s){ cout << "copy constructing..." << endl; a = s.a; } Single& operator = (Single& r){ cout << "operatoring..." << endl; a = r.a; return *this; } }; int main() { Single o1; Single o2(1); o2 = o1; Single o3 = o1; return 0; }  

运行结果： 

default constructing...

constructing with parameter ...1

operatoring...

copy constructing... 

2 复制一个对象，将它作为实参传给一个函数（注意对象引用不会）。

3 从函数返回时复制一个对象（注意对象引用不会）。下面实例：

#include<iostream>using namespace std;class Single{ private: int a; public: Single():a(0){cout << "default constructing..." << endl;} Single(int i):a(i){cout << "constructing with parameter ..." << i << endl;}Single(const Single& s){cout << "copy constructing..." << endl;a = s.a;}Single& operator = (Single& r){ cout << "operatoring..." << endl;a = r.a;return *this;}};Single play1(Single s){return s;}Single play2(Single& s){return s;}Single& play3(Single s){return s;}Single& play4(Single& s){return s;}int main(){ Single o1;//default constructing... cout << "play1" << endl;play1(o1);cout << "play2" << endl;play2(o1);cout << "play3" << endl;play3(o1);cout << "play4" << endl;play4(o1);return 0;} 

运行结果：

default constructing...

play1

copy constructing...//实参传给一个函数

copy constructing...//返回一个对象

play2

copy constructing...//返回一个对象

play3

copy constructing...//实参传给一个函数

play4 

下面是一道面试题：

#include<iostream>using namespace std;class Single{ private: int a; public: Single():a(0){cout << "default constructing..." << endl;} Single(int i):a(i){cout << "constructing with parameter ..." << i << endl;}~Single(){cout << "destructing with parameter ..." << a << endl;}Single(const Single& s){cout << "copy constructing..." << endl;a = s.a;}Single& operator = (const Single& r){ cout << "operatoring..." << endl;a = r.a;return *this;}};Single play(Single s){return s;}int main(){play(1);cout << "......" << endl;Single o2 = play(2);cout << "......" << endl;Single o3;o3 = play(3);return 0;} 

运行结果：

constructing with parameter ...1//使用1新建实参s 

copy constructing...//返回一个对象，调用复制构造函数

destructing with parameter ...1//参数s析构

destructing with parameter ...1//调用函数main没有定义变量接收返回值，所以会用一个临时对象保存返回的对象的值。被调用函数结束时，临时对象被析构

......

constructing with parameter ...2//使用2新建实参s

copy constructing...//返回一个对象，调用复制构造函数

destructing with parameter ...2//参数s析构

......

default constructing...//Single o3;

constructing with parameter ...3//使用3新建实参s

copy constructing...//返回一个对象，调用复制构造函数

destructing with parameter ...3//参数s析构

operatoring...//赋值

destructing with parameter ...3//临时对象析构

destructing with parameter ...3//o3析构

destructing with parameter ...2//o2析构

下面的例子来自Thinking in C++：

#include <cstdio>#include <iostream>#include <fstream>using namespace std;ofstream out("howmany2.out");class HowMany2 {string name; // Object identifierstatic int objectCount;public:HowMany2(const string& id = "") : name(id) {++objectCount;print("HowMany2()");}~HowMany2() {--objectCount;print("~HowMany2()");}// The copy-constructor:HowMany2(const HowMany2& h) : name(h.name) {name += " copy";++objectCount;print("HowMany2(const HowMany2&)");}void print(const string& msg = "") const {if(msg.size() != 0)out << msg << endl;out << '\t' << name << ": "<< "objectCount = "<< objectCount << endl;}};int HowMany2::objectCount = 0;// Pass and return BY VALUE:HowMany2 f(HowMany2 x) {x.print("x argument inside f()");out << "Returning from f()" << endl;return x;}int main() {HowMany2 h("h");out << "Entering f()" << endl;HowMany2 h2 = f(h);h2.print("h2 after call to f()");out << "Call f(), no return value" << endl;f(h);out << "After call to f()" << endl;} ///:~

运行的结果为：

HowMany2()
h: objectCount = 1
Entering f()
HowMany2(const HowMany2&)
h copy: objectCount = 2
x argument inside f()
h copy: objectCount = 2
Returning from f()
HowMany2(const HowMany2&)
h copy copy: objectCount = 3
~HowMany2()
h copy: objectCount = 2
h2 after call to f()
h copy copy: objectCount = 2
Call f(), no return value
HowMany2(const HowMany2&)
h copy: objectCount = 3
x argument inside f()
h copy: objectCount = 3
Returning from f()
HowMany2(const HowMany2&)
h copy copy: objectCount = 4
~HowMany2()                                                     //临时对象
h copy copy: objectCount = 3
~HowMany2()                                                     //内部对象
h copy: objectCount = 2
After call to f()
~HowMany2()
h copy copy: objectCount = 1
~HowMany2()
h: objectCount = 0

其中临时对象的析构要早于内部对象，而Thinking in C++中顺序相反。总之，临时对象的生存期一定要尽可能的短。