运算符重载语法：返回值类型 operator运算符(参数列表) { 代码逻辑。。。
}
C++中的运算符重载是通过函数来实现的，可以将重载的运算符看作是类成的一个成员函数，向普通函数一样调用。如重载String类的 + 运算符，调用的时候可以这样：
class {
// .....
String operator+(const String &str)
{ .... }
}
String str1 = "hello ";
String str2 = "cplusplus";
String str3 = str1.operator+(str2);
从上述代码中可以看出，operator+就像是String类的一个函数，可以像普通函数一样调用，将要相加的字符串对象作为实参传递给函数即可。所以从这可以得出一个函数重载的步聚：（以上述+重载为例）
1、写出运算符的函数原型
str1.operator+(str2);
从这可以得知，+ 需要两个操作数，str1和str2（即两个字符串对象），返回值类型为String对象（加法运算后的结果）。由于是作为类的成员函数重载，所以str1在进行 + 运算时作为this指针传给函数，函数只需要一个参数即可，即被相加的字符串对象str2。
2、写出函数声明
从函数原型可以得出函数声明：String operator+(const String &str);
3、实现函数细节
String String::operator+(const String &str)
{
if (str.buff == nullptr)
{
return *this;
} size_t totallen = str.len + this->len + 1;
char *buff = new char[totallen]; strcpy(buff, this->buff);
strcat(buff, str.buff); String temp(buff);
return temp;
}
下面这个示例重载了字符串操作的常用操作符：
//
// String.h
// C++运算符重载
//
// Created by 杨信 on 14-5-8.
// Copyright (c) 2014年 yangxin. All rights reserved.
// #ifndef __C______String__
#define __C______String__ #include <iostream> using namespace std; class String
{
private:
char *buff;
size_t len; public:
String(); // 用一个字符串初始化对象
String(const char *buff); // 拷贝构造
String(const String &str); // 析构
~String(); // 设置字符串内容
void setString(const char *buff); // 获取字符串的长度
size_t length() const; // 获取字符串内容
char * getStr() const; // 比较两个字符串是否相等
bool operator==(String &str); // 比较两个字符串是否不相等
bool operator!=(String &str); // 比较两个字符串的大小
bool operator>(String &str); // 比较两个字符串的大小
bool operator<(String &str); // 获取或修改字符串中的某一个字符
char& operator[](int index); // 赋值构造函数
String& operator=(const String &str); // 两个字符串相加
String operator+(const String &str); // 字符串累加
String& operator+=(const String &str); // 从输入流中获取字符串
friend istream& operator>>(istream &input, String &str); // 将字符串输出到输出流
friend ostream& operator<<(ostream &output, const String &str); }; #endif /* defined(__C______String__) */ //
// String.cpp
// C++运算符重载
//
// Created by 杨信 on 14-5-8.
// Copyright (c) 2014年 yangxin. All rights reserved.
// #include "String.h"
#include <string>
#include <cassert>
#include <cmath> String::String()
{
this->buff = nullptr;
this->len = 0;
} // 用一个字符串初始化对象
String::String(const char *buff):buff(nullptr), len(0)
{
setString(buff);
} // 拷贝构造
String::String(const String &str)
{
setString(str.buff);
} // 析构
String::~String()
{
// 释放内存
if (this->buff != nullptr)
{
delete[] buff;
buff = nullptr;
len = 0;
}
} void String::setString(const char *buff)
{
if (buff == nullptr)
{
return;
} if (this->buff != nullptr) {
delete[] this->buff;
this->buff = nullptr;
this->len = 0;
} size_t len = strlen(buff);
this->buff = new char[len + 1];
this->len = len;
strcpy(this->buff, buff);
} // 获取字符串的长度
size_t String::length() const
{
return this->len;
} // 获取字符串内容
char * String::getStr() const
{
return this->buff;
} // 获取或修改字符串中的某一个字符
char& String::operator[](int index)
{
assert(index < this->len); return this->buff[index];
} // 比较两个字符串是否相等
bool String::operator==(String &str)
{
if (this->len != str.len)
{
return false;
} for (int i = 0; i < this->len; ++i)
{
if (this->buff[i] != str[i])
{
return false;
}
} return true;
} // 比较两个字符串是否不相等
bool String::operator!=(String &str)
{
return !(*this == str);
} // 比较两个字符串的大小
bool String::operator>(String &str)
{
char *pstr = this->buff;
char *pstr2 = str.buff;
while (*pstr != '\0' && *pstr2 != '\0')
{
if (*pstr > *pstr2) {
return true;
}
pstr++;
pstr2++;
}
return false;
} // 比较两个字符串的大小
bool String::operator<(String &str)
{
return !(*this > str);
} // 赋值构造函数
String& String::operator=(const String &str)
{
setString(str.buff); return *this;
} // 两个字符串相加
String String::operator+(const String &str)
{
if (str.buff == nullptr)
{
return *this;
} size_t totallen = str.len + this->len + 1;
char *buff = new char[totallen]; strcpy(buff, this->buff);
strcat(buff, str.buff); String temp(buff);
return temp;
} // 字符串累加
String& String::operator+=(const String &str)
{
if (str.buff == nullptr)
{
return *this;
} // 创建一个临时缓冲区，存储对象本身的字符串和相加的字符串
size_t len = this->len + str.length();
char *temp = new char[len + 1];
strcpy(temp, this->buff);
strcat(temp, str.buff); // 设置新的字符串给对象本身
setString(temp); return *this;
} // 从输入流中获取字符串
istream& operator>>(istream &input, String &str)
{
// 在堆区创建临时缓冲区，接收用户输入
int size = 1024 * 10;
char *tempbuff = new char[size];
memset(tempbuff, 0, size); // 获取用户输入
input.getline(tempbuff, size); // 将临时缓冲中的字符串保存到str对象的字符串缓冲区中
str.setString(tempbuff); // 释放临时缓冲区数据
delete[] tempbuff;
tempbuff = nullptr;
return input;
} // 将字符串输出到输出流
ostream& operator<<(ostream &output, const String &str)
{
output << str.getStr();
return output;
} // 测试用例
//
// main.cpp
// String(运算符重载)
//
// Created by 杨信 on 14-5-8.
// Copyright (c) 2014年 yangxin. All rights reserved.
// #include <iostream>
#include "String.h"
#include <cmath> using namespace std; int main(int argc, const char * argv[])
{ // 初始化
String str1("helloz");
String str2("helloz"); // 获取字符中内容
cout << str1.getStr() << endl; // 获取字符串的长度
cout << "长度:" << str1.length() << endl; // 获取第字符串中的第一个字符
cout << "第1个字符：" << str1[0] << endl; // 比较两个字符串是否相等，相等返回1，否则返回0
bool isequal = str1 == str2;
cout << isequal << endl; // 比较两个字符串的大小，str1大于str2返回1，否则返回0
cout << (str1 > str2) << endl; // 修改字符串中的第2个字符为C
String s = "Hello";
s[1] = 'C';
cout << s << endl; // 测试用一个字符串去初始化另外一个字符串
String str3 = str2;
cout << str3.getStr() << endl;
String str4;
str4 = str3;
cout << str4.getStr() << endl; // 测试两个字符串相加
String str5 = str1 + str2;
cout << &str5 << endl;
cout << str5.getStr() << endl; // 测试字符串连等
String str6;
String str7 = str6 = str5;
cout << str6.getStr() << " | " << str7.getStr() << endl; // 测试字符串累加
String str8 = "i love c++ ";
str8 += "i love c ";
cout << str8.getStr() << endl; // 从输入流读取字符串
String str9;
cout << "Please a string:";
cin >> str9; // 将字符串输出到输出流
cout << str9 << endl; return 0;
}
运算符重载注意事项：
- 友元函数重载运算符时需要传递所有操作数
- 成员函数重载，会将操作数本身做为this指针作为参数传入函数，如果是多元操作符，只需与它被操作的数传入函数即可
= 号重载时，如果对象中有新分配内存的成员，要先delete，再new，如果要支持连等操作，需要返回对象本身的引用
函数返回值作左值时，返回值必须为引用
- 只有C++预定义的操作符集中的操作符才可以被重载（不能自己随便写一个操作符，如：+-）
- 重载操作符不能改变操作符的优先级，例如：先乘徐，后加减
- 重载操作符不能改变操作数的个数
以下几种运算符不能被重载：
- . ：成员选择运算符
- :: ：作用域运算符
- * ： 指针运算符
- # ：预处理标志
- ?: ：三目运算符，没有确定性，重载没有意义