C++什么时候调用拷贝构造函数和什么时候调用构造函数

拷贝构造函数 都是在什么情况下调用？？？

/*
**
什么时候调用拷贝构造函数
**
*/

#include <iostream>
using namespace std;

//日期类
class Date{

public:
int year,month,day;
Date(){//无参构造
cout << "日期类的构造函数" << endl;
}

~Date(){
cout << "日期的析构函数" << endl;
}

#pragma 拷贝构造函数里面的参数类型必须是引用
Date (const Date& d3){
this->year = d3.year;
this->month = d3.month;
this->day = d3.day;
cout << "拷贝构造函数Date (Date& d3)" << endl;

}

};

void fa(Date d){//在这个参数可以看出会创建一个新的临时变量d对象，相当于Date d = d;后面的d是传进来的，也就是通过相同类型对象来创建对象，所以这里会调用拷贝构造函数。

}

//主函数
int main(){
Date d;
cout << "===== 1 =====" << endl;

fa(d);

cout << "===== 2 =====" << endl;
return 0;
}

运行结果：

日期类的构造函数
===== 1 =====
拷贝构造函数Date (Date& d3)   //fa函数进栈
日期的析构函数                 //弹栈
===== 2 =====
日期的析构函数
Program ended with exit code: 0

再写一个参数是引用类型的函数 fb 如下：

void fb(Date &d){ //这里是给传进的参数创建别名（引用）不会创建新的对象

}

修改主函数如下：

/主函数
int main(){
Date d;
cout << "===== 1 =====" << endl;

fa(d);

cout << "===== 2 =====" << endl;

fb(d);
cout << "===== 3 =====" << endl;
return 0;
}

运行结果可以看出在2和3之间并没有创建新的对象

日期类的构造函数
===== 1 =====
拷贝构造函数Date (Date& d3)
日期的析构函数
===== 2 =====
===== 3 =====
日期的析构函数
Program ended with exit code: 0

再创建一个参数类型是指针类型的函数 fc 如下：

void fc(Date *d){ //传进来的参数是指针类型
//这里创建了一个指针变量放在栈里面了，但是没有创建新的对象,指针指向的是传进来的对象的地址
}

主函数如下：

//主函数
int main(){
Date d;
cout << "===== 1 =====" << endl;

fa(d);

cout << "===== 2 =====" << endl;

fb(d);
cout << "===== 3 =====" << endl;
fc(&d);
cout << "===== 4 =====" << endl;
return 0;
}

运行的结果如下：

日期类的构造函数
===== 1 =====
拷贝构造函数Date (Date& d3)
日期的析构函数
===== 2 =====
===== 3 =====
===== 4 =====
日期的析构函数

从运行结果3和4之间也可以知道并没有创建新的对象。

再来，创建一个返回值类型是Date ，参数是引用类型的函数 fd 如下：

Date fd(Date &r){
return r;
}

主函数中：

//主函数
int main(){
Date d;
cout << "===== 1 =====" << endl;
fa(d);
cout << "===== 2 =====" << endl;
fb(d);
cout << "===== 3 =====" << endl;
fc(&d);
cout << "===== 4 =====" << endl;
fd(d);
cout << "===== 5 =====" << endl;

return 0;
}

运行结果如下：

日期类的构造函数
===== 1 =====
拷贝构造函数Date (Date& d3)
日期的析构函数
===== 2 =====
===== 3 =====
===== 4 =====
拷贝构造函数Date (Date& d3)
日期的析构函数
===== 5 =====
日期的析构函数
Program ended with exit code: 0

从运行结果可知在4和5之间调用了拷贝构造函数创建对象了。那fd这个函数哪里创建对象了呢？ 参数是引用类型，只是起别名，所以并没有创建对象。是返回值这里创建了，返回值类型是Date类型，相当于通过引用 Date = r ;创建了一个匿名的临时对象，所以这里会调用拷贝构造函数。

如果main主函数中修改如下，结果会如何呢？

