C++面向对象高级开发（侯捷）——三大函数：拷贝构造，拷贝赋值，析构

本文链接：https://blog.csdn.net/qq_29821795/article/details/119581911

三大函数：拷贝构造、拷贝复制、析构

当类中含有指针，则不能用系统默认的那一套拷贝构造，拷贝赋值。需要自定义这三个函数：拷贝构造、拷贝复制、析构。
string类，内部含有一个指针，以这个指针来指向任意长度的字符串数据。

class String
{
public:
    String(const char* cstr =0);  //普通的构造函数
    String(const String& str);  //拷贝构造函数
    String& operator=(const String& str);  //拷贝赋值函数
    ~String();  //析构函数
    char* get_c_str() const { return m_data; }
private:
    char* m_data;  //定义成一个指针，可以有更好的发展空间，因为不确定将来的字符串到底有多长。
};

构造函数和析构函数(ctor和dtor)

inline
String::String(const char* cstr = 0)
{
    if(cstr)  {
        m_data = new char[strlen(cstr)+1];
        strcpy(m_data,cstr);
    }
    else  {  //未指定初值
        m_data = new char[1];
        *m_data = '\0';
    }
}

inline
String::~String()  //离开作用域，调用析构函数
{
    delete[] m_data;  //释放掉因创建对象动态分配的内存
}

指针指向别处，导致原本所指区域被放养的现象（此即内存泄漏，相当于失去对这片区域的掌控，且这片区域还白白地占着宝贵的资源）。析构函数会在此类对象被释放时自动执行，如下的析构函数表示，释放此对象指针所指的区域。

拷贝构造函数(copy ctor)

这里我们要自己定义拷贝构造函数。若自定义的类中有指针，系统默认的构造函数只会浅拷贝，将指针拷贝。这里会产生两个问题：产生内存泄漏；产生别名，很危险。

//拷贝构造函数
inline
String::String(const String& str)
{
    m_data=new char[ strlen(str.m_data) + 1 ];
    strcpy(m_data, str.m_data);
}

{
    String s1("hello");  
    String s2(s1); //直接取另一个object的private data(兄弟之间互为friend)
//  String s2 = s1;
}

拷贝赋值函数(copy assignment operator)

拷贝赋值操作过程：

将原来的空间清空；
分配一个和拷贝的对象的一样大的空间；
将内容拷贝过去。

为什么带有指针的类就得有拷贝构造呢？string类如下图，是一个指针指向一个数组数据。
在这里插入图片描述
试想这么一种情况，已有string类 a，string类 b，然后执行代码b = a。我们的目的是想开辟两片内存，只是这两片区域存放着相同的数据，两个指针分别指向这两片区域。但是按照 =操作符的默认执行过程，会按照下图进行，实际执行结果会变成：b的指针指向a的指针指的区域。这样不仅达不到我们想要的目的，还会造成问题：1.b的指针最初指向的那片区域还没收回来，2.b相当于是一个a的别名，没达到我们想要的效果。
在这里插入图片描述
所以为了达成目的：开辟两片内存，只是这两片区域存放着相同的数据，两个指针分别指向这两片区域。写出代码如下：

//拷贝赋值函数
inline
string& string::operator = (const string& str) //拷贝赋值
{
	if (this == &str) { return *this; }   //检查是不是在自我赋值，不仅仅为了提高效率，而且是为了正确性，假设发生自我赋值，会发生错误，指向一个已删除的对象
										
	delete[] m_data;	                       //把指针指的老值杀了
	m_data = new char[strlen(str.m_data) + 1];  //建立新地盘
	strcpy(m_data, str.m_data);					//给新地盘放上复制的新值
		return  *this;
}

为了实现 a=b，按照三步来进行，先把a的指针指向的那片区域收回来，再按照b指针指向区域内容的长度new 一个新的char数组，最后将a指针指向的区域的内容拷贝至b指针指向的char数组中。

if那一行是为啥呢？因为有这么一种情况，如果有人写代码 a = a。按照我们的需求，这一行代码我们想要他什么也不做即可。但是按照以上代码三步走，第一步就把a指向数组给释放了，第二三步完全进行不下去了，和我们的需求大相径庭。所以为了防止这种情况，我们写上这一行，如果遇到自我赋值，什么都不做直接返回即可。

new和delete

new：产生一个对象是先分配内存再调用构造函数。
delete：先调用析构函数再释放内存。
new[]必须和delete[]搭配使用[即array new一定搭配array delete]，不然会出错。

String类

#ifndef __MYSTRING__
#define __MYSTRING__

class String
{
public:                                 
   String(const char* cstr=0);                     
   String(const String& str);                    
   String& operator=(const String& str);         
   ~String();                                    
   char* get_c_str() const { return m_data; }
private:
   char* m_data;
};

#include <cstring>

inline
String::String(const char* cstr)
{
   if (cstr) {
      m_data = new char[strlen(cstr)+1];
      strcpy(m_data, cstr);
   }
   else {   
      m_data = new char[1];
      *m_data = '\0';
   }
}

inline
String::~String()
{
   delete[] m_data;
}

inline
String& String::operator=(const String& str)
{
   if (this == &str)
      return *this;

   delete[] m_data;
   m_data = new char[ strlen(str.m_data) + 1 ];
   strcpy(m_data, str.m_data);
   return *this;
}

inline
String::String(const String& str)
{
   m_data = new char[ strlen(str.m_data) + 1 ];
   strcpy(m_data, str.m_data);
}

#include <iostream>
using namespace std;

ostream& operator<<(ostream& os, const String& str)
{
   os << str.get_c_str();
   return os;
}

#endif