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< 
 我们如何对上面的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进行了拷贝，发生了值拷贝，两个指针的值相同，指向了同一空间，在生命周期结束后，调用两次析构函数，对同一空间释放了两次，发生错误。 
   浅拷贝 
   一个对象会影响另一个对象，析构两次程序崩溃 
    
   根本原因就是发生了浅拷贝，我们需要深拷贝，后续的文章将会进一步讲解。

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

Java相关栏目本月热门文章