C++中浅复制、深复制与String类实现

浅复制和深复制

有关浅复制与深复制的定义为：对类进行复制的时候按位复制，即把一个对象各数据成员的值原样复制到目标对象中。当类中涉及到指针类型数据成员的时候，往往就会产生指针悬挂问题。

看如下代码：

#include <iostream>
using namespace std;

class A{
	
	public:
	
	A(int a_n)
	{
		a = new int(a_n);
	}
	
	void setnum(int a_n){ *a = a_n; }
	
	int getnum(){ return *a;}	
	
    private:
        int* a;
};

int main()
{
	A a1(3);
	A b1=a1;
	
	cout<< "a1.getnum : " << a1.getnum() << endl;
	cout<< "b1.getnum : " << b1.getnum() << endl;
	
	a1.setnum(5);
	cout<< "a1.setnum(5) , a1.getnum : " << a1.getnum() << endl;
	cout<< "a1.setnum(5) , b1.getnum : " << b1.getnum() << endl;
	
	return 0;
}

执行代码如下：

        只对a1对象做了setnum(5)，但影响了两个对象a1、a2中的成员变量；这是由于b1=a1执行的是浅复制，此时a1.a和b1.a指向的是同一个内存地址。还有就是如果在析构函数里面有对内存的释放。就会出现内存访问异常。因为一块内存空间会被释放两次！

参考以下代码c_person.cpp理解：

#include <iostream>
#include <string.h>
using namespace std;
class person{
private:
    char *name;
    int age;
public:
    person(const char *Name,int Age)
    {
        name=new char[strlen(Name)+1];
        strcpy(name,Name);
        age=Age;
        cout<<"construct ..."<<endl;
    }
    ~person()
    {
        cout<<"destruct ..."<<age<<endl;
        delete name;
    }
    void dispaly()
    {
        cout<<name<<" "<<age<<endl;
    }
    void setage(int x)
    {
        age=x;
    }
};
int main()
{
    person p1("test",23);
    person p2=p1;
    p1.setage(10);
    p1.dispaly();
    p2.dispaly();
    
    return 0;
}

运行结果如下：

 从运行结果我们可以看到程序只是调用了一次构造函数，但是却执行了两次析构函数，不符合预期期望。由于没有定义构造函数，在执行p2=p1的时候，系统采用默认拷贝构造函数(默认的拷贝构造函数不会为新对象重新分配新的内存空间)，即按位的拷贝方式将p1中各数据成员的值拷贝到p2的对应成员中，所以导致p1.name=p2.name（指向了同一内存），此时类person的构造函数只会执行一次，这种拷贝方式我们称为浅拷贝。

当程序运行结束时，由析构函数执行的规律可知先构造的后执行，所以先执行p2的析构函数，此时系统将p2.name指向的存储单元释放，在执行p1析构函数的时候，p1.name所指向的内存单元又被释放，这样就会造成同一块内存空间被释放两次，造成错误，p1.name也就成了悬挂指针。

解决这一问题就需要对p1进行深拷贝，即构造拷贝函数，让对象p2在拷贝p1的时候获取新的内存空间。

#include <iostream>
#include <string.h>
using namespace std;
class person{
private:
    char *name;
    int age;
public:
    person(const char *Name,int Age)
    {
        name=new char[strlen(Name)+1];
        strcpy(name,Name);
        age=Age;
        cout<<"construct ..."<<endl;
    }

    person(const person& oPerson)        //自定义的拷贝构造函数，
    {
        name=new char[strlen(oPerson.name)+1];
        strcpy(name, oPerson.name);
        age=oPerson.age;
        cout<<"copy construct ..."<<endl;
    }

    ~person()
    {
        cout<<"destruct ..."<<age<<endl;
        delete name;
    }
    void dispaly()
    {
        cout<<name<<" "<<age<<endl;
    }
    void setage(int x)
    {
        age=x;
    }
};
int main()
{
    person p1("test",23);
    person p2=p1;
    p1.setage(10);
    p1.dispaly();
    p2.dispaly();
    
    return 0;
}

