C++的运算符重载（四）——其他运算符重载和总结

概述：
除了前面重载的指针，自增自减，左移运算符之外，可以发生重载的运算符还有很多，比如等号（=），等等（==）以及（!=）等，

文章目录

• 一、重载其他运算符
• 二、符号重载总结
• 三，字符串类封装

---

一、重载其他运算符

1，重载等号运算符

class Person
{
public:
	Person()
	{
	
	}
	Person(int age1, char* name1)
	{
		age = age1;
		name = new char[strlen(name1) + 1];
		strcpy(name, name1);
	}
	Person& operator= (Person &p)
	{
		this->age = p.age;
		this->name = new char[strlen(p.name) + 1];
		strcpy(this->name,p.name);

		return  *this;
	}
	~Person()
	{
		delete[]name;
	}
	int age;
	char* name;

};

void test01()
{
	Person p1(10, (char*)"Bob");
	//Person p2 = p1;
	//p2 = p1;不会调用构造函数
	Person p2;
	p2 = p1;
	cout << p2.age << endl;
	cout << p2.name << endl;


}
int main()
{
	test01();


	return 0;
}

注意：
在不重载等号运算符的时候,如p1 = p2编译器会认为是简单值拷贝 。
自定义对象等号的时候，不能简单的进行每个成员变量都等于，如下

Person& operator= (Person &p)
	{
		this->age = p.age;
		this->name = p.name;
		
		return  *this;
	}

这种重载是不对的，因为对于一个数组来说数组名就是首地址，如果这样直接复制，会导致两个数组访问同一块内存，导致一些难以预料的问题，所以在赋值的时候一定要重新开辟空间。并且要记得最后对象释放的时候记得也释放申请的空间

2，重载等等和不等运算符

class Person
{
public:
	Person(int age ,string name)
	{
		this->age = age;
		this->name = name;
	}

	bool operator==(Person& p)
	{
		return ((p.age == this->age) && (p.name == this->name));
	}
	bool operator!=(Person& p)
	{
		return ((p.age != this->age) | (p.name != this->name));
	}
	int age;
	string name;

};

void test01()
{
	Person p1(10, "test");
	Person p2(10,"test1");
	if (p1 == p2)
	{
		cout << "p1和p2相等" << endl;
	}
	if (p1 != p2)
	{
		cout << "p1和p2不相等" << endl;
	}
}

int main()
{
	test01();
	return 0;
}

3重载函数调用符号"（）"

class Myadd
{
public:
	int add(int a,int b)
	{
		return a + b;
	}

	int  operator()(int x, int y)
	{
		return x + y;
	}
};
void test01()
{
	Myadd m1;
	cout << m1.add(1, 3) << endl;
	cout << m1(3, 2) << endl;/*可以像函数一样调用的对象函数对象*/
	cout << Myadd()(3, 4) << endl;/*匿名对象*/
}

int main()
{
	test01();
	return 0;
}

4对于"||“和”&&"的重载

对于这两种运算符不太好重载，不能重载 operator&& 和 operator|| 的原因是，无法在这两种情况下实现内置操作 符的完整语义。说得更具体一些，内置版本版本特殊之处在于：内置版本的&&和 ||首先计算左边的表达式，如果这完全能够决定结果，就无需计算右边的表达式了- -而且能够保证不需要。我们都已经习惯这种方便的特性了。 我们说操作符重载其 实是另一种形式的函数调用而已，对于函数调用总是在函数执行之前对所有参数进 行求值。
比如

if(complex1 && (complex1 += complex2))

对于上述代码来说计算判断的时候，是按照先算括号里面的，并不会从左开始判断，并且如果complex1为0就不会判断的情况，所以会有一些问题，并不能达到我们想要的功能。
根据内置&&的执行顺序，我们发现这个案例中执行顺序并不是从左向右，而是先 右猴左，这就是不满足我们习惯的特性了。由于 complex1 += complex2 先执行， 导致 complex1 本身发生了变化，如果初始值是 0，现在经过+=运算变成 1,1 && 1 输出 了真。所以会有一些问题

二、符号重载总结

=, [], () 和 -> 操作符只能通过成员函数进行重载 << 和 >>只能通过全局函数配合 友元函数进行重载 不要重载 && 和 || 操作符，因为无法实现短路规则 常规建议

