C/C++关于运算符重载笔记

发表于 2020-05-12 更新于 2023-05-25 分类于《C/C++ 入门系列教程》

加号运算符重载重载加号运算符，让p3=p1+p2改成p3.mage=p1.mage+p2.mage实现两个数据成员的相加。

加号运算符重载: 重载加号运算符，让 p3 = p1 + p2 改成 p3.mage = p1.mage + p2.mage 实现两个数据成员的相加。

告诉编译器，两个类中的数据成员应该怎么相加。

成员函数相加 +号运算符重载成员函数二元

#include <iostream>
#include <string>

using namespace std;

class Person
{
public:
	int m_x;
	int m_y;
	Person(){};
	Person(int x, int y) :m_x(x), m_y(y) {}

		// 加号运算符重载，这里其实是二元，因为隐藏了一个this指针。
	Person operator + (Person &p)
	{
		Person tmp;
		tmp.m_x = this->m_x + p.m_x;
		tmp.m_y = this->m_y + p.m_y;
		return tmp;
	}
};


int main(int argc, char *argv[])
{
	Person p1(10, 10);
	Person p2(20, 20);

	Person p3 = p1 + p2;
	cout << "p3 m_x = > " << p3.m_x << endl;
	cout << "p3 m_y = > " << p3.m_y << endl;

	system("pause");
	return 0;
}

全局函数相加,实现运算符重载

#include <iostream>
#include <string>

using namespace std;

class Person
{
public:
	int m_x;
	int m_y;
	Person(){};
	Person(int x, int y) :m_x(x), m_y(y) {}
};

// 全局函数实现运算符重载，这个就属于二元运算符重载
Person operator +(Person &p1, Person &p2)
{
	Person tmp;
	tmp.m_x = p1.m_x + p2.m_x;
	tmp.m_y = p1.m_y + p2.m_y;
	return tmp;
}

int main(int argc, char *argv[])
{
	Person p1(10, 30);
	Person p2(20, 50);

	Person p3 = p1 + p2;
	cout << "p3 m_x = > " << p3.m_x << endl;
	cout << "p3 m_y = > " << p3.m_y << endl;

	system("pause");
	return 0;
}

左移运算符重载： 使用 << 重载左移运算符，让cout 直接输出两个变量。重载左移运算符不可以写成成员函数，只能写全局运算符。

#include <iostream>
#include <string>

using namespace std;

class Person
{
public:
	int m_x;
	int m_y;
	Person(){};
	Person(int x, int y) :m_x(x), m_y(y) {}
};

ostream& operator << (ostream &cout, Person &ptr)
{
	cout << "m_x = " << ptr.m_x << " ----> " << "m_y = " << ptr.m_y << endl;
	return cout;
}

int main(int argc, char *argv[])
{
	Person p1(10, 30);
	Person p2(20, 10);

	cout << p1 << endl;
	cout << p2 << endl;

	system("pause");
	return 0;
}

使用友元函数，访问私有的数据。

#include <iostream>
#include <string>

using namespace std;

class Person
{

	friend ostream& operator<<(ostream &cout, Person &ptr);
private:
	int m_x;
	int m_y;

public:
	Person(){};
	Person(int x, int y) :m_x(x), m_y(y) {}
};

ostream& operator << (ostream &cout, Person &ptr)
{
	cout << "m_x = " << ptr.m_x << " ----> " << "m_y = " << ptr.m_y << endl;
	return cout;
}

int main(int argc, char *argv[])
{
	Person p1(10, 30);
	Person p2(20, 10);

	cout << p1 << endl;
	cout << p2 << endl;

	system("pause");
	return 0;
}

前置/后置运算符的重载:

#include <iostream>
#include <string>

using namespace std;

class MyInteger
{
	friend ostream& operator<<(ostream& cout, MyInteger & myInt);

public:
	int m_count;
public:
	MyInteger() { m_count = 0; }

	// 重载前置 ++x 运算符
	MyInteger& operator ++ ()
	{
		this->m_count++;
		return *this;
	}
	// 重载后置 x++ 运算符,为了区分前后置,需要在参数后面增加一个int占位符
	// 此时编译器才会认为我们需要使用后置重载运算符了
	MyInteger operator ++ (int)
	{
		MyInteger tmp = *this;
		m_count++;
		return tmp;
	}
};

ostream& operator<<(ostream& cout, MyInteger & myInt)
{
	cout << myInt.m_count;
	return cout;
}

int main(int argc, char *argv[])
{
	MyInteger myInt;

	cout << ++myInt << endl;
	cout << myInt++ << endl;

	cout << ++(++myInt) << endl;

	system("pause");
	return 0;
}