运行结构：

从运行结果可以看到符合预期期望，从拷贝构造函数定义可以知道，对类对象的复制，重新为新对象分配了新的内存单元。深拷贝和浅拷贝可以简单理解为：如果一个类拥有资源，当这个类的对象发生复制过程的时候，资源重新分配，这个过程就是深拷贝，反之，没有重新分配资源，就是浅拷贝。

String类实现

一般是要求实现构造函数、拷贝构造函数、赋值函数、析构函数这几个非常重要的部分。因为String里涉及动态内存的管理，默认的拷贝构造函数在运行时只会进行浅复制，即只复制内存区域的指针，会造成两个对象指向同一块内存区域的现象。如果一个对象销毁或改变了该内存区域，会造成另一个对象运行或者逻辑上出错。这时就要求程序员自己实现这些函数进行深复制，即不止复制指针，需要连同内存的内容一起复制。

具体代码如下：

/******************
Author : lijd
data   : 2019-06-28
*******************/
#include <string.h>
#include <assert.h>
#include <iostream>

using namespace std;

class String
{
public:
	String(const char *str = NULL);	//通用构造函数
	String(const String &str);		//拷贝构造函数(深赋值)
	~String();						//析构函数

	String operator+(const String &str) const;	//重载+
	String& operator=(const String &str);		//重载=
	String& operator+=(const String &str);		//重载+=
	bool operator==(const String &str) const;	//重载==
	char& operator[](int n) const{assert(n <= length - 1); return data[n]; }	//重载[](内联函数)

	size_t size() const{ return length; }		//长度接口(内联函数)
	const char* c_str() const{ return data; }	//数据接口(内联函数)

	friend istream& operator>>(istream &is, String &str);//输入
	friend ostream& operator<<(ostream &os, String &str);//输出

private:
	char *data;		//字符串
	size_t length;	//长度
};

String::String(const char *str)
{
	if(str == NULL)
	{
		length = 0;
		data = new char[1];
		*data = '\0';
	}else{
		length = strlen(str);
		data = new char[length + 1];
		strcpy(data, str);
	}
}

String::String(const String &str)
{
	length = str.size();
	data = new char[length + 1];
	strcpy(data, str.c_str());
}

String::~String()
{
	delete []data;
	length = 0;
}

String String::operator+(const String &str) const
{
	String newString;
	newString.length = length + str.size();
	newString.data = new char[newString.length + 1];
	strcpy(newString.data, data);
	strcat(newString.data, str.data);
	return newString;
}

String& String::operator=(const String &str)
{
	if(this == &str)
	{
		return *this;
	}
	
	delete []data;
	length = str.size();
	data = new char[length + 1];
	
	strcpy(data, str.c_str());
	
	return *this;
}

String& String::operator+=(const String &str)
{
	if(str.size() == 0)
	{
		return *this;
	}
	
	length += str.size();
	char *t_data = new char[length + 2];
	
	strcpy(t_data, data);
	strcat(t_data, str.c_str());
	
	delete []data;
	data = t_data;
	
	return *this;
}

bool String::operator==(const String &str) const
{
	if(length == str.size() && !strcmp(data, str.c_str()))
	{
		return true;
	}
	
	return false;
}

istream& operator >>(istream &is, String &str)
{
	char temp[1024];
	is >> temp;
	str.length = strlen(temp);
	str.data = new char[str.length + 1];
	strcpy(str.data, temp);
	
	return is;
}

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

int main()
{
	String s;	
	cin >> s;	
	cout << s << ": " << s.size() << endl;

	char a[] = "Hello", b[] = "World!";
	String s1(a), s2(b);	
	cout << s1 << " + " << s2 << " = " << s1 + s2 << endl;

	String s3 = s1 + s2;
	if (s1 == s3)	cout << "First: s1 == s3" << endl;
	s1 += s2;
	if (true == (s1 == s3))	cout << "Second: s1 == s3" << endl;
	
	cout<<s1[3]<<endl;
	
	return 0;
}

运行结果如下：