拷贝构造函数被调用的几种情况：
（1）当用类的一个对象去初始化该类的另一个对象时，系统会自动调用拷贝构造函数；
（2）将一个对象作为实参传递给一个非引用类型的形参，系统会自动调用拷贝构造函数；
（3）从一个返回类为非引用的函数返回一个对象时，系统会自动调用拷贝构造函数；
（4）用花括号列表初始化一个数组的元素时，系统会自动调用拷贝构造函数。
下面逐个举例：
#include<ctime>
#include<cstdlib>
#include<iterator>
#include<algorithm>
#include<iostream>
#include<numeric>
using namespace std;
class MyClass {
public:
MyClass():data(0){}
MyClass(const MyClass& a){
data = a.data;
cout << "拷贝构造函数调用\n";
}
MyClass& operator=(const MyClass&a){
data = a.data;
cout << "调用赋值函数\n";
return *this;
}
int data;
};
int main() {
MyClass a;
MyClass b(a); // 用类的一个对象a去初始化另一个对象b
MyClass c = a; // 用类的一个对象a去初始化另一个对象c，注意这里是初始化，不是赋值
return 0;
}测试
#include<ctime>
#include<cstdlib>
#include<iterator>
#include<algorithm>
#include<iostream>
#include<numeric>
using namespace std;
class MyClass {
public:
MyClass():data(0){}
MyClass(const MyClass& a){
data = a.data;
cout << "拷贝构造函数调用\n";
}
MyClass& operator=(const MyClass&a){
data = a.data;
cout << "调用赋值函数\n";
return *this;
}
int data;
};
void fun1(MyClass a) {
return ;
}
int main() {
MyClass a;
fun1(a); // 形参为类对象，实参初始化形参，调用拷贝构造函数
return 0;
}测试
第3点我看网上都这么说，但是实际调试的时候，发现不会调用拷贝构造函数，于是查了一下。这里默认情况下一般会被编译器优化，减少不必要的拷贝构造，所以，具体的返回值可能会因编译器及编译选项的不同而不同。使用g++编译器，关闭优化g++ xxx.cpp -fno-elide-constructors后执行结果如下（-fno-elide-constructors选项就是用来关闭拷贝优化的）
g++ xxx.cpp -fno-elide-constructors#include<ctime>
#include<cstdlib>
#include<iterator>
#include<algorithm>
#include<iostream>
#include<numeric>
using namespace std;
class MyClass {
public:
MyClass():data(0){}
MyClass(const MyClass& a){
data = a.data;
cout << "拷贝构造函数调用\n";
}
MyClass& operator=(const MyClass&a){
data = a.data;
cout << "调用赋值函数\n";
return *this;
}
int data;
};
MyClass fun2() {
MyClass a;
return a;
}
int main() {
MyClass a;
MyClass d = fun2(); // 函数返回一个类对象时, 这里可能会被编译器优化，从而可能没有调用拷贝构造
return 0;
}不优化编译
这里拷贝构造调用两次，一次是返回非引用的对象时调用的，一次时用返回值初始对象d时调用的。
默认优化编译
什么都不调用。
编译器具体是怎么优化的，一般编译器会先看支不支持拷贝优化，如果不支持，再看有没有定义移动构造函数，如果都没有，就调用拷贝构造函数。更具体的细节可以参考移动语义及拷贝优化的内容。
#include<ctime>
#include<cstdlib>
#include<iterator>
#include<algorithm>
#include<iostream>
#include<numeric>
using namespace std;
class MyClass {
public:
MyClass():data(0){}
MyClass(const MyClass& a){
data = a.data;
cout << "拷贝构造函数调用\n";
}
MyClass& operator=(const MyClass&a){
data = a.data;
cout << "调用赋值函数\n";
return *this;
}
int data;
};
int main() {
MyClass a;
MyClass b;
MyClass arr[2] = {a, b};
return 0;
}编译
#include <iostream>
using namespace std;
class Student{
public:
// 默认构造函数，没有参数
Student(){
this->age = 20;
this->num = 1000;
}
// 初始化构造函数，有参数和参数列表
Student(int a, int n):age(a), num(n){};
// 拷贝构造函数，这里与编译器生成的一致
Student(const Student& s){
this->age = s.age;
this->num = s.num;
}
// 转换构造函数,形参是其他类型变量，且只有一个形参
Student(int r){
this->age = r;
this->num = 1002;
}
~Student(){}
public:
int age;
int num;
};
int main(){
Student s1;
Student s2(18,1001);
int a = 10;
Student s3(a);
Student s4(s3);
printf("s1 age:%d, num:%d\n", s1.age, s1.num);
printf("s2 age:%d, num:%d\n", s2.age, s2.num);
printf("s3 age:%d, num:%d\n", s3.age, s3.num);
printf("s2 age:%d, num:%d\n", s4.age, s4.num);
return 0;
}执行
1) 必须使用成员初始化的四种情况：
2) 成员初始化列表做了什么
1) Empty(); // 缺省构造函数
2) Empty( const Empty& ); // 拷贝构造函数
3) ~Empty(); // 析构函数
4) Empty& operator=( const Empty& ); // 赋值运算符定义一个base类，在base类中将拷贝构造函数和拷贝赋值函数设置成private（或者delete掉）,那么派生类中编译器将不会自动生成这两个函数，且由于base类中该函数是私有的（delete的），因此，派生类将阻止编译器执行相关的操作。
1) 带有默认构造函数的类成员对象，如果一个类没有任何构造函数，但它含有一个成员对象，而后者有默认构造函数，那么编译器就为该类合成出一个默认构造函数。不过这个合成操作只有在构造函数真正被需要的时候才会发生；如果一个类A含有多个成员类对象的话，那么类A的每一个构造函数必须调用每一个成员对象的默认构造函数而且必须按照类对象在类A中的声明顺序进行；
2) 带有默认构造函数的基类，如果一个没有任务构造函数的派生类派生自一个带有默认构造函数基类，那么该派生类会合成一个构造函数调用上一层基类的默认构造函数；
3) 带有一个虚函数的类
4) 带有一个虚基类的类
1) 如果一个类没有任何构造函数，但他含有一个成员对象，该成员对象含有默认构造函数，那么编译器就为该类合成一个默认构造函数，因为不合成一个默认构造函数那么该成员对象的构造函数不能调用；
2) 没有任何构造函数的类派生自一个带有默认构造函数的基类，那么需要为该派生类合成一个构造函数，只有这样基类的构造函数才能被调用；
3) 带有虚函数的类，虚函数的引入需要进入虚表，指向虚表的指针，该指针是在构造函数中初始化的，所以没有构造函数的话该指针无法被初始化；
4) 带有一个虚基类的类。