指针运算符重载（智能指针） 用来托管自定义的对象，让对象可以自动的释放数据，

当我们使用一个对象结束以后，无需手动释放堆空间，智能指针会帮助我们完成这个过程。

#include <iostream>
#include <string>

using namespace std;

class Student
{
public:
	char *m_name;
	int m_age;

public:
	Student(char *name, int age)
	{
		this->m_name = name;
		this->m_age = age;
	}
	void Print()
	{
		cout << "Name: " << this->m_name << endl;
		cout << "Age: " << this->m_age << endl;
	}
};

// 定义智能指针,用于自动释放对象所占用的空间
class Smart_Pointer
{
private:
	Student *ptr;
public:
	// 先来执行构造函数,将传入的指针复制到内部
	Smart_Pointer(Student *ptr)
	{ this->ptr = ptr; }

	// 重载运算符 -> 让智能指针能够直接指向Student
	Student * operator -> ()
	{ return this->ptr; }

	// 重载运算符 *
	Student & operator * ()
	{ return *this->ptr; }

	// 定义析构函数,这是智能指针的关键部分,对象会被自动释放
	~Smart_Pointer()
	{
		if (this->ptr != NULL)
		{
			delete this->ptr;
			this->ptr = NULL;
		}
	}
};

int main(int argc, char *argv[])
{
	// 手动释放的案例：平常的使用方式
	Student *stu = new Student("lyshark", 10);
	stu->Print();
	delete stu;

	// 使用智能指针：则无需考虑释放的问题
	Smart_Pointer ptr(new Student("lyshark", 10));
	ptr->Print();
	(*ptr).Print();

	system("pause");
	return 0;
}

赋值运算符重载： 我们将等于号进行重载，实现对类中数据成员的赋值拷贝。

#include <iostream>
#include <string>

using namespace std;

class Student
{
public:
	int m_uid;
	char *m_name;
public:
	Student(int uid, char *name)
	{
		this->m_uid = uid;
		this->m_name = new char[strlen(name) + 1];
		strcpy(this->m_name, name);
	}
	// 重载 = 实现类数据成员的赋值运算
	Student& operator = (const Student &ptr)
	{
		// 先来判断原来的堆区是否有内容,如果有则先来释放
		if (this->m_name != NULL)
		{
			this->m_uid = 0;
			delete[] this->m_name;
			this->m_name = NULL;
		}
		// 否则，我们直接开辟空间完成内存拷贝
		this->m_name = new char[strlen(ptr.m_name) + 1];
		strcpy(this->m_name, ptr.m_name);
		this->m_uid = ptr.m_uid;

		return *this;
	}
	// 析构函数,则需要释放内存
	~Student()
	{
		if (this->m_name != NULL)
		{
			this->m_uid = 0;
			delete[] this->m_name;
			this->m_name = NULL;
		}
	}
};

int main(int argc, char *argv[])
{

	Student stu1(1,"lyshark");
	Student stu2(2, "admin");
	Student stu3(0, "");

	stu3 = stu2 = stu1;

	cout << stu3.m_name << endl;
	cout << stu2.m_name << endl;
	cout << stu1.m_name << endl;

	system("pause");
	return 0;
}

关系运算符重载:

#include <iostream>
#include <string>

using namespace std;

class Student
{
public:
	int m_uid;
	char * m_name;

public:
	Student(int uid,char *name)
	{
		this->m_uid = uid;
		this->m_name = name;
	}

	bool operator == (Student &ptr)
	{
		if (this->m_uid == ptr.m_uid && this->m_name == ptr.m_name)
			return true;
		return false;
	}
	bool operator != (Student &ptr)
	{
		if (this->m_uid != ptr.m_uid && this->m_name != ptr.m_name)
			return true;
		return false;
	}
};

int main(int argc, char *argv[])
{
	Student stu1(1, "lyshark");
	Student stu2(1, "lyshark");
	Student stu3(2, "admin");

	if (stu1 == stu2)
		cout << "stu1 = stu2" << endl;

	if (stu1 != stu3)
		cout << "stu1 != stu3" << endl;

	system("pause");
	return 0;
}

重载与仿函数:

#include <iostream>
#include <string>

using namespace std;

class MyPrint
{
public: void operator()(string text)
	{
		cout << text << endl;
	}
};

class MyAdd
{
public: int operator()(int x, int y)
	{
			return x + y;
	}
};


int main(int argc, char *argv[])
{
	MyPrint print;

	print("hello lyshark");              // 使用仿函数
	cout << MyAdd()(100, 200) << endl;   // 匿名仿函数

	system("pause");
	return 0;
}