构造函数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

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

巴特西

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

最新文章

热门文章