构造函数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) + ];
     memset(m_str, , strlen(str) + );
     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 ;
 }

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

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

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

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

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

上面的代码需要特别注意的是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

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