c/c++整理--类String的构造函数、析构函数和赋值函数

类string的原型

class string
{
public:
	string(const char* str = NULL);		//普通构造函数
	string(const string &other);		//复制构造函数
	~string(void);						//析构函数
	string & operater = (const string &other);	//赋值函数
private:
	char *m_string;						//私有成员，保护字符串
};

自己编写String的构造函数、析构函数和赋值函数：

#include <iostream>
#include <string.h>

using namespace std;

class String
{
public:
	String(const char* str = NULL);		//普通构造函数
	String(const String &other);		//复制构造函数
	~String(void);						//析构函数
	String & operator = (const String &other);	//赋值函数
private:
	char *m_string;						//私有成员，保护字符串
};

String::~String(void)
{
	cout<<"Destructing"<<endl;
	if(m_string != NULL)				//如果m_string不为NULL，释放内存
	{
		delete[] m_string;
		m_string = NULL;				//释放后置为NULL
	}
}

String::String(const char* str)
{			
	cout<<"Constructing"<<endl;			
	if(str == NULL)						//如果str为NULL，存字符串""
	{
		m_string = new char[1];			//分配一个字节
		*m_string = '\0';				//赋值为字符串结束符
	}
	else
	{
		m_string = new char[strlen(str)+1];		//分配空间容纳str
		strcpy(m_string, str);					//复制str到私有成员
	}
}

String::String(const String& other)
{
	cout<<"Constructing Copy"<<endl;
	m_string = new char[strlen(other.m_string)+1];		//分配空间容纳str内容
	strcpy(m_string, other.m_string);					//复制str到私有成员
}

String & String::operator = (const String& other)
{
	cout<<"operator = Function"<<endl;
	if(this == &other)									//如果对象与other是同一个对象
	{
		return *this;
	}
	delete[] m_string;
	m_string = new char[strlen(other.m_string)+1];
	strcpy(m_string, other.m_string);
	return *this;
}

int main()
{
	String a("hello");
	String b("world");
	String c(a);
	c=b;
	
	return 0;
}

（1）普通构造函数：判断了传入的参数是否为NULL，如果是NULL，初始化一个字节的空字符串（包括结束符‘\0’）；如果不是，分配足够大小长度的堆内存来保存字符串。

（2）复制构造函数：只是分配足够大小的堆内存来保护字符串。

（3）析构函数：如果类私有成员m_string不为NULL，释放m_string指向的堆内存，并且为了避免产生野指针，将m_string赋空。

（4）赋值函数：首先判断当前对象与引用传递对象是否为同一对象，如果是直接返回；否则，先释放当前对象的堆内存，然后分配足够大小的堆内存赋值字符串。

执行结果：

Constructing
Constructing
Constructing Copy
operator = Function
Destructing
Destructing
Destructing