什么是运算符重载？ 如何在 C++ 中进行运算符重载？运算符重载在面向对象编程中的好处是什么？

什么是运算符重载

运算符重载是一种允许用户重新定义 C++ 中大多数运算符的功能的机制。在 C++ 中，运算符（如+、-、*、/等）本来有其预定义的操作，比如对于基本数据类型（int、float等）的加法操作。但是，当我们处理自定义的数据类型（如类和结构体）时，通过运算符重载，可以赋予这些运算符新的含义，使其能够像操作基本数据类型一样方便地操作自定义类型。

例如，我们有一个复数类Complex，它包含实部和虚部两个成员变量。如果没有运算符重载，对两个复数进行相加操作就会很麻烦，可能需要定义一个专门的函数来实现加法。但是通过重载+运算符，就可以像Complex c3 = c1 + c2;这样直观地进行复数相加操作，其中c1、c2和c3是Complex类的对象。

如何在 C++ 中进行运算符重载

成员函数方式

加号运算符重载

作用：实现两个自定义数据类型相加的运算

#include<iostream>
using namespace std;

class Box
{
	int height;
	int width;
	int length;
public:
	Box() :height(0), width(0), length(0) {}
	Box(int l, int w, int h) :height(h), width(w), length(l) {}
	Box(const Box &other)
	{
		this->height = other.height;
		this->width = other.width;
		this->length = other.length;
	}

	Box operator+ (const Box & other)//加&避免调用拷贝构造
    //返回值不加引用，是因为返回的是局部变量，函数结束会被释放
	{
		Box c;
		c.length = other.length + this->length;
		c.width = other.width + this->width;
		c.height = other.height + this->height;
		return c;
	}

	void Print()
	{
		cout << width << "  " << length << "  " << height << endl;
	}
	~Box()
	{
		cout << "析构函数" << endl;
	}
};

int main()
{
	Box a(1,1,1), b(1,1,1);
	Box c = a + b;
	c.Print();
	
}

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

class Box
{
	int height;
	int width;
	int length;
public:
	friend ostream&  operator<<(ostream &o, Box a);
	Box() :height(0), width(0), length(0) {}
	Box(int l, int w, int h) :height(h), width(w), length(l) {}
	Box(const Box &other)
	{
		this->height = other.height;
		this->width = other.width;
		this->length = other.length;
	}
	void Print()
	{
		cout << width << "  " << length << "  " << height << endl;
	}
	~Box()
	{
		cout << "析构函数" << endl;
	}
};
//左移运算符要在类外实现
ostream&  operator<<(ostream &o ,Box a)
{
	o << a.height << "  " << a.length << "  " << a.width << endl;
	return o;
}

int main()
{
	Box a(1, 1, 1),b;
	cout << a << b;
}

#include<iostream> 
using namespace std;

class Box
{
	int length;
	int width;
	int height;
public:
	friend ostream& operator<<(ostream& o, Box b);
	Box() :length(0), width(0), height(0) {}
	Box(int l, int w, int h) :length(l), width(w), height(h) {}
	Box(const Box& other)
	{
		this->length = other.length;
		this->height = other.height;
		this->width  =  other.width;
	}
	Box& operator+=(const Box& other) //可以引用返回*this，因为*this这个对象没在当前函数内创建，在主函数创建的，主函数如果是a+=b，那么*this是a
	{
		this->height += other.height;
		this->length += other.length;
		this->width += other.width;
		return *this;
	}
};
ostream& operator<<(ostream& o,Box b)
{
	o << b.length << "  " << b.width << "  " << b.height << endl;
	return o;
}

int  main()
{
	Box a(1,1,1), b(2,2,2),c(3,3,3);
	a += b += c;
	cout <<a << b << c << endl;
}

class Integer
{
	int num;
public:
	Integer() :num(0) {}
	Integer(int val) :num(val) {}
	Integer operator++ ()
	{
		this->num += 1;
		return *this;
	}
	Integer operator++ (int) //使用参数占位符来区分前++和后++，有参数占位符的为后++
	{
		Integer other = *this;
		this->num += 1;
		return other;
	}
};

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

class A
{
	int num;
public:
	A() :num(0) {}
	A(int num) :num(num) {}

	bool operator> (const A& other)
	{
		if (this->num > other.num) return 1;
		return 0;
	}

	bool operator ==(const A& other)
	{

		if (this->num == other.num) return 1;
		return 0;
	}
};

int main() {

	A a(2), b;
	cout << (a > b);
	return 0;
}

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

class A
{
	int num;
	int *p;
public:
	A() :num(0),p(nullptr) {}
	A(int num) :num(num),p(new int(num)) {}
	~A()
	{
		if (p) delete p;
	}
	A& operator= (const A&other)
	{
		if (p) delete p; //释放原来指向的堆区内存，拷贝构造没有这一步骤
		num = other.num;
		p = new int(num); //指向新的堆区内存
		return *this;
	} 
};

int &fun()
{
	int a = 2;
	return a;
}

int main() {

	int b = fun(); //行
	int &c = fun(); //不行

	A a(2), b(3),c;
	a = b = c; // 如果类内没有实现赋值运算符，编译器则会提供默认的赋值运算符，每个成员都会被赋值，此时要注意浅拷贝问题
	return 0;
}

class Vector2D {
     public:
         double x;
         double y;
         Vector2D(double a = 0, double b = 0) : x(a), y(b) {}
         friend Vector2D operator+(const Vector2D& v1, const Vector2D& v2);
     };
     Vector2D operator+(const Vector2D& v1, const Vector2D& v2) {
         return Vector2D(v1.x + v2.x, v1.y + v2.y);
     }