C++中类的6个默认成员函数（构造函数、析构函数、拷贝构造函数、赋值重载等）

如果一个类中什么成员都没有，简称为空类。任何一个类在我们不写的情况下，都会自动生成下面6个默认成员函数。

构造函数

概念

对于以下的日期类：

class Date{
   public:
   void SetDate(int year,int month,int day ){
           _year=year;
           _month=month;
           _day=day;
    }
   
   void Display(){
             cout<<_year<<"-"<<_month<<"-"<<_day<<endl;
    }
  private:
      int _year;
      int _month;
      int _day;
};

int main(){
     Date d1;
     d1.SetDate(2019,7,29);    
     d1.Display(); 
     Date d2;    
     d2.SetDate(2020,1,1);    
     d2.Display();    
     return 0;
}

对于Date类，可以通过SetDate公有的方法给对象设置内容，但是如果每次创建对象都调用该方法设置信息，未免有点麻烦。

构造函数是一个特殊的成员函数，名字与类名相同,创建类类型对象时由编译器自动调用，保证每个数据成员都有 一个合适的初始值，并且在对象的生命周期内只调用一次。

2.2 特性
构造函数是特殊的成员函数，需要注意的是，构造函数的虽然名称叫构造，但是需要注意的是构造函数的主要任务并不是开空间创建对象，而是初始化对象。

其特征如下：
1.函数名与类名相同。
2. 无返回值。
3. 对象实例化时编译器自动调用对应的构造函数。
4. 构造函数可以重载。

class Date { 
public :    
// 1.无参构造函数   
   Date () {}        
// 2.带参构造函数    
Date (int year, int month , int day ){
        _year = year ;        
        _month = month ;       
        _day = day ;    
         } 
private :    
   int _year ;    
   int _month ;    
   int _day ; 
}

void TestDate() {    
     Date d1; // 调用无参构造函数    
     Date d2 (2019, 7, 29); // 调用带参的构造函数        
   // 注意：如果通过无参构造函数创建对象时，对象后面不用跟括号，否则就成了函数声明    
   //    Date d3(); 声明了d3函数，该函数无参，返回一个日期类型的对象    
  
}

5.如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成。

class Date { 
public:    
/*   
 // 如果用户显式定义了构造函数，编译器将不再生成    
Date (int year, int month, int day) {
        _year = year;
        _month = month;       
         _day = day;    }    
 */
private:    
    int _year;   
    int _month;   
    int _day; 
      };
 void Test() {
    // 没有定义构造函数，对象也可以创建成功，因此此处调用的是编译器生成的默认构造函数 
     Date d;
      }

6.无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认成员函数。

class Date { 
public:    
 Date(){        
  _year = 1900 ;        
  _month = 1 ;        
  _day = 1;    }        
 Date (int year = 1900, int month = 1, int day = 1){
  _year = year;
  _month = month;
  _day = day;    
 }
 
private :    
 int _year ;    
 int _month ;    
 int _day ; 
};
 
// 以下测试函数是否能通过编译？ 
void Test() {    
 Date d1; 
}

7.关于编译器生成的默认成员函数，在我们不实现构造函数的情况下，编译器会生成默认的构造函数。但是看起来默认构造函数又没什么用？对象调用了编译器生成的默认构造函数，但是对象_year/_month/_day，依旧是随机值。也就说在这里编译器生成的默认构造函数并没有什么用吗？？
解答：C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语法已经定义好的类型：如 int/char…，自定义类型就是我们使用class/struct/union自己定义的类型，观察下面的程序，会发现编译器生成默认的构造函数会对自定义类型成员_t调用的它的默认成员函数

class Time { 
public:    
  Time(){
   cout << "Time()" << endl;
   _hour = 0;        
   _minute = 0;        
   _second = 0;    
 };
private:    
   int _hour;       
   int _minute;    
   int _second; 
};

class Date { 
private:    // 基本类型(内置类型)    
   int _year;    
   int _month;    
   int _day;
   Time _t;  // 自定义类型
};

int main(){
Date d;    
return 0;
}

3.析构函数

3.1 概念
与构造函数功能相反，析构函数不是完成对象的销毁，局部对象销毁工作是由编译器完成的。而对象在销毁时会自动调用析构函数，完成类的一些资源清理工作。
3.2 特性
析构函数是特殊的成员函数。
其特征加粗样式如下：
1.析构函数名是在类名前加上字符 ~。
2. 无参数无返回值。
3. 一个类有且只有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。
4. 对象生命周期结束时，C++编译系统系统自动调用析构函数。

typedef int DateType;
class SeqList(){
public:
   SeqList(int capacity = 10){ 
         _pData = (DataType*)malloc(capacity * sizeof(DataType));        
         assert(_pData);                
         _size = 0;        
         _capacity = capacity;    
      }
   ~SeqList() { 
           if (_pData){
              free(_pData );   // 释放堆上的空间            
              _pData = NULL;   // 将指针置为空           
              _capacity = 0;          
              _size = 0;        
            }   
      } 
 
private :    
   int* _pData ;    
   _t _size;    
   size_t _capacity;
}

