C++自实现String类

String.h

#include <iostream>
#include <assert.h>
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;	//data表示的字符串长度
	char* data; //指向字符串数据
};

String.cpp

#include "String.h"

String::String()  //默认构造函数,构造空字符串
{
	data = new char[1];  //空字符串只含有'\0'一个元素
	*data = '\0';
	size = 0;
}

String::String(int n, char c)	//普通构造函数
{								//含有n个相同字符的字符串
	data = new char[n + 1];
	size = n;
	char *temp = data;			//保存data
	while (n--)					//做n次赋值
	{
		*temp++ = c;
	}
	*temp = '\0';
}

String::String(const char* source)	//普通构造函数
{									//字符串内容与source相同
	if (source == NULL)				//source为NULL
	{								//将data赋为空字符串
		data = new char[1];
		*data = '\0';
		size = 0;
	}
	else
	{
		size = strlen(source);		//source不为NULL
		data = new char[size + 1];	//复制source字符串
		strcpy(data, source);
	}
}

String::String(const String& s)		//复制构造函数
{									//字符串内容与对象s的相同
	data = new char[s.size + 1];
	strcpy(data, s.data);
	size = s.size;
}

String& String::operator=(char* s)	// = 重载
{									// 目标为字符串
	if (data != NULL)
	{
		delete[]data;
	}
	size = strlen(s);
	data = new char[size + 1];
	strcpy(data, s);
	return *this;					//复制目标字符串
}

String& String::operator=(const String& s)	// = 重载
{											//目标为String对象
	if (this == &s)
	{
		return *this;
	}
	if (data != NULL)						//释放data堆内存
	{
		delete[]data;
	}

	size = strlen(s.data);
	data = new char[size + 1];				//分配堆内存
	strcpy(data, s.data);					//复制对象s的字符串成员
	return *this;
}

String::~String()
{
	if (data != NULL)						//data不为NULL,释放堆内存
	{
		delete[]data;
		data = NULL;
		size = 0;
	}
}

char& String::operator[](int i)				//[] 重载
{
	assert(i >= 0 && i < size);
	
	return data[i];							//取数组下标为i的字符元素
}

const char& String::operator[](int i)const	//[] 重载
{
	assert(i >= 0 && i < size);
	
	return data[i];							//取数组下标为i的字符元素

}

String& String::operator+=(const String& s) //+=重载
{											//连接对象s的字符串成员
	int len = size + s.size + 1;
	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 (s == NULL) 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)	//重载<<
{												//打印对象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);							//从输入流接收最多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;
	//return strcmp(left.data, right.data) < 0;
}

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;
	//return strcmp(left.data, right.data) > 0;
}

bool operator==(const String& left, const String& right) //重载==
{
	if(left.size != right.size) return false;

	int i = 0;
	while (left[i] != 0)
	{
		if (left[i] == right[i])
		{
			i++;
		}
		else
			return false;
	}
	return true;

	//return strcmp(left.data, right.data) == 0;
}

bool operator!=(const String& left, const String& right) //重载!=
{
	if (left.size != right.size) return true;

	int i = 0;
	while (left[i] != 0)
	{
		if (left[i] != right[i])
		{
			return true;
		}
		else
		{
			i++;
		}
	}
	return false;
	//return strcmp(left.data, right.data) != 0;
}

main.cpp

#include <iostream>
#include "String.h"

using namespace std;

int main()
{
	String str(3, 'a');
	String str1(str);
	String str2("asdf");
	String str3;

	cout << "str:" << str << endl;
	cout << "str1:" << str1 << endl;
	cout << "str2:" << str2 << endl;
	cout << "str3:" << str3 << endl;

	str3 = str2;		//赋值测试
	cout << "str3:" << str3 << endl;
	str3 = "12ab";
	cout << "str3:" << str3 << endl;

	cout << "str3[2] = " << str3[2] << endl;

	str3 += "111";		//+=重载测试
	cout << "str3:" << str3 << endl;
	str3 += str1;
	cout << "str3:" << str3 << endl;

	cin >> str1;
	cout << "str1:" << str1 << endl;

	system("pause");
	return 0;
}