本篇内容来源于对c++课堂上学习内容的记录
通过定义函数实现任意数据类型的运算
假设我们定义了一个复数类，想要实现两个复数的相加肯定不能直接使用“+”运算符，我们可以通过自定义一个函数来实现这个功能：
#include <iostream>
using namespace std;
class Complex //定义Complex类
{public:
Complex( ){real=0;imag=0;} //定义构造函数
Complex(double r,double i){real=r;imag=i;} //构造函数重载
Complex complex_add(Complex &c2); //声明复数相加函数
void display( ); //声明输出函数
private:
double real; //实部
double imag; //虚部
};
Complex Complex∷complex_add(Complex &c2)
{ Complex c;
c.real=real+c2.real;
c.imag=imag+c2.imag;
return c;
}
void Complex∷display( ) //定义输出函数
{cout<<″(″<<real<<″,″<<imag<<″i)″<<endl;}
int main( )
{
Complex c1(3,4),c2(5,-10),c3; //定义3个复数对象
c3=c1.complex_add(c2); //调用复数相加函数
cout<<″c1=″; c1.display( ); //输出c1的值
cout<<″c2=″; c2.display( ); //输出c2的值
cout<<″c1+c2=″; c3.display( ); //输出c3的值
return 0;
}
使用运算符重载实现上述功能
运算符重载是指在编程语言中，为用户自定义的数据类型定义新的行为，使其可以像内置数据类型一样使用运算符。通过运算符重载，程序员可以对用户自定义类型进行特定的操作，而不仅仅局限于语言提供的默认行为。
在大多数编程语言中，运算符重载通常涉及到重定义类或对象的特定方法，以实现对应运算符的功能。具体步骤包括：
选择运算符： 选择要重载的运算符。这可以是算术运算符（如+、-）、关系运算符（如==、!=）、位运算符、赋值运算符等。
定义重载函数： 在类或对象中定义与选择的运算符相关的特定方法。这些方法通常被称为运算符重载函数。在许多语言中，这些函数具有特殊的名称，例如C++中的 operator+、operator==
对于上述的例子，要想使用运算符重载，仅仅需要把复数类中的函数名称由complex_add变成operator+即可，然后就可以直接使用运算符“+”对两个复数进行相加：
重载运算符的一些规则
1.C++不允许用户自己定义新的运算符，只能对已有的运算符进行重载
2.C++有几个运算符是不能重载的，分别是：
.（成员访问运算符）
*（成员指针访问运算符）
::（域运算符）
sizeof（长度运算符）
?:（三目运算符）
3.重载不能改变操作数个数
4.重载不能改变优先级
5.重载不能改变结合性
6.重载的运算符必须和用户定义类型一起使用，参数不能全是C++标准类型
7.有些运算符不用重载就可以对用户定义类型的对象使用，比如“=”和“&”
友元重载运算符
首先简单解释一下友元
在面向对象编程中，友元（Friend）是一种机制，允许一个类或函数访问另一个类的私有成员。这就意味着，如果一个类或函数被声明为另一个类的友元，它就可以直接访问该类的私有成员，而不受访问权限的限制。
友元的主要用途是在某些情况下，允许外部的类或函数访问另一个类的私有部分，以实现更灵活的设计或提高效率。一般而言，友元关系是单向的，即如果类 A 是类 B 的友元，不一定意味着类 B 是类 A 的友元
友元在重载运算符中有什么用呢？
考虑这么一个问题，我想让上述的复数和一个整数相加怎么办，其实很简单，只需要把operator+中的参数类型由Complex改成int就行了，这样，在下面调用的时候，就可以写：
Complex c=a+2;
但是，如果我们写成：
Complex c=2+a;有没有问题呢？当然有问题，这样就是参数列表中的类型顺序不照应了
因此，如果运算符左侧操作数属于C++标准类型或者是一个其它类的对象，则运算符重载函数不能作为成员函数，只能作为非成员函数，如果函数需要访问类的私有成员，则必须声明为友元函数
举个例子：
#include <iostream>
using namespace std;
class Complex
{public:
Complex( ){real=0;imag=0;}
Complex(double r,double i)
{real=r;imag=i;}
friend Complex operator +
(Complex &c1,Complex &c2);
//重载函数作为友元函数
void display( );
private:
double real;
double imag;
};
Complex operator + (Complex &c1,Complex &c2)
//定义作为友元函数的重载函数
{return Complex(c1.real+c2.real, c1.imag+c2.imag);}
void Complex∷display( )
{cout<<″(″<<real<<″,″<<imag<<″i)″<<endl;}
int main( )
{Complex c1(3,4),c2(5,-10),c3;
c3=c1+c2;
cout<<″c1=″; c1.display( );
cout<<″c2=″; c2.display( );
cout<<″c1+c2 =″; c3.display( );}
单目运算符的重载
由于单目运算符本身就一个参数，那么如果运算符重载函数作为成员函数的话，就可以忽略参数
首先看自增运算符++和自减运算符--的重载
此时我们面临一个问题，这两个符号分为前置和后置两种情况，如果区分呢？
C++约定： 在自增(自减)运算符重载函数中，增加一个int型形参，就是后置自增(自减)运算符函数
重载后置自增运算符时，多了一个int型的参数，增加这个参数只是为了与前置自增运算符重载函数有所区别，此外没有任何作用
举个例子：
#include <iostream>
class Counter {
private:
int count;
public:
Counter() : count(0) {}
// 重载前置自增运算符 (++var)
Counter& operator++() {
count++;
return *this; // 返回递增后的对象引用
}
// 重载后置自增运算符 (var++)
Counter operator++(int) {
Counter temp(*this); // 创建一个副本用于保存递增前的值
count++;
return temp; // 返回递增前的对象副本
}
void display() const {
std::cout << "Count: " << count << std::endl;
}
};
int main() {
Counter myCounter;
// 使用前置自增运算符
++myCounter;
myCounter.display();
// 使用后置自增运算符
Counter anotherCounter = myCounter++;
myCounter.display();
anotherCounter.display();
return 0;
}
重载“<<”和">>"
格式：
重载"<<"
#include <iostream>
class Point {
private:
int x, y;
public:
Point(int xCoord, int yCoord) : x(xCoord), y(yCoord) {}
// 重载输出运算符
friend std::ostream& operator<<(std::ostream& out, const Point& point);
std::ostream& operator<<(std::ostream& out, const Point& point) {
out << "Point(" << point.x << ", " << point.y << ")";
return out;
}
int main() {
Point myPoint(3, 4);
// 使用重载的输出运算符
std::cout << "My Point: " << myPoint << std::endl;
return 0;
}
为什么在函数当中最后要返回out呢？
可以满足链式编程，实现类似:cout<<myPoint1<<myPoint2<<endl;的输出
下面看对">>"的重载
#include <iostream>
class Point {
private:
int x, y;
public:
Point() : x(0), y(0) {}
// 重载输入运算符
friend std::istream& operator>>(std::istream& in, Point& point);
// 用于显示坐标的成员函数
void display() const {
std::cout << "Point(" << x << ", " << y << ")";
}
};
std::istream& operator>>(std::istream& in, Point& point) {
std::cout << "Enter x-coordinate: ";
in >> point.x;
std::cout << "Enter y-coordinate: ";
in >> point.y;
return in;
}
int main() {
Point myPoint;
// 使用重载的输入运算符
std::cout << "Please enter coordinates for a point:\n";
std::cin >> myPoint;
// 使用成员函数显示坐标
std::cout << "You entered: ";
myPoint.display();
std::cout << std::endl;
return 0;
}
转换构造函数和类型转换函数
转换构造函数(conversion constructor function) 的作用是将一个其他类型的数据转换成一个类的对象，本质是就是一种特殊的有参构造函数
class Celsius {
private:
double temperature;
public:
// 转换构造函数，将double类型转换为Celsius对象
Celsius(double temp) : temperature(temp) {}
void display() {
std::cout << "Temperature in Celsius: " << temperature << " C" << std::endl;
}
};
int main() {
// 使用转换构造函数，将double类型转换为Celsius对象
Celsius celsiusObject = 25.5;
celsiusObject.display();
return 0;
}
类型转换函数：用转换构造函数可以将一个指定类型的数据转换为类的对象。但是不能反过来将一个类的对象转换为一个其他类型的数据(例如将一个Complex类对象转换成double类型数据)。 C++提供类型转换函数(type conversion function)来解决这个问题
一般形式
operator 类型名()
{实现转换的语句}
注意：
1.类型转换函数只能作为成员函数，因为转换的主体是本类对象，不能作为友元函数或普通函数
2.从函数形式可以看到，它与运算符重载函数相似，都是用关键字operator开头，只是被重载的是类型名
3.程序中的Complex类对象是不是一律都转换成为double类型数据？否，Complex对象既是Complex对象，也可以作为double类型数据，需要时才进行转换
针对最前面那个复数类的例子，如果在类中定义：
operator double(){return real;}
在main函数中如果有：
Complex a(1,2);
double d=a+2.5;
此时在没有特定运算符重载函数的情况下，编译器将会自动把a转换为double和2.5相加
假如程序中需要对一个Complex类对象和一个double型变量进行+,-,*,/等算术运算，以及关系运算和逻辑运算，如果不用类型转换函数，就要对多种运算符进行重载，以便能进行各种运算 如果用类型转换函数对double进行重载(使Complex类对象转换为double型数据)，就不必对各种运算符进行重载，因为Complex类对象可以被自动地转换为double型数据，而标准类型的数据的运算，是可以使用系统提供的各种运算符的
注意！如果同时有转换构造函数和类型转换函数，可能出现二义性！
比如进行上述的double d=a+2.5;时，我到底是把a通过类型转换函数变成double呢，还是让2.5通过转换构造函数变为Complex呢？？？在使用的时候要注意这一点