cout << "===== 4 =====" << endl;
Date d2 = fd(d);
cout << "===== 5 =====" << endl;

理论上fd(d); 这里有一个拷贝构造函数和一个析构函数 还有这一步Date d2 = fd(d); 这里应该还有一个拷贝构造函数

运行结果如下：

日期类的构造函数
===== 1 =====
拷贝构造函数Date (Date& d3)
日期的析构函数
===== 2 =====
===== 3 =====
===== 4 =====
拷贝构造函数Date (Date& d3)
===== 5 =====
日期的析构函数
日期的析构函数
Program ended with exit code: 0

为什么运行结果和我们分析的理论不一样呢？？45之间为什么不是2个拷贝构造函数和1个析构函数呢？（其中一个拷贝构造函数和析构函数是fd的返回值临时变量的）

那是因为编译器做的优化，它把那个临时变量的拷贝构造函数和析构函数相抵消了，所以这里也就只显示了 Date d2 = ...这个的拷贝构造函数。

再写一个返回值是引用类型 参数是引用类型的函数 fe：

Date& fe(Date &r){
return r;
}

主函数中添加如下代码：

<p class="p1"><span class="s1">    cout</span><span class="s2"> << </span><span class="s3">"===== 5 ====="</span><span class="s2"> << </span><span class="s4">endl</span><span class="s2">;</span></p><p class="p2"><span class="s5">    </span><span class="s6">fe</span><span class="s5">(d);</span><span class="s7">//</span><span class="s3">参数</span><span class="s7"> </span><span class="s3">返回值都是引用类型的函数</span></p><p class="p1"><span class="s2">    </span><span class="s1">cout</span><span class="s2"> << </span><span class="s3">"===== 6 ====="</span><span class="s2"> << </span><span class="s4">endl</span><span class="s2">;</span></p><p class="p3"><span class="s3">    </span><span class="s8">Date</span><span class="s3"> d3 = </span><span class="s9">fe</span><span class="s3">(d);</span></p><p class="p1"><span class="s2">    </span><span class="s1">cout</span><span class="s2"> << </span><span class="s3">"===== 7 ====="</span><span class="s2"> << </span><span class="s4">endl</span><span class="s2">;</span></p><p class="p1"><span class="s1">    Date</span><span class="s2"> &d4 = </span><span class="s3">fe</span><span class="s2">(d);  //创建一个引用变量接收函数返回的</span></p><p class="p2"><span class="s4">    </span><span class="s5">cout</span><span class="s4"> << </span><span class="s2">"===== 8 ====="</span><span class="s4"> << </span><span class="s6">endl</span><span class="s4">;</span></p>

运行结果如下：

日期类的构造函数
===== 1 =====
拷贝构造函数Date (Date& d3)
日期的析构函数
===== 2 =====
===== 3 =====
===== 4 =====
拷贝构造函数Date (Date& d3)
===== 5 =====
===== 6 =====
拷贝构造函数Date (Date& d3)
<p class="p1"><span class="s1">===== 7 =====</span></p><p class="p1"><span class="s1">===== 8 =====</span></p><p class="p2"><span class="s1">日期的析构函数</span></p><p class="p2"><span class="s1">日期的析构函数</span></p><p class="p2"><span class="s1">日期的析构函数</span></p><p class="p3"><span class="s1">Program ended with exit code: 0</span></p>

从运行结果可知56之间的只是调用函数fe ，该函数的返回值和参数都是引用类型，并没有创建新的对象。
而在67之间因为通过返回值创建了对象 Date d3 ＝......这里调用了拷贝构造函数。
而78之间因为创建一个引用类型的变量来接收函数返回的，也就是相当于起别名，而并没有创建新对象，所以并没有调用拷贝构造函数

再来，在main函数当中添加如下代码：

