构造函数constructor 与析构函数destructor（五）

我们知道当调用默认拷贝构造函数时，一个对象对另一个对象初始化时，这时的赋值时逐成员赋值。这就是浅拷贝，当成员变量有指针时，浅拷贝就会在析构函数那里出现问题。例如下面的例子：

//test.h
#ifndef MYSTRING_H
#define MYSTRING_H
class MyString
{
    char* m_str;
public:
    MyString(char* str="");
    ~MyString();
    void Display();
};
#endif //MYSTRING_H


//test.cpp
#define _CRT_SECURE_NO_WARNINGS
#include "MyString.h"
#include<iostream>
#include<cstring>
using std::endl;
using std::cout;

MyString::MyString(char* str)
{
    m_str = new char[strlen(str) + 1];
    memset(m_str, 0, strlen(str) + 1);
    strcpy(m_str,str);
}


MyString::~MyString()
{
    cout << "destructor" << endl;
    delete[] m_str;
    //m_str = 0;
    
}

void MyString::Display(){
    cout << m_str << endl;
}

//demo.cpp
#include"MyString.h"
#include<iostream>
using std::endl;
using std::cout;

int main(){
    MyString a("aaaaaa");
    MyString b = a;//调用默认拷贝构造函数，此时b对象，和a对象都是指向同一块内存空间，当析构函数调用时，那么同一块内存空间会被释放两次，从而产生运行时错误。
    a.Display();

    return 0;
}

所以此时默认拷贝构造函数就出现问题，此时应该提供自己的拷贝构造函数，来实施深拷贝。

在类里面添加拷贝构造函数

void MyString::AllocMemAndCpy(char* other){//类里面的工具函数，负责分配内存和拷贝内存中的值
    int len = strlen(other) + 1;
     m_str = new char[len];
    memset(m_str,0,len);
    strcpy(m_str,other);
}

MyString::MyString(const MyString& other){//拷贝构造函数
    AllocMemAndCpy(other.m_str);
}

#include"MyString.h"
#include<iostream>
using std::endl;
using std::cout;

int main(){
    MyString a("aaaaaa");
    MyString b = a;
    a.Display();
    b.Display();
    return 0;
}

此时运行结果就是正确的了，不会出现运行时错误了。

注意：当类中的成员变量有指针时，就要小心了。此时可能就需要拷贝构造函数了，还有就是类中有共享内存时，这是要在析构函数中计算还剩下多少对象，只有剩下最后一个对象被销毁时才能delete那块共享内存。

默认的赋值运算符也是浅拷贝，如果不添加自己的等号运算符，这个程序还是会出现运行时错误

#include"MyString.h"
#include<iostream>
using std::endl;
using std::cout;

int main(){
    MyString a("aaaaaa");
    MyString b = a;
    a.Display();
    b.Display();

    MyString c;
    c.Display();
    c = a;//程序在此处调用了默认的赋值运算符(=operator),默认的赋值运算符也是浅拷贝
          //因此这时出现的运行时错误，也是在调用析构函数时，销毁两次同一块内存，为了使剩下成功运行，必须提供自己的等号运算符。
    
    return 0;
}

上面的代码需要特别注意的是c=a;，这种赋值会造成被删除的两个指针指向同一块内存，在析构函数调用时，同一块内存会被析构函数释放两次。但是如果c=c;，这句代码就不会造成上述的错误，因为自己给自己赋值并没有使两个对象的指针同时指向一个块内存，就自然只会调用一次析构函数，从而释放一次对象。但是为了顾及中情况，应该添加如下的赋值运算符函数。

MyString& MyString::operator=(const MyString& other){
    if (this ==&other)//赋值对象与被赋值对象是同一个对象。即语句a=a;
        return *this;
    delete m_str;//因为赋值对象与被赋值对象不是同一个对象，因此 被赋值对象之前指向的内容应该被删除，即a=c;那么a之前指向的内存应该被释放。
    AllocMemAndCpy(other.m_str);
    return (*this);
}

禁止拷贝：

有时候有些对象时独一无二的，那么是独一无二的对象就禁止拷贝，禁止拷贝的办法就是把operator=() 与拷贝构造函数都声明成私有的，甚至是空函数都可以

#ifndef MYSTRING_H
#define MYSTRING_H
class MyString
{
    char* m_str;
    void AllocMemAndCpy(char* other);
    MyString(const MyString& ms){}
    MyString& operator=(const MyString& other){}

public:
    MyString(char* str="");
    ~MyString();
    
    
    void Display();
};
#endif //MYSTRING_H

此时拷贝构造函数和operator=()都是声明在private中，并且都是空函数。此时Test a=c; b=c;这样的语句在编译时就会报错。

我们知道当我们不提供构造函数时，编译器会提供默认构造函数，当我们不提供拷贝构造函数时，编译器会提供默认拷贝构造函数，那么再创建一个空的类时，编译器到底提供什么呢？

class Empty {};
Empty();             // 默认构造函数
Empty( const Empty& );    // 默认拷贝构造函数
~Empty();             // 默认析构函数
Empty& operator=( const Empty& );  // 默认赋值运算符
Empty* operator&();                       // 取址运算符
const Empty* operator&() const;        // 取址运算符 const

上面的就是一个空类，我们在使用时要注意，有时候这些编译器默认提供的不适合，我们要自己写。