先寫一個日期類，把建構函式，拷貝建構函式，解構函式，賦值運算子的過載都寫上，程式碼如下：

class Date{
public:
	//建構函式
	Date() {
		cout << "Date()" << endl;
	}
	//拷貝建構函式
	Date (const Date & d) {
		cout << "Date(cont Date& d)" << endl;
	}
	//解構函式
	~Date() {
		cout << "~Date" << endl;
	}
	//賦值運算子過載
	Date& operator=(const Date& d) {
		cout << "operator=" << endl;
		return *this;
	}
private:
	int _year;
	int _month;
	int _day;
};
 

注意，函式裡面都只是輸出了一個字串，用來顯示呼叫情況

建構函式是建立一個物件的時候呼叫的，如果沒有寫，編譯器會自動生成一個預設的建構函式，例：

Date d;

建立一個物件，它會呼叫一次建構函式，如圖：

拷貝建構函式也是建構函式，它是在一個物件被建立的時候呼叫，有以下兩種使用方式：

Date d1;
Date d2 = d1;
Date d3(d1);

接下來看一種特殊的情況:

Date();

它被構造之後立即就被銷燬了

接下來看這種情況：

Date d = Date();

有了先前的分析，應該是一次建構函式，一次拷貝建構函式，是真正 的結果如圖：

只有一次建構函式，並沒有拷貝建構函式

注意，這裡是編譯器優化的效果，首先這裡直接建立了一個Date()，這是一個匿名的物件，然後要進行拷貝構造的時候編譯器進行了優化

為了測試正確與否，我們先改一下建構函式和拷貝建構函式，程式碼如下：

	//建構函式
	Date(int year = 1800, int month = 1, int day = 1) {
        cout << "Date()" << endl;
        _year = year;
        _month = month;
        _day = day;
    }
	//拷貝建構函式
	Date (const Date & d) {
		cout << "Date(cont Date& d)" << endl;
		_year = d._year;
		_month = d._month;
		_day = d._day;
 }

 

再更改一下測試用例：

Date d3 = Date(1,1,1);

如圖我們發現，這個表示式呼叫 了Date(1,1,1),然後並沒有再呼叫拷貝建構函式，但是，d3還是和這個匿名的物件值一樣， 所以，編譯器的優化是這樣的：直接讓d3成為這個匿名的物件。

什麼意思呢？相當於給匿名物件起了個名字叫d3

這就是編譯器的一種優化

注意，我們說過拷貝建構函式呼叫有兩種方式：

Date d1;
Date d2 = d1;
Date d3(d1);

但是在這裡，雖然Date d = Date();編譯器是優化了的，但是另一種方式是行不通的！

像這樣：

Date d3(Date());

為什麼呢？我也不知道~反正vs2013的編譯器是不認的，建構函式拷貝建構函式都沒有呼叫

d3直接就沒有建立成功

好了~不如我們把這些歸咎於編譯器吧~反正也不知道為啥

但是，這樣是可以建立成功的：

為什麼？別問我，我不知道，誰要是知道了可以評論下

接下來我們定義兩個函式，進一步去測試

void fun1(Date d)
{}

Date func2()
{
    Date ret;
    return ret;
}

Date d1;
fun1(d1);

場景二：

Date d2 = func2();

函式在返回值的時候，會有一個臨時變數，如圖：

像這樣，所以應該是ret呼叫一次建構函式，臨時變數呼叫一次拷貝構造，然後ret再呼叫一次解構函式，然後臨時變數賦值給d2的時候再呼叫一次拷貝建構函式

但是，結果卻不是這樣的，因為編譯器優化了，如圖：

編譯器優化後，沒有臨時變數的拷貝構造了，如圖：

好了，接下來看場景三：

Date d3;
d3 = func2();

細細一看，這個好像並沒有優化，為什麼呢？

因為d3已經被建立好了，無法進行優化

我們改一下fun2函式，程式碼如下：

Date func2()
{
	return Date();
}

Date()這個是不是似曾相識~

好了我們來測試一下，場景一：

Date d2 = func2();

結果如下：

只有一次建構函式？？？

如果認真看了上面的例子，這個例子肯定很簡單了，編譯器會優化，沒有臨時變數的拷貝，如圖：

這個不就是Date d2 = Date();

場景二：

Date d3;

d3 = func2();

如圖，d3一次建構函式，Date()一次建構函式，因為Date()是匿名的物件而且剛建立就要返回，所以這裡就直接優化了

呼叫方式基本就講完了，附上一個題：

class AA
{
public:
	AA()
	{
	}
	AA(const AA& a)
	{
		cout<<"AA(const AA& a)"<<endl;
	}
};
AA f (AA a)
{
	return a ;
}
void Test1 ()
{
	AA a1 ;
	a1 = f(a1);
}
void Test2 ()
{
	AA a1 ;
	AA a2 = f(a1);
}

void Test3 ()
{
	AA a1 ;
	AA a2 = f(f(a1));
}

程式碼如上，問：所有的Test函式總共呼叫了幾次建構函式，幾次拷貝建構函式，幾次解構函式

首先來看Test1();

一次建構函式，兩次拷貝構造，一次賦值運算子的過載，過程如下圖：

接下來看Test2();

一次建構函式，一次拷貝建構函式，零次賦值運算子的過載

因為這裡物件a2是新建立的，所以編譯器會進行優化，如下圖：

接下來看最難的Test3()；程式碼如下：

void Test3 ()
{
	AA a1 ;
	AA a2 = f(f(a1));
}

可以看到這裡有一個巢狀，我們先一步一步分析

顯示a1拷貝給函式f的形參a，然後返回a，返回a的時候有個臨時變數tmp(假設),然後a拷貝給tmp，tmp再拷貝給外面的函式的形參a，這個a和上面做同樣的動作，思路分析如圖：

執行一下看結果圖：

結果是隻有三次拷貝建構函式，和上面一樣，編譯器肯定進行了優化

優化的情況下肯定不需要臨時變量了，思路如圖：

完！