三，字符串类封装

一个简单的字符串类的封装，实现string的功能。

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string>
#include <string.h>

using namespace std;

class MyString
{
	friend ostream& operator<< (ostream& out, MyString& str);
	friend istream& operator>>(istream& in, MyString& str);

public://构造函数
	MyString(const char* str)
	{
		this->pString = new char[strlen(str) + 1]; strcpy(this->pString, str);
		this->m_Size = strlen(str);
	}
	MyString(const MyString& str)
	{
		this->pString = new char[strlen(str.pString) + 1]; strcpy(this->pString, str.pString);
		this->m_Size = str.m_Size;
	}
	~MyString()
	{
		if (this->pString != NULL)
		{
			delete[]this->pString; this->pString = NULL;
		}
	}

	char& operator[](int index)
	{
		return this->pString[index];
	}//[]重载

	//=号重载
	MyString& operator=(const char* str)
	{
		if (this->pString != NULL) {
			delete[] this->pString; this->pString = NULL;
		}
		this->pString = new char[strlen(str) + 1]; strcpy(this->pString, str);
		this->m_Size = strlen(str);
		return *this;
	}
	MyString& operator=(const MyString& str)
	{
		if (this->pString != NULL) {
			delete[] this->pString; this->pString = NULL;
		}
		this->pString = new char[strlen(str.pString) + 1]; strcpy(this->pString, str.pString);
		this->m_Size = str.m_Size;
		return *this;
	}

	//字符串拼接 重载+号
	MyString operator+(const char* str)
	{
		int newsize = this->m_Size + strlen(str) + 1; char* temp = new char[newsize];

		memset(temp, 0, newsize); strcat(temp, this->pString); strcat(temp, str);

		MyString newstring(temp);
		delete[] temp;

		return newstring;
	}

	MyString operator+(const MyString& str)
	{
		int newsize = this->m_Size + str.m_Size + 1; char* temp = new char[newsize];  memset(temp, 0, newsize);
		strcat(temp, this->pString); strcat(temp, str.pString);

		MyString newstring(temp);
		delete[] temp;
		return newstring;
	}

	//字符串比较
	bool operator== (const char* str)
	{

		if (strcmp(this->pString, str) == 0 && strlen(str) == this->m_Size){

			return true;
		}

		return false;
	}
	bool operator== (const MyString& str)
	{
		if (strcmp(this->pString, str.pString) == 0 && str.m_Size == this
			->m_Size) {
			return true;
		}
		return false;
	}
private:
	char* pString; //指向堆区空间
	int m_Size; //字符串长度 不算'\0'
};


//左移运算符
ostream& operator<< (ostream& out, MyString& str)
{
	out << str.pString;
	return out;
}
//右移运算符
istream& operator>>(istream& in, MyString& str)
{
	//先将原有的数据释放
	if (str.pString != NULL)
	{
		delete[] str.pString; str.pString = NULL;
	}
	char buf[1024]; //开辟临时的字符数组，保存用户输入内容
	in >> buf;

	str.pString = new char[strlen(buf) + 1]; strcpy(str.pString, buf);
	str.m_Size = strlen(buf);

	return in;
}

void test01()
{
	MyString str("hello World");

	cout << str << endl;

	//cout << "请输入MyString 类型字符串：" << endl;
	//cin >> str;
	//cout << "字符串为： " << str << endl;

	//测试[]
	cout << "MyString 的第一个字符为：" << str[0] << endl;

	//测试 =
	MyString str2 = "^_^"; MyString str3 = ""; str3 = "aaaa";
	str3 = str2;
	cout << "str2 = " << str2 << endl; cout << "str3 = " << str3 << endl;

	//测试 +
	MyString str4 = " 我 爱 "; MyString str5 = " C++  "; MyString str6 = str4 + str5; MyString str7 = str6 + "，C语言";

	cout << str7 << endl;

	//测试 ==
	if (str6 == str7)
	{
		cout << "s6 与 s7 相等" << endl;
	}
	else
	{
		cout << "s6 与 s7 不相等" << endl;
	}
}

int main()
{
	test01();

	return 0;
}