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

析构函数定义

析构函数：与构造函数功能相反（不理解构造函数看以看专栏里面），析构函数不是完成对对象本身的销毁，局部对象销毁工作是由编译器完成 的。而对象在销毁时会自动调用析构函数，完成对象中资源的清理工作 。

析构函数是特殊的成员函数，其特征如下：

1. 析构函数名是在 类名前加上字符 ~ ；

2. 无参数无返回值类型 ；

3. 一个类 只能有一个析构函数 。若未显式定义，系统会自动生成默认的析构函数。注意：析构函数不能重载；

4. 对象生命周期结束时， C++ 编译系统系统 自动调用析构函数 。

比如在我们的栈里面，malloc的空间在对象声明周期结束过后会自动调用我们所写的析构函数，不用再去手动的调用我们自己写的Destory函数。

typedef int DataType;

class Stack
{
public:
 Stack(size_t capacity = 3)
 {
     _array = (DataType*)malloc(sizeof(DataType) * capacity);
     if (NULL == _array)
     {
          perror("malloc申请空间失败!!!");
          return;
     }
     _capacity = capacity;
     _size = 0;
 }

 void Push(DataType data)
 {
     CheckCapacity();
     _array[_size] = data;
     _size++;
 }


 ~Stack()
 {
     if (_array)
     {
         free(_array);
         _array = NULL;
         _capacity = 0;
         _size = 0;
 }
 }

private:
 DataType* _array;
 int _capacity;
 int _size;
};

void TestStack()
{
 Stack s;
 s.Push(1);
 s.Push(2);
}

出了TestStack函数自动调用析构销毁

那么编译器自动生成的析构函数又有什么作用？

默认生成析构函数特点： 跟构造函数类似，内置类型不处理自定义类型成员回去调用他的析构函数

拷贝构造函数定义

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

class Date
{

public:
 Date(int year = 1900, int month = 1, int day = 1)
 {
 _year = year;
 _month = month;
 _day = day;
 }

void print()
{
  cout<<_year<<" "<<_month<<" "<<_day<<endl;
}

private:
 int _year;
 int _month;
 int _day;
};

我们如何对上面的Date进行拷贝？我们可以这样写

int main()
{

  Date d1(2);

  Date d2 = d1;
  d2.print();

  Date d3(d1);
  d3.print();

  return 0; 
}

 在上面的代码中，我们并未编写拷贝构造函数，构造函数未显式定义

编译器将会生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。

在编译器生成的默认拷贝构造函数中，内置类型是按照字节方式直接拷贝的，而自定义类型是调

用其拷贝构造函数完成拷贝的。

那么如果我们要自己编写上述拷贝构造函数，要怎么写？下面的写法对吗？

class Date
{
public:
 Date(int year = 1900, int month = 1, int day = 1)
 {
 _year = year;
 _month = month;
 _day = day;
 }

 Date(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);

    return 0;
}

我们可以自己去运行拷贝一下，这样写是错误的

 这种写法错误的原因是

 这是一个无限递归的过程，是个死循环。我们对其进行修改

 Date(Date d) // 错误写法：编译报错，会引发无穷递归
 {
     _year = d._year;
     _month = d._month;
     _day = d._day;
 }

 Date(const Date& d)//Date& d引用传参，相当于传地址Date* d,前面加const是为了防止被修改
 {
 _year = d._year;
 _month = d._month;
 _day = d._day;
 }

同学们看到这里或许会有疑问，编译器生成的默认拷贝构造函数已经可以完成字节序的值拷贝了 ，还需要自己显式实现吗？当然像日期类这样的类是没必要的。对于下面这种情况就很有必要了

typedef int DataType;

class Stack
{
public:
 Stack(size_t capacity = 10)
 {
 _array = (DataType*)malloc(capacity * sizeof(DataType));
 if (nullptr == _array)
 {
 perror("malloc申请空间失败");
 return;
 }
 _size = 0;
 _capacity = capacity;
 }

 void Push(const DataType& data)
 {
 // CheckCapacity();
 _array[_size] = data;
 _size++;
 }

 ~Stack()
 {
 if (_array)
{
 free(_array);
 _array = nullptr;
 _capacity = 0;
 _size = 0;
 }
 }

private:
 DataType *_array;
 size_t _size;
 size_t _capacity;
};

int main()
{
 Stack s1;
 s1.Push(1);
 s1.Push(2);

 Stack s2(s1);
 return 0; 
}

我们运行上面的程序，并不能成功的完成，那么为什么？

我们用s2对s1进行了拷贝，发生了值拷贝，两个指针的值相同，指向了同一空间，在生命周期结束后，调用两次析构函数，对同一空间释放了两次，发生错误。

浅拷贝

一个对象会影响另一个对象，析构两次程序崩溃

根本原因就是发生了浅拷贝，我们需要深拷贝，后续的文章将会进一步讲解。