5. 关于编译器自动生成的析构函数，是否会完成一些事情呢？下面的程序我们会看到，编译器生成的 默认析构函数，对会自定类型成员调用它的析构函数。

 class String{ 
 public:    
      String(const char* str = "jack"){
   _str = (char*)malloc(strlen(str) + 1);        
   strcpy(_str, str);    
}
 
    ~String(){        
  cout << "~String()" << endl;        
  free(_str);    
 } 
private:    
 char* _str; 
};
 
class Person{ 
private:    
 String _name;    
 int    _age; 
};
 
int main(){
 Person p; 
 return 0;
}

4. 拷贝构造函数

4.1 概念 ：
只有单个形参，该形参是对本类类型对象的引用(一般常用const修饰)，在用已存在的类类型对象 创建新对象时由编译器自动调用。（在创建对象时，可否创建一个与一个对象一某一样的新对象）

4.2 特征
拷贝构造函数也是特殊的成员函数，其特征如下：

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

class Date{
public:
 Date(int year=2019,int month =7,int day=30){
      _year=year;
      _month=month;
      _day=day;
 }
 
 Date(const Date& d){
      _year=d._year;
      _month=d._month;
      _day=d._day;
 }
private:
 int _year;
 int _month;
 int _day;
};
int main(){
    Date d1;
    Date d2(d1);
    Date d3(d2);
    return 0;
}

3. 若未显示定义，系统生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝我们叫做浅拷贝，或者值拷贝。

class Date{
public:
 Date(int year=2019,int month =7,int day=30){
      _year=year;
   _month=month;
   _day=day;
 }
private:
 int _year;
 int _month;
 int _day;
};
int main(){
    Date d1;
 // 这里d2调用的默认拷贝构造完成拷贝，d2和d1的值也是一样的。 
 Date d2(d1);
 Date d3(d2);
 return 0;
}

4.编译器生成的默认拷贝构造函数已经可以完成字节序的值拷贝了，我们还需要自己实现吗？像日期类这样的类是没必要的。但下面的类会崩溃，需要用到深拷贝。

class String{
public:    
String(const char* str = "jack"){ 
   _str = (char*)malloc(strlen(str) + 1);
   strcpy(_str, str);    
}
~String(){
   cout << "~String()" << endl;
   free(_str);    } 
private:    
   char* _str; 
};

int main(){
    String s1("hello");    
    String s2(s1); 
}

5.赋值运算符重载

5.1 运算符重载
C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。
函数名字为：关键字operator后面接需要重载的运算符符号。
函数原型：返回值类型 operator操作符(参数列表)
注意：
1.不能通过连接其他符号来创建新的操作符：比如operator@
2.重载操作符必须有一个类类型或者枚举类型的操作数
3.用于内置类型的操作符，其含义不能改变，例如：内置的整型+，不 能改变其含义
4.作为类成员的重载函数时，其形参看起来比操作数数目少1成员函数的 操作符有一个默认 的形参this，限定为第一个形参
5.* 、:: 、sizeof 、?: 、. 注意以上5个运算符不能重载。

class Date { 
public:
 Date(int year = 1900, int month = 1, int day = 1){
  _year = year;        
  _month = month;        
  _day = day;    
 }  
// bool operator==(Date* this, const Date& d2)    
// 这里需要注意的是，左操作数是this指向的调用函数的对象 
  bool operator==(const Date& d2){
        return _year == d2._year
                  && _month == d2._month
                   && _day == d2._day;   
  } 
  private:    
 int _year;    
 int _month;    
 int _day; 
};
int main(){
 Date d1(2019,7,30);
 Date d2(2019,8,1);
 cout<<d1==d2<<endl;
 return 0;
}

5.2 赋值运算符重载

class Date{ 
public: 
   Date(int year = 1900, int month = 1, int day = 1){
        _year = year;        
        _month = month;
        _day = day;    
   }        
   Date (const Date& d){
       _year = d._year;
       _month = d._month;
       _day = d._day;    
   }        
   Date& operator=(const Date& d){
      if(this != &d){
         _year = d._year;
         _month = d._month;
         _day = d._day;
      }    
   } 
private:
   int _year;
   int _month;
   int _day;
}; 

赋值运算符主要有四点：

1. 参数类型
2. 返回值
3. 检测是否自己给自己赋值
4. 返回*this
5. 一个类如果没有显式定义赋值运算符重载，编译器也会生成一个，完成对象按字节序的值拷贝。

class Date{
public:
  Date(int year = 1900, int month = 1, int day = 1){
   _year = year;
   _month = month;
   _day = day;
  } 
//private:    
 int _year;    
 int _month;    
 int _day; 
};
int main(){
 Date d1;
 Date d2(2018,10, 1);        
 // 这里d1调用的编译器生成operator=完成拷贝，d1和d2的值也是一样的。    
 d1 = d2;
 cout<<d1._day<<endl;
 system("pause");
    return 0; 
}