String运算符重载

operator是关键字，它与重载的运算符一起构成函数名。因函数名的特殊性，C++编译器可以将这类函数识别出来。

小结：
　1. 运算符重载函数的函数名必须为关键字operator加一个合法的运算符。在调用该函数时，将右操作数作为函数的实参。

   2.  当用类的成员函数实现运算符的重载时，运算符重载函数的参数（当为双目运算符时）为一个或（当为单目运算符时）没有。运算符的左操作数一定是对象，因为重载的运算符是该对象的成员函数，而右操作数是该函数的参数。

   3.  单目运算符“++”和“--”存在前置与后置问题。
前置“++”格式为：
  返回类型  类名::operator++(){……}
而后置“++”格式为：
  返回类型  类名::operator++(int){……}
  后置“++”中的参数int仅用作区分，并无实际意义，可以给一个变量名，也可以不给变量名。

4.  C++中只有极少数的运算符不允许重载。 

重载运算符有以下几种限制
1).不可臆造新的运算符
2).不能改变运算符原有的优先级、结合性和语法结构,不能改变运算符操作数的个数
3).运算符重载不宜使用过多
4).重载运算符含义必须清楚，不能有二义性

String运算符重载具体代码如下：

#include<iostream>
#include<string>
using namespace std;

class String;                                      //先声明
ostream& operator<<(ostream &out, const String &s);//输出流
istream& operator>>(istream &in, String &s);       //输入流

class String                                        //定义String类
{
	friend ostream& operator<<(ostream &out, const String &s);//友元
    friend istream& operator>>(istream &in, String &s);
public: 
	String(const char *str = NULL)                  //构造函数
	{
		if(str == NULL)
		{
			m_data = new char[1];
			m_data[0] = '\0';
		}
		else
		{
			m_data = new char[strlen(str)+1];
			strcpy(m_data,str);
		}
	}
	String(const String &s)                         //拷贝构造函数
	{
		m_data = new char[strlen(s.m_data)+1];
		strcpy(m_data,s.m_data);
	}
	String& operator=(const String &s)              //运算符重载
	{
		if(this != &s)
		{
			free(m_data);
			m_data = new char[strlen(s.m_data)+1];
			strcpy(m_data,s.m_data);	
		}
		return *this;
	}
	~String()                                        //析构函数
	{
		delete []m_data;
	}
	String operator+(const String &s)                //s = s1 + s2
	{
		char *p = new char[strlen(m_data) +strlen(s.m_data)+1];
		strcpy(p,m_data);
		strcat(p,s.m_data);
		String tmp(p);
		delete []p;
		return tmp;
	}
	String operator+=(const String &s)               //s1 += s2
	{
		char *p = m_data;
		p = new char[strlen(m_data) +strlen(s.m_data)+1];
		strcpy(p,m_data);
		strcat(p,s.m_data);
		String tmp(p);
		delete []p;
		return tmp;
	}
	char&  operator[](int index)                      //重载下标运算符
	{
		return m_data[index];
	}
	bool operator==(String &s)                        //s1 = s2
	{
		if (strcmp(m_data,s.m_data) == 0)
		{
			return true;
		}
		else
		{
			return false;
		}
	}
	bool operator!=(String &s)                        //s1 != s2
	{
		if (strcmp(m_data,s.m_data) != 0)
		{
			return true;
		}
		else
		{
			return false;
		}
	}
	bool operator>(String &s)                           //s1 > s2
	{
		if (strcmp(m_data,s.m_data) > 0)
		{
			return true;
		}
		else
		{
			return false;
		}
	}
	bool operator<=(String &s)                          //s1 <= s2
	{
		if (strcmp(m_data,s.m_data) <= 0)
		{
			return true;
		}
		else
		{
			return false;
		}
	}
	bool operator<(String &s)                           //s1 < s2
	{
		if (strcmp(m_data,s.m_data) < 0 )
		{
			return true;
		}
		else
		{
			return false;
		}
	}
	bool operator>=(String &s)                          //s1 >= s2
	{
		if (strcmp(m_data,s.m_data) >= 0)
		{
			return true;
		}
		else
		{
			return false;
		}
	}
private:
	char *m_data;                                      //私有成员
};

ostream& operator<<(ostream &out, const String &s)
{
	out<<s.m_data;
	return out;
}

istream& operator>>(istream &in, String &s)
{
	in>>s.m_data;
	return in;
}

void main()                                            //测试函数
{
    String s1("hello");
	String s2("world");
    String s3= s1 + s2;
	String s;
	s = s1 += s2; 
	cout<<s1[0]<<endl;
	cout<<s1<<endl;
	cout<<s3<<endl;
	cout<<s<<endl;

	String s4("helloworld");
	String s5("helloworld");
	String s6("hello"); 
	String s7("hi");

	if (s4 == s5)
	{
		cout<<"s4和s5相等!"<<endl;
	}
	else
	{
		cout<<"s4和s5不相等!"<<endl;
	}
	if(s4 > s7)
	{
		cout<<"s4大于s7!"<<endl;
	}
	else if(s4 < s7)
	{
		cout<<"s4小于s7!"<<endl;
	}
	else 
	{
		cout<<"s4等于s7!"<<endl;
	}
	if(s4 >= s6)
	{
		cout<<"s4大等于s6!"<<endl;
	}
	else if(s4 <= s6)
	{
		cout<<"s4小等于s7!"<<endl;
	}
}

希望大家可以指出我的不足，谢谢大家。