C/C++学习笔记十三 C++中的重载运算符
1、什么是运算符重载？
运算符重载是 C++ 中的一项功能，使运算符（例如 +、- 等）能够处理用户定义的数据类型。这种机制称为编译时多态性，并提供了为不同数据类型定制运算符行为的优点。
例如，我们可以重载“+”运算符来执行整数加法、字符串串联以及复数加法。这增强了运算符的多功能性，使他们能够对更广泛的数据类型进行操作。
2、什么是运算符函数？
运算符函数是一种专门类型的函数，它为特定运算符提供替代实现。它的语法与常规函数类似，但其名称以“operator”关键字开头，后跟运算符符号。
我们可以为同一个运算符定义多个运算符函数，这些函数可以根据它们所使用的操作数的数量和类型来区分。例如，“+”运算符可以针对整数、字符串和复数具有不同的运算符函数实现。这允许对操作员进行定制以满足特定要求。
class ClassName
{
...
public
ReturnType operator OperatorSymbool(argument list)
{
// Implementation logic
}
...
};ReturnType： 运算符函数返回值的类型。
运算符：编程语言中用于执行特定操作的关键字。
OperatorSymbol：程序中重载的运算符的符号。
参数列表：调用函数时传递给函数的参数列表。
3、使用运算符重载将两个复数相加
假设我们不使用运算符重载并且想要将两个复数相加。我们可以通过创建一个名为“Complex”的复数类来实现这一点。在类内部，我们定义了一个名为“add”的公共方法，它执行两个复数的加法。此方法将接受两个复数作为参数，并将它们相加的结果作为新的复数返回。
class Complex {
public:
Complex add(Complex c1, Complex c2) {
// Perform addition of c1 and c2 and return the result
return result;
}
};
//This approach works.
//But it requires us to call add method
Complex c1, c2, res;
res = c1.add(c1, c2);众所周知，运算符重载允许我们更改运算符的行为以处理用户定义的数据类型。因此，对于复数重载“+”运算符，我们可以在“Complex”类中定义一个运算符重载函数。
此函数将指定“+”运算符与复数一起使用时的新行为。该函数可以定义为类的成员函数或友元函数，具体取决于运算符及其所操作的操作数的具体要求。
定义完运算符函数后，我们现在可以使用简单的语句将两个复数 c1 和 c2 相加：res = c1 + c2，这相当于 res = c1.operator+ (c2)。这使得代码更直观、更容易理解。
#include
using namespace std;
class Complex {
private:
int real, imag;
public:
Complex(int r = 0, int i = 0) {
real = r;
imag = i;
}
Complex operator + (Complex c) {
Complex temp;
temp.real = real + c.real;
temp.imag = imag + c.imag;
return temp;
}
int getReal(){
return real;
}
int getImag(){
return imag;
}
};
int main() {
Complex c1(4, 7);
Complex c2(3, 5);
Complex res;
res = c1 + c2;
cout << "Result: " << res.getReal() << " + " << res.getImag() << "i" << endl;
return 0;
}
//output Result: 7 + 12i 
我们还可以将函数签名写成如下：
Complex operator + (const Complex& c)这个版本与之前的版本有几个显着的区别：
- 参数“c”使用“&”运算符通过引用传递，这意味着该函数将接收到原始对象的直接链接而不是副本。
- 参数“c”也被指定为“const”，表示该函数不能更改它所传递的对象。
这些修改被认为是最佳实践，原因如下：
- 通过引用传递对象，函数可以访问原始对象而无需创建重复对象，从而提高效率并避免创建新对象的不必要的开销。
- 将对象指定为“const”有助于防止对该对象进行意外修改，从而降低代码中出现错误和意外行为的风险。
4、重载加法运算符的另一个例子
class opr
{
private:
int a;
float b;
public:
opr(int a, float b)
{
this->a = a;
this->b = b;
}
opr operator + (opr test)
{
opr tmp(0, 0.0);
tmp.a = a + test.a;
tmp.b = b + test.b;
return tmp;
}
void show()
{
cout << a << " " << b << '\n';
}
};
int main()
{
opr obj1(1, 3.3);
opr obj2(2, 1.5);
opr obj3;
obj3 = obj1 + obj2;
obj3.show();
return 0;
}5、运算符重载的一些规则
在 C++ 中重载运算符时，需要记住几个重要规则：
1、至少其中一个操作数必须是用户定义的数据类型。
2、只有内置运算符才能重载。这意味着我们无法创建新的运算符，只能更改现有的运算符以使其工作方式不同。
3、重载运算符不能有默认参数，空参数列表“()”除外。
4、重载运算符不会影响其优先级或结合性。
5、操作数的数量无法更改。例如，一元运算符保持一元，二元运算符保持二元。
6、编译器会自动为每个类重载赋值运算符“=”。换句话说，不需要为赋值运算符创建单独的运算符函数。我们可以使用它来复制同一类的对象，类似于使用复制构造函数。
7、重载运算符时，正确且一致地使用它们以使代码更具可读性和易于理解性至关重要。
6、一元运算符的运算符重载
一元运算符是对单个操作数进行操作的运算符。自增运算符“++”和自减运算符“--”是一元运算符的示例。例如，增量运算符“++”将其操作数的值增加1。它可以用作前缀运算符（放置在操作数之前）或后缀运算符（放置在操作数之后）。
例如：
int x = 5;
// x is incremented to 6, and y is set to 6
int y = ++x;
// x is incremented to 7, but z is set to the original value of x (6)
int z = x++;类似地，减运算符“--”将其操作数的值减1。它也可以用作前缀或后缀运算符。例如：
int x = 5;
// x is decremented to 4, and y is set to 4
int y = --x;
// x is decremented to 3, but z is set to the original value of x (4)
int z = x--;7、重载自增运算符(++)的实现代码
在下面的代码中，我们定义了一个名为“Value”的类，其中包含一个私有成员变量“count”。我们还定义了一个构造函数，将该成员变量初始化为值 2。在类内部，我们将“operator++”函数定义为成员函数，该函数被重载两次（带和不带 int 参数）。这些函数将“count”成员变量的值加 1。
在 main 函数中，我们创建一个“Value”对象 (v) 并对其多次使用“++”运算符。然后，我们使用“getCount”方法来检索“count”成员变量的值。
class Value
{
private:
int count;
public:
Value() : count(2) {}
// prefix version of ++ operator
void operator ++ ()
{
++count;
}
// postfix version of ++ operator
void operator ++ (int)
{
++count;
}
int getCount()
{
return count;
}
};
int main()
{
Value v;
v++;
cout << v.getCount() << "\n";
++v;
++v;
cout << v.getCount() << "\n";
return 0;
}
//output
//3
//5一元运算符函数的前缀和后缀版本之间的唯一区别是参数列表。前缀版本不带参数，而后缀版本带一个“int”类型的参数。该参数实际上并不用于传递整数值，而是向编译器发出信号，指示该函数应用于重载运算符的后缀形式。
8、C++中实现运算符重载的三种方法
(1)、通过成员函数重载运算符
成员函数是在类内部定义并作用于该类的对象的函数。关于运算符重载，一元运算符（对单个参数进行操作的运算符）在其列表中没有参数，而二元运算符（对两个参数进行操作的运算符）只有一个参数。
class Complex
{
private:
double real;
double imag;
public:
Complex(double real = 0, double imag = 0) : real(real), imag(imag) {}
// overload the + operator as a member function
Complex operator + (const Complex& other) const
{
return Complex(real + other.real, imag + other.imag);
}
void print() const
{
cout << real << " + " << imag << "i" << endl;
}
};
int main()
{
Complex c1(1, 2);
Complex c2(3, 4);
Complex c3 = c1 + c2;
c3.print();
return 0;
}(2)、通过友元函数重载运算符
友元函数不是类的成员，但可以直接访问私有和受保护成员，并且可以在类的私有或公共部分中声明。与成员函数相比，它提供了更大的灵活性。
换句话说，如果运算符函数需要访问类的私有和受保护成员，则可以将其定义为友元函数。在这种情况下，一元运算符有一个参数，而二元运算符有两个参数。
class Complex
{
private:
double real;
double imag;
public:
Complex(double real = 0, double imag = 0) : real(real), imag(imag) {}
friend Complex operator + (const Complex& c1, const Complex& c2);
void print()
{
cout << real << " + " << imag << "i" << endl;
}
};
// overload the + operator as a friend function
Complex operator + (const Complex& c1, const Complex& c2)
{
return Complex(c1.real + c2.real, c1.imag + c2.imag);
}
int main()
{
Complex c1(1, 2);
Complex c2(3, 4);
Complex c3 = c1 + c2;
c3.print();
return 0;
}(3)、通过非成员函数重载运算符
非成员函数不是类的成员，无权访问私有成员和受保护成员。
class Complex
{
public:
double real;
double imag;
Complex(double real = 0, double imag = 0) : real(real), imag(imag) {}
void print() const
{
cout << real << " + " << imag << "i" << endl;
}
};
// overload the + operator as a non-member function
Complex operator + (const Complex& c1, const Complex& c2)
{
return Complex(c1.real + c2.real, c1.imag + c2.imag);
}
int main()
{
Complex c1(1, 2);
Complex c2(3, 4);
Complex c3 = c1 + c2;
c3.print();
return 0;
}