C++ 构造函数、析构函数、拷贝构造函数

• 构造函数
• • 概念及特性
• 析构函数
• • 概念
  • 特性
• 拷贝构造函数
• • 概念
  • 特征

对于类中的成员变量，可以通过调用方法来给对象赋值，但如果每次创建对象都得调用一次，未免有些麻烦
那有没有方法能在实例化对象时就调用并能将信息设置进去呢

	
  1 #include 
  2 using namespace std;
  3                                       
  4 class Test                            
  5 {                                     
  6   public:                             
  7     Test()                            
  8     {                                 
  9       cout << "this is a test" << endl;
 10     }                                  
 11   private:                            
 12     int m_data;                       
 13 };                                    
 14                                       
 15 int main()                            
 16 {                                     
 17   Test t;                             
 18   return 0;                           
 19 } 

构造方法（构造函数）是一个特殊的成员函数，虽然名字叫做构造函数，但它的主要任务并不是开空间创建对象，而是初始化对象
它的特性在于：
	1、名字必须与类相同
	2、不能有任何返回值
	3、对象实例化时编译器自动调用对应的构造函数，且在对象的生命周期中只调用一次
	4、构造函数可以重载

    1 #include 
  2 using namespace std;
  3 
  4 class Test
  5 {
  6   public:
  7     Test()
  8     {
  9       m_data = 10;
 10     }
 11     Test(int data)
 12     {
 13       m_data = data;
 14     }
 15     int Getdata()
 16     {
 17       return m_data;
 18     }
 19   private:
 20     int m_data;
 21 };
 22 
 23 int main()
 24 {
 25   Test t1;
 26   Test t2(100);
 27   cout << "m_data of t1 = " << t1.Getdata() << endl;
 28   cout << "m_data of t2 = " << t2.Getdata() << endl; 
 29   return 0;
 30 }

这样我们就完成了在实例化对象时对成员变量的初始化

与构造函数功能相反，析构函数不是完成对象的销毁，局部对象销毁工作是由于对象在销毁时会自动调用析构函数，完成类的一些资源清理工作

析构函数是特殊的成员函数
特征如下：
	1、析构函数名是在类名前加上字符“~”
	2、无参数无返回值（不能重载）
	3、一个类有且只有一个析构函数
	4、对象生命周期结束时，C++编译系统自动调用析构函数

  1 #include 
  2 using namespace std;
  3 
  4 class Test
  5 {
  6   public:
  7     Test()
  8     {
  9       m_data = 10;
 10     }
 11     ~Test()
 12     {
 13       cout << "end" << endl;
 14     }
 15     int Getdata()
 16     {
 17       return m_data;
 18     }
 19   private:
 20     int m_data;
 21 };
 22 
 23 int main()
 24 {
 25   Test t1;
 26   cout << "m_data of t1 = " << t1.Getdata() << endl;   
 27   return 0;
 28 }

构造函数：只有单个形参，该形参是对本类类型对象的引用（一般常用const修饰），再用已存在的类类型对象创建新对象时由编译器自动调用

  1 #include 
  2 using namespace std;
  3 
  4 class Test
  5 {
  6   public:
  7     Test()				//构造函数
  8     {
  9       m_data = 10;
 10     }
 11     Test(const Test &t)	//拷贝构造函数
 12     {
 13       m_data = t.m_data;
 14     }
 15     ~Test()
 16     {
 17 
 18     }
 19     int Getdata()
 20     {
 21       return m_data;
 22     }
 23   private:
 24     int m_data;
 25 };
 26 
 27 int main()
 28 {
 29   Test t1;
 30   Test t2(t1);	//等价于Test t2 = t1;
 31   cout << "m_data of t1 = " << t1.Getdata() << endl;
 32   cout << "m_data of t2 = " << t2.Getdata() << endl;
 33   return 0;
 34 }

为什么要使用const修饰？
答：为了保证引用的对象不被修改

1、拷贝构造函数是构造函数的一个重载形式
2、拷贝构造函数的参数只有一个且必须使用引用传参，使用传值方式会引发无穷递归调用