運算子過載規則如下：

①、 C++中的運算子除了少數幾個之外，全部可以過載，而且只能過載C++中已有的運算子。
②、 過載之後運算子的優先順序和結合性都不會改變。
③、 運算子過載是針對新型別資料的實際需要，對原有運算子進行適當的改造。一般來說，過載的功能應當與原有功能相類似，不能改變原運算子的操作物件個數，同時至少要有一個操作物件是自定義型別。

不能過載的運算子只有五個:

它們是：成員運算子“.”、指標運算子“*”、作用域運算子“：：”、“sizeof”、條件運算子“？：”。

運算子過載形式有兩種，過載為類的成員函式和過載為類的友元函式。

運算子過載為類的成員函式的一般語法形式為：
函式型別 operator 運算子（形參表）
{
函式體；
}
運算子過載為類的友元函式的一般語法形式為：
friend 函式型別 operator 運算子（形參表）
{
函式體；
}
其中，函式型別就是運算結果型別；operator是定義運算子過載函式的關鍵字；運算子是過載的運算子名稱。

參考程式碼如下：

class String
{
public:

//構造

String(char* pstring)  //構造
	{
		pstr = new char[strlen(pstring) + 1]();
		strcpy(pstr, pstring);
	}

//類內是this_call的呼叫約定，成員方法隱藏this指標，指向一般為左運算元，所以只用傳右運算元即可

String(const String& rhs)
{
	pstr = new char[strlen(rhs.pstr) + 1]();
	strcpy(pstr, rhs.pstr);
}
 

類內=(賦值)的過載,左右運算元型別均為String,類內只用傳右運算元即可

String& operator=(const String& rhs)
{
	if (this != &rhs)
	{
		delete[] pstr;
		pstr = new char[strlen(rhs.pstr) + 1]();
		strcpy(pstr, rhs.pstr);
	}
	return *this;
}

//析構

~String()
{
	delete[] pstr;
	pstr = NULL;
}

類內實現+的過載，傳入右運算元型別為char*(可省略:char*可隱式生成臨時物件，呼叫左右運算元都為string類的過載函式)

//const String operator+(char* prhs)
//{
//	char* pnewstr = new char[strlen(pstr) + strlen(prhs) + 1]();
//	strcat(pnewstr, pstr);
//	strcat(pnewstr, prhs);
//	String tmp(pnewstr);
//	delete[] pnewstr;
//	return tmp;
//}

String str2 = str1 + “world”;//“helloworld” +是自左向右，可根據str1.推演str2的型別
String str3 = “hi” + str1;//“hihello”;錯誤，不能根據右邊型別推演左邊型別，只能呼叫左操作符為char*,右操作符為string的函式，或者兩個型別都是string 的函式

類內==的過載,左右運算元型別均為String,類內只用傳右運算元即可

bool operator==(const String& rhs)
{
	return strcmp(pstr, rhs.pstr) == 0;
}

if (str1 == str2)
{
std::cout << str1[0] << std::endl;// int p[10] ==> p int* p[1]
}

類內[]的過載，左運算元型別為String,右運算元型別為int,類內只用傳右運算元即可

char& operator[](int index)
{ 
	return pstr[index];
}

std::cout << str1[0] << std::endl;// int p[10] ==> p int* p[1]

類內<的過載,左運算元型別為std::cout,右運算元型別為String,類內只用傳右運算元即可

bool operator<(const String& rhs)
{
	return strcmp(pstr, rhs.pstr) < 0;
}

if (str2 < str2)
{
std::cout << str2 << std::endl;
}

private:

char* pstr;

//類外不能訪問類內的私有成員變數，設定友元函式

 friend const String operator+(char*, const String&);
    	friend const String operator+(const String&, const String&);
    	friend std::ostream& operator <<(std::ostream&, const String&);

};

//類外是cd_call的呼叫約定,無this指標，需傳兩個物件

//類外實現+的過載，左運算元型別為char*,右運算元為String(可省略:char*可先呼叫構造生成臨時物件，後呼叫左右運算元都為string類的過載函式)

//const String operator+(char* plhs, const String& rhs)
//{
//	char* pnewstr = new char[strlen(plhs) + strlen(rhs.pstr) + 1]();
//	strcat(pnewstr, plhs);
//	strcat(pnewstr, rhs.pstr);
//	String tmp(pnewstr);
//	delete[] pnewstr;
//	return tmp;
//}

String str3 = “hi” + str1;//“hihello”;

類外實現+的過載，左右運算元型別均為String

const String operator+(const String& lhs, const String& rhs)
{
	char* pnewstr = new char[strlen(lhs.pstr) + strlen(rhs.pstr) + 1]();
	strcat(pnewstr, lhs.pstr);
	strcat(pnewstr, rhs.pstr);
	String tmp(pnewstr);
	delete[] pnewstr;
	return tmp;
}

String str4 = str1 + str2; //“hellohelloworld”

類外實現<<的過載,左運算元為std::ostream的型別，右運算元為String型別

std::ostream& operator <<(std::ostream& out, const String& rhs)
{
	out << rhs.pstr;
	return out;
}