cout << "===== 8 =====" << endl;
Date d5[2] = {d,d2};              //数组里面有2个元素，分别用d和d2来赋值
<span class="s1" style="font-family: Arial, Helvetica, sans-serif;">cout</span><span class="s2" style="font-family: Arial, Helvetica, sans-serif;"> << </span><span class="s3" style="font-family: Arial, Helvetica, sans-serif;">"===== 9 ====="</span><span class="s2" style="font-family: Arial, Helvetica, sans-serif;"> << </span><span class="s4" style="font-family: Arial, Helvetica, sans-serif;">endl</span><span class="s2" style="font-family: Arial, Helvetica, sans-serif;">;</span><p class="p2"><span class="s3">    </span><span class="s5">Date</span><span class="s3"> d6[</span><span class="s6">5</span><span class="s3">];</span></p><p class="p1"><span class="s2">    </span><span class="s1">cout</span><span class="s2"> << </span><span class="s3">"===== 10 ====="</span><span class="s2"> << </span><span class="s4">endl</span><span class="s2">;</span></p>

运行结果如下：

<p class="p1"><span class="s1"><span style="font-size:18px;">日期类的构造函数</span></span></p><p class="p2"><span class="s1"><span style="font-size:18px;">===== 1 =====</span></span></p><p class="p2"><span style="font-size:18px;"><span class="s2">拷贝构造函数</span><span class="s1">Date (Date& d3)</span></span></p><p class="p1"><span class="s1"><span style="font-size:18px;">日期的析构函数</span></span></p><p class="p2"><span class="s1"><span style="font-size:18px;">===== 2 =====</span></span></p><p class="p2"><span class="s1"><span style="font-size:18px;">===== 3 =====</span></span></p><p class="p2"><span class="s1"><span style="font-size:18px;">===== 4 =====</span></span></p><p class="p2"><span style="font-size:18px;"><span class="s2">拷贝构造函数</span><span class="s1">Date (Date& d3)</span></span></p><p class="p2"><span class="s1"><span style="font-size:18px;">===== 5 =====</span></span></p><p class="p2"><span class="s1"><span style="font-size:18px;">===== 6 =====</span></span></p><p class="p2"><span style="font-size:18px;"><span class="s2">拷贝构造函数</span><span class="s1">Date (Date& d3)</span></span></p><p class="p2"><span class="s1"><span style="font-size:18px;">===== 7 =====</span></span></p><p class="p2"><span class="s1"><span style="font-size:18px;">===== 8 =====</span></span></p><p class="p2"><span style="font-size:18px;"><span class="s2">拷贝构造函数</span><span class="s1">Date (Date& d3)</span></span></p><p class="p2"><span style="font-size:18px;"><span class="s2">拷贝构造函数</span><span class="s1">Date (Date& d3)</span></span></p><p class="p2"><span class="s1"><span style="font-size:18px;">===== 9 =====</span></span></p><p class="p1"><span class="s1"><span style="font-size:18px;">日期类的构造函数</span></span></p><p class="p1"><span class="s1"><span style="font-size:18px;">日期类的构造函数</span></span></p><p class="p1"><span class="s1"><span style="font-size:18px;">日期类的构造函数</span></span></p><p class="p1"><span class="s1"><span style="font-size:18px;">日期类的构造函数</span></span></p><p class="p1"><span class="s1"><span style="font-size:18px;">日期类的构造函数</span></span></p><p class="p2"><span class="s1"><span style="font-size:18px;">===== 10 =====</span></span></p><p class="p1"><span class="s1"><span style="font-size:18px;">日期的析构函数</span></span></p><p class="p1"><span class="s1"><span style="font-size:18px;">日期的析构函数</span></span></p><p class="p1"><span class="s1"><span style="font-size:18px;">日期的析构函数</span></span></p><p class="p1"><span class="s1"><span style="font-size:18px;">日期的析构函数</span></span></p><p class="p1"><span class="s1"><span style="font-size:18px;">日期的析构函数</span></span></p><p class="p1"><span class="s1"><span style="font-size:18px;">日期的析构函数</span></span></p><p class="p1"><span class="s1"><span style="font-size:18px;">日期的析构函数</span></span></p><p class="p1"><span class="s1"><span style="font-size:18px;">日期的析构函数</span></span></p><p class="p1"><span class="s1"><span style="font-size:18px;">日期的析构函数</span></span></p><p class="p1"><span class="s1"><span style="font-size:18px;">日期的析构函数</span></span></p><p class="p3"><span class="s1"><span style="font-size:18px;">Program ended with exit code: 0</span></span></p>

在结果89之间看到有2个拷贝构造函数。因为是通过同类型对象来创建对象的，所以会调用2个拷贝构造函数。
在9和10 之间会看到5个构造函数，这里不是拷贝构造而是直接创建对象，所以是构造函数。

如果再在main函数里面添加如下的代码：

<span style="font-size:24px;">    </span><span style="font-size:18px;"><span class="s1" style="font-family: Arial, Helvetica, sans-serif;">cout</span><span class="s2" style="font-family: Arial, Helvetica, sans-serif;"> << </span><span class="s3" style="font-family: Arial, Helvetica, sans-serif;">"===== 10 ====="</span><span class="s2" style="font-family: Arial, Helvetica, sans-serif;"> << </span><span class="s4" style="font-family: Arial, Helvetica, sans-serif;">endl</span><span class="s2" style="font-family: Arial, Helvetica, sans-serif;">;</span></span><p class="p2"><span style="font-size:18px;"><span class="s3">    d = d2;  </span><span class="s5">//</span><span class="s6">赋值操作</span></span></p><p class="p1"><span style="font-size:18px;"><span class="s2">    </span><span class="s1">cout</span><span class="s2"> << </span><span class="s3">"===== 11 ====="</span><span class="s2"> << </span><span class="s4">endl</span><span class="s2">;</span></span></p><p class="p2"><span style="font-size:18px;"><span class="s3">    </span><span class="s7">Date</span><span class="s3"> *d7 = </span><span class="s8">new</span><span class="s3"> </span><span class="s7">Date</span><span class="s3">;</span></span></p><p class="p2"><span style="font-size:18px;"><span class="s3"></span></span></p><p class="p1"><span style="font-size:18px;"><span class="s1">    delete</span><span class="s2"> d7;</span></span></p><p></p><p class="p1"><span style="font-size:18px;"><span class="s2">    </span><span class="s1">cout</span><span class="s2"> << </span><span class="s3">"===== 12 ====="</span><span class="s2"> << </span><span class="s4">endl</span><span class="s2">;</span></span></p>

运行结果：

<p class="p1"><span class="s1">===== 10 =====</span></p><p class="p1"><span class="s1">===== 11 =====</span></p><p class="p2"><span class="s1">日期类的构造函数</span></p><p class="p2"><span class="s1"></span></p><p class="p1"><span class="s1">日期的析构函数</span></p><p></p><p class="p1"><span class="s1">===== 12 =====</span></p>

运行结果10 和 11之间什么都没有打印，也就是并没有创建新的对象。
而11和12之间只有一个构造函数，Date *d7是指针，指向一个对象，在创建这个对象的时候就调用了构造函数。

如果把11和12当中 delete d7注释掉 然后通过d7来创建对象，main函数中增加如下代码呢：

cout << "===== 12 =====" << endl;
Date *d8 = new Date(*d7);
delete d8;
cout << "===== 13 =====" << endl;

运行结果如下：

<p class="p1"><span class="s1">===== 12 =====</span></p><p class="p1"><span class="s2">拷贝构造函数</span><span class="s1">Date (Date& d3)</span></p><p class="p2"><span class="s1">日期的析构函数</span></p><p class="p1"><span class="s1">===== 13 =====</span></p>

在12和13之间是通过*d7得到同类型的对象然后创建对象，所以这里会调用拷贝构造函数。

要搞明白：
什么时候调用构造函数 ？ 什么时候调用拷贝构造函数 ？ 什么时候什么都不调用？？