c++-基础知识-案例-string类的实现

c+±基础知识-案例-string类的实现

参考
注意
1.对于以下两个函数，由于返回对象为istream和ostream，不能将其修改为类内的成员函数，所以可以设置为友元函数，注意声明时加friend关键字，定义时不加friend关键字。

	friend istream& operator>>(istream &is, String &str);
	friend ostream& operator<<(ostream &os,String &str);

2.拷贝过程中使用深拷贝
3.普通构造函数以及拷贝构造函数中不加以下代码，报错

//报错
if (this->m_data != NULL)
{
	delete [] this->m_data;
	this->m_data = NULL;
}

1.string类的实现-头文件

#ifndef STRING_H
#define STRING_H
#include <iostream>
#include <fstream>
#include <string>
using namespace std;

//实现string类
class String
{
public:
	//普通构造函数
	String(const char *str = NULL);

	//拷贝构造函数
	String(const String &str);

	//重载字符串赋值运算，这个运算会改变原有字符串的值，为了避免内存泄露，这里释放了原先申请的内存再重新申请一块适当大小的内存存放新的字符串。
	String& operator=(const String &str);

	//重载字符串连接运算，这个运算会返回一个新的字符串。
	String operator+(const String &str) const;

	String& String::operator+=(const String &str);

	//重载相等关系运算，这里定义为内联函数加快运行速度。
	inline bool operator==(const String &str) const//重载==
	{
		if (this->m_length != str.m_length)	return false;
		return strcmp(this->m_data, str.m_data) ? false : true;
	}

	//重载字符串索引运算符，进行了一个简单的错误处理，当长度太大时自动读取最后一个字符。
	inline char& operator[](int n) const//重载[]
	{
		//超出最大索引
		if (n >= this->m_length) return this->m_data[this->m_length-1]; //错误处理
		else return this->m_data[n];
	}

	//重载两个读取私有成员的函数，分别读取长度和C字符串。
	inline size_t size() const
	{
		return this->m_length;
	}

	//重载输入运算符，先申请一块足够大的内存用来存放输入字符串，再进行新字符串的生成。这是一个比较简单朴素的实现，网上很多直接is>>str.data的方法是错误的，因为不能确定str.data的大小和即将输入的字符串的大小关系。
	friend istream& operator>>(istream &is, String &str);

	//重载输入运算符
	friend ostream& operator<<(ostream &os,String &str);

	//获取c字符串
	inline const char* c_str() const
	{
		return this->m_data;
	}

	//析构函数
	~String();

private:
	char *m_data;
	size_t m_length;	//长度
};

#endif

2.string类的实现-实现文件

#include "String.h"

//普通构造函数
String::String(const char *str)
{
	if (!str)
	{
		//str为空
		this->m_length = 0;
		//对字符串自动申请存放结束标志
		this->m_data = new char[1];
		*(this->m_data) = '\0';
	}
	else
	{
		报错
		//if (this->m_data != NULL)
		//{
		//	delete [] this->m_data;
		//	this->m_data = NULL;
		//}

		this->m_length = strlen(str);
		this->m_data = new char[this->m_length + 1];//加1，\0占1位
		strcpy(this->m_data,str);
	}

}

//拷贝构造函数
String::String(const String &str)
{
	str为空
	if (!str.m_data)
	{
		this->m_data = NULL;
	}

	报错
	//if (this->m_data != NULL)
	//{
	//	delete [] this->m_data;
	//	this->m_data = NULL;
	//}

	this->m_length = str.m_length;
	//深拷贝
	this->m_data = new char[str.m_length+1];
	strcpy(this->m_data,str.m_data);
}

String& String::operator=(const String &str)
{
	if (this != &str)
	{
		delete [] this->m_data;
		this->m_length = str.m_length;
		//str为空
		if (!str.m_data)
		{
			this->m_data = NULL;
		}
		else
		{
			//深拷贝
			m_data = new char[str.m_length+1];
			strcpy(m_data,str.m_data);
		}

		return *this;
	}

	//返回自身
	return *this;
}

String String::operator+(const String &str) const
{
	String newString;
	newString.m_length = 	this->m_length + str.m_length;
	newString.m_data = new char[newString.m_length + 1];
	strcpy(newString.m_data, this->m_data);//字符串复制
	strcat(newString.m_data, str.m_data);//字符串链接
	return newString;
}

//在原来的基础上增加
String& String::operator+=(const String &str)
{
	this->m_length += str.m_length;
	char *newData = new char[this->m_length + 1];
	strcpy(newData, this->m_data);//字符串复制
	strcat(newData, str.m_data);//字符串链接
	delete [] this->m_data;
	this->m_data = newData;
	return *this;
}

istream& operator>>(istream &is, String &str)//输入
{
	char temp[1000];//申请内存
	is>>temp;
	str.m_length = strlen(temp);
	str.m_data = new char[str.m_length + 1];
	strcpy(str.m_data,temp);
	return is;
}

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

String::~String()
{
	cout<<"析构函数"<<endl;
	if(this->m_data != NULL)
	{
		delete [] this->m_data;
		this->m_data = NULL;
	}
}