string类中运算符重载实现

C++中预定义的加、减等运算符的操作对象只能是基本的数据类型。如果要在用户自定义的类型对象上应用同样的运算符，就需要通过运算符重载来重新定义其实现，使它能够用于自定义类型执行特定的操作，所以运算符重载的基本要求是要跟应用在基本数据类型上的功能“”看起来“”是一致的。

运算符重载的实质是函数重载，其定义也于一般函数的定义类似，唯一一点区别是运算符函数的函数名是由关键字operator和其后要重载的运算符符号构成的。运算符函数定义的一般格式如下：

  <返回值类型> operator <运算符符号>(<参数表>)
{
     <函数体>
}

对比一般函数的定义格式为：

<返回值类型> <函数名>(<参数表>)
{
     <函数体>
}

把一般函数定义中的“函数名”替换为“operator+运算符”的形式即为运算符的定义。

对一个自定义类型对象应用操作符运算，我的理解是，相当于对该对象执行操作符重载函数所定义的行为，把重载的运算符操作当成一般函数操作来看待，理解上就会简单很多。

给出string类的大部分运算符实现，包括string类构造函数，拷贝构造函数实现，运算符“=”、“+”、“+=”、“！=”、“>”、“<”、“<<”、“>>”的实现，其他可参照实现。

Mystring.h头文件各运算符重载声明：

#ifndef __Mystring
#define __Mystring
#include <iostream>

class Mystring
{
public:
	Mystring(const char *str=NULL);//构造函数
	Mystring(const Mystring& obj); //拷贝构造函数
	Mystring operator=(const Mystring &obj);
	Mystring operator+(const Mystring &obj);
	Mystring operator+=(const Mystring &obj);
	bool operator !=(const Mystring &obj);
	bool operator >(const Mystring &obj);
	bool operator <(const Mystring &obj);

	friend	std::ostream & operator<<(std::ostream &out,const Mystring &obj);
	friend	std::istream & operator>>(std::istream &in,Mystring &obj);

	~Mystring();

private:
	char *pstr;

};

#endif

Mysring.cpp各运算符重载定义：

#include "Mystring.h"

using namespace std;

Mystring::Mystring(const char * str)
{
	if(NULL==str)
	{
		this->pstr=new char[1];
		pstr[0]='\n';
	}
	else
	{
		this->pstr=new char[strlen(str)+1];
		strcpy(this->pstr,str);
	}
}

Mystring::Mystring(const Mystring & obj)
{
	this->pstr=new char[strlen(obj.pstr)+1];
	//实现深拷贝
	strcpy(this->pstr,obj.pstr);
}
Mystring::~Mystring()
{
	delete [] this->pstr;
	//释放之后把指针指向空，防止后文引用该指针
	this->pstr=NULL;
}

Mystring Mystring::operator=(const Mystring &obj)
{
	//分配内存空间，记得+1，因为c风格的字符串以'\n'结尾，需要多加一个字符
	this->pstr=new char[strlen(obj.pstr)+1];
	strcpy(this->pstr,obj.pstr);
	return *this;
}

Mystring Mystring::operator+(const Mystring &obj)
{
	Mystring mstr;
	mstr.pstr=new char[strlen(this->pstr)+strlen(obj.pstr)+1];
	sprintf(mstr.pstr,"%s%s",this->pstr,obj.pstr);
	return mstr;
}
Mystring Mystring::operator+=(const Mystring &obj)
{
	Mystring mstr;
	mstr.pstr=new char[strlen(this->pstr)+1];
	strcpy(mstr.pstr,this->pstr);
	this->pstr=new char[strlen(mstr.pstr)+strlen(obj.pstr)+1];
	sprintf(this->pstr,"%s%s",mstr.pstr,obj.pstr);
	return *this;
}

bool Mystring::operator!=(const Mystring &obj)
{
	if(strcmp(this->pstr,obj.pstr)==0)
	{
		return false;
	}
	else
	{
		return true;
	}
}

bool Mystring::operator>(const Mystring &obj)
{
	if(strcmp(this->pstr,obj.pstr)>0)
	{
		return true;
	}
	else
	{
		return false;
	}
}

bool Mystring::operator<(const Mystring &obj)
{
	if(strcmp(this->pstr,obj.pstr)<0)
	{
		return true;
	}
	else
	{
		return false;
	}
}

ostream & operator<<(ostream &out,const Mystring &obj)
{
	out<<obj.pstr;
	return out;
}

istream & operator>>(istream &in,Mystring &obj)
{
	//分配内存空间
	obj.pstr=new char[1024];
	in>>obj.pstr;
	return in;
}

在main中测试运算符功能：

#include <iostream>
#include "Mystring.h"
using namespace std;
int main()
{
	Mystring str1("abc");
	cout<<"str1经过初始化之后值为："<<str1<<endl;
	Mystring str2;
	str2=str1;
	cout<<"str2经过str1初始化之后值为："<<str2<<endl;
	Mystring str3;
	str3=str1+str2;
	cout<<"str1与str2之和str3为："<<str3<<endl;
	cout<<"请输入字符串str4："<<endl;
	Mystring str4;
	cin>>str4;
	cout<<"你输入的str4为："<<str4<<endl;
	if(str3!=str4)
	{
		cout<<"str3不等于str4"<<endl;
	}

	if(str3>str4)
	{
		cout<<str3<<"大于"<<str4<<endl;

	}
	if(str3<str4)
	{
		cout<<str3<<"小于"<<str4<<endl;
	}

	system("pause");
	return 0;
}

对str4输入字符串“ABCABC”，运行结果为：

注意：运算符中比较特殊的是输入输出流操作“<<”和“>>”，只能作为string类的友元（加friend）来实现，不能作为string类的成员函数实现。