C/C++学习笔记：String类的构造函数、析构函数和赋值函数

已知：String 类 

class String 
{ 
public: 
      String(const char *str = NULL); // 通用构造函数
     String(const String &another); // 拷贝构造函数
     ~ String(); // 析构函数
     String& operator=(const String &rhs); // 赋值函数
private: 
     char *m_data; // 用于保存字符串
}; 

#include <iostream>

class String
{
public:
	String (const char *str = NULL); //通用构造函数
	String (const String &another);  //拷贝构造函数
	~String();						  //析构函数
	String& operator = (const String &rhs);	 //赋值函数
protected:
private:
	char *m_data; //用于保存字符串
};

String::String(const char *str)
{
	if ( NULL == str)
	{
		m_data = new char[1];  对空字符串自动申请存放结束标志'\0'的空间
		if ( NULL == m_data )  //内存是否申请成功
		{
			std::cout << "Application of memory failure" << std::endl;
			exit(1);
		}
		m_data[0] = '\0';
	}
	else
	{
		int length = strlen(str);
		m_data = new char[length + 1];
		if (NULL == m_data)
		{
			std::cout << "Application of memory failure" << std::endl;
			exit(1);
		}
		strcpy(m_data, str);
	}
}

String::String(const String &another)  //输入参数为const型 
{
	int length = strlen(another.m_data);
	m_data = new char[length + 1];
	if (NULL == m_data)
	{
		std::cout << "Application of memory failure" << std::endl;
		exit(1);
	}
	strcpy(m_data, another.m_data);
}

//析构函数
String::~String()
{
	delete [] m_data;
}

String& String::operator=(const String &rhs)  //输入参数为const型 
{
	if ( this == &rhs )	 //检查自赋值 
	{				  
		return *this;
	}
	int length = strlen(rhs.m_data);
	delete [] m_data;	//释放原来的内存资源
	m_data = new char[length+1];
	if (NULL == m_data)
	{
		std::cout << "Application of memory failure" << std::endl;
		exit(1);
	}
	strcpy(m_data, rhs.m_data);
	return *this;	  //返回本对象的引用
}



// 测试
void main()
{
	String A;
	String B("CSDN");
	system("pause");
}

引申：用C++实现一个String类，它具有比较，连接，输入，输出功能，并且提供一些测试用例。

//String.h
#ifndef STRING_H
#define STRING_H

#include<iostream>
using namespace std;

class String
{
public:
	String();								//默认构造函数
	String(int n, char c);					 //普通构造函数
	String(const char* source);				 //普通构造函数
	String(const String& s);				 //复制构造函数
	String& operator= (char* s);			  //重载=，实现字符串赋值
	String& operator= (const String& s);	  //重载=，实现对象赋值
	~String();								   //析构函数
	char& operator[] (int i);					//重载[]，实现数组运算
	const char& operator[] (int i) const;		//重载[]，实现数组运算（对象为常量）
	String& operator+= (const String& s);		 //重载+=，实现与对象相加
	String& operator+= (const char* s);			 //重载+=，实现与字符串相加
	friend ostream& operator<< (ostream& out, String& s);	//重载<<，实现输出流
	friend istream& operator>> (istream& in, String& s);	  //重载>>，实现输入流
	friend bool operator< (const String& left, const String& right);   //重载<
	friend bool operator> (const String& left, const String& right);	//重载>
	friend bool operator== (const String& left, const String& right);	 //重载==
	friend bool operator!= (const String& left, const String& right);	 //重载!=
	char* getData();//获取data指针
	int length();
private:
	int size;	  //长度
	char* data;	   //指向字符串数据
};

#endif

//String.cpp
#include "String.h"

String::String()
{
	data = new char[1];
	*data = '\0';
	size = 0;
}

String::String(int n, char c)
{
	data = new char[n + 1];
	size = n;
	char* tmp = data;
	while( n -- )
	{
		*tmp++ = c;
	}
	*tmp = '\0';
}

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

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

String& String::operator=(char* s)
{
	if (NULL != data)
	{
		delete [] data;
	}
	size = strlen(s);
	data = new char[size + 1];
	strcpy(data, s);
	return *this;
}

String& String::operator=(const String& s)
{
	if( this == &s )
	{
		return *this;
	}
	if(NULL != data)
	{
		delete[] data;
	}
	size = strlen(s.data);
	data = new char[size + 1];
	strcpy(data, s.data);
	return *this;
}

String::~String()
{
	if( NULL != data)
	{
		delete[] data;
		data = NULL;
		size = 0;
	}
}

char& String::operator[](int i)
{
	return data[i];
}

const char& String::operator[](int i) const
{
	return data[i];
}

String& String::operator+=(const String& s)
{
	int len = size + s.size +１;
	char* temp = data;
	data = new char[len];
	size = len - 1;
	strcpy(data, temp);
	strcat(data, s.data);
	delete[] temp;
	return *this;
}

String& String::operator+=(const char* s)
{
	if( NULL == s)
	{
		return *this;
	}
	int len = size + strlen(s) + 1;
	char* temp = data;
	data = new char[len];
	size = len - 1;
	strcpy(data, temp);
	strcat(data, s);
	delete[] temp;
	return *this;
}

int String::length()
{
	return size;
}

ostream& operator<<(ostream& out, String& s)
{			
	for( int i = 0; i < s.length(); ++i)
	{
		 out << s[i] << " ";
	}
	return out;
}

istream& operator>>(istream& in, String& s)
{
	char p[50];
	in.getline(p,50);
	s = p;
	return in;
}

bool operator< (const String& left, const String& right)
{
	int i = 0;
	while(left[i] == right[i] && left[i] != 0 && right[i] != 0)
	{
		i ++;
	}
	return left[i]-right[i] < 0 ? true:false;
}

bool operator> (const String& left, const String& right)
{
	int i = 0;
	while(left[i] == right[i] && left[i] != 0 && right[i] != 0)
	{
		i ++;
	}
	return left[i]-right[i] > 0 ? true:false;
}

bool operator== (const String& left, const String& right)
{
	int i = 0;
	while(left[i] == right[i] && left[i] != 0 && right[i] != 0)
	{
		i ++;
	}
	return left[i]-right[i] == 0 ? true:false;
}

bool operator!= (const String& left, const String& right)
{
	int i = 0;
	while(left[i] == right[i] && left[i] != 0 && right[i] != 0)
	{
		i ++;
	}
	return left[i]-right[i] != 0 ? true:false;
}