C++运算符重载总结

一、C++操作符重载的意义

1、当运算符作用于类类型的运算对象时，可以通过运算符重载重新定义该运算符的含义。
2、在模板编程实现的泛型编程中，对不同类型实现相同的语义，各自类通过操作符重载实现对应语义。
例如：由模板类自己定义大小关系。

// FUNCTION TEMPLATE _Min_value
template<class _Ty>
	_Post_equal_to_(_Right < _Left ? _Right : _Left)
	constexpr const _Ty& _Min_value(const _Ty& _Left, const _Ty& _Right)
		_NOEXCEPT_COND(_NOEXCEPT_OPER(_Right < _Left))
	{	// return smaller of _Left and _Right
	return (_Right < _Left ? _Right : _Left);
	}

		// FUNCTION TEMPLATE _Max_value
template<class _Ty>
	_Post_equal_to_(_Left < _Right ? _Right : _Left)
	constexpr const _Ty& _Max_value(const _Ty& _Left, const _Ty& _Right)
		_NOEXCEPT_COND(_NOEXCEPT_OPER(_Left < _Right))
	{	// return larger of _Left and _Right
	return (_Left < _Right ? _Right : _Left);
	}

二、哪些运算符能够重载？哪些不可重载？哪些不该被重载？

1、能够被重载的运算符

//	new delete new[] delete[]	//内存分配的接管作用
//	+ - * / % 
//	^ & | ~ 
//	! = < > 
//	+= -= *= /= %= <= >= 
//	<< >> <<= >>=
//	== != <= >=
//	&& ||
//	++ -- //分前置和后置
//	,
//	->* -> () []				//通过指针取成员指针、通过指针取成员、强制类型转换、数组取下标

2、不可重载的运算符

//	.			通过对象（结构体）取成员
//	.*			通过对象取成员指针
//	::			作用域分辨符
//	?:			条件运算符
//	sizeof		计算数据大小运算符

3、不该被重载的运算符

//	,			//逗号表达式
//	&			//取地址
//	&& ||		//逻辑与逻辑或

三、运算符的重载规则

1、重载后运算符的优先级与结合性不会改变。
2、不能改变原有运算符操作数的个数。
3、不能重载C++没有的运算符。
4、不能改变运算符的原有语义。

四、运算符函数重载的两种形式

1、重载为类的成员函数(隐含参数this)
2、重载为类的非成员函数(一般为友元函数)。

五、什么时候应该重载为类的成员函数运算符，什么时候应该重载为类的友元函数运算符？

1、一般，单目运算符最好重载为类的成员函数，双目运算符则最好重载为友元函数。
2、一些双目运算符（=，()，[]，->）不能重载为类的友元函数。
3、类型转换函数只能定义一个类的成员函数。
4、若一个运算符的操作需要修改对象的状态，选择重载成员函数较好。
5、若运算符所需操作数（尤其是第一个操作数）期望有隐式的类型转换，则只能选择友元函数。
6、当运算符函数是一个成员函数时，最左边的操作数（或者只有最左边的操作数）必须是运算符类的一个类对象(包括引用)。如果左边操作数必须是一个不同类的对象，或者一个基本数据类型的对象，该运算符必须作为一个友元函数来实现。
7、当需要考虑运算符的运算具有可交互性，选择重载为友元函数。

六、运算符重载实现的示例

Complex.h

#pragma once
#include <iostream>
#include <cmath>

class Complex
{
private:
	double re, im;

public:
	//获取成员变量
	const double& real()const { return re; }
	const double& imag()const { return im; }
	//支持类型转换的构造
	Complex(double r = 0, double i = 0)
		:re(r), im(i)
	{
		std::cout << this << std::endl;
	}
	//拷贝构造
	Complex(const Complex& Com);


	//自我赋值检测的拷贝赋值
	Complex& operator=(const Complex& Com);
	//bool类型转换，在原点为返回false
	explicit operator bool() const noexcept;
	//取反
	Complex operator-() const;
	//前置++,__，实部加1,减法1
	Complex operator++();
	Complex operator--();
	//后置++,__，实部加1,减法1
	Complex operator++(int);					//重点
	Complex operator--(const int);				//const int和int无差别，不能同时存在
	//重载!，求共轭复数
	Complex operator!() const;
	//重载()为仿函数，求模
	double operator()() const;

	//重载<<用以输出复数
	friend std::ostream& operator<<(std::ostream&, const Complex&);
	//加减乘除
	friend Complex operator+(const Complex& Com1, const Complex& Com2);
	friend Complex& operator+=(Complex& Com1, const Complex& Com2);
	friend Complex operator-(const Complex& Com1, const Complex& Com2);
	friend Complex& operator-=(Complex& Com1, const Complex& Com2);
	friend Complex operator*(const Complex& Com1, const Complex& Com2);
	friend Complex& operator*=(Complex& Com1, const Complex& Com2);
	friend Complex operator/(const Complex& Com1, const Complex& Com2);
	friend Complex& operator/=(Complex& Com1, const Complex& Com2);
	//相等、大小判断
	friend bool operator==(const Complex& Com1, const Complex& Com2);
	friend bool operator!=(const Complex& Com1, const Complex& Com2);
	friend bool operator<(const Complex& Com1, const Complex& Com2);
	friend bool operator<=(const Complex& Com1, const Complex& Com2);
	friend bool operator>(const Complex& Com1, const Complex& Com2);
	friend bool operator>=(const Complex& Com1, const Complex& Com2);
};

Complex.cpp

#include "Complex.h"

Complex::Complex(const Complex& Com)
{
	std::cout << this << std::endl;
	this->re = Com.re;
	this->im = Com.im;
}
Complex& Complex::operator=(const Complex& Com)
{
	std::cout << this << std::endl;
	if (this != &Com)
	{
		this->re = Com.re;
		this->im = Com.im;
		return (*this);
	}
	return (*this);
}

Complex::operator bool() const noexcept		//explicit只能写在声明中，不能写在定义中。
{
	if (0 == this->re && 0 == this->im)
		return false;
	else
		return true;
}
Complex Complex::operator-() const
{
	return Complex(-this->re, -this->im);
}
//前置++，--
Complex Complex::operator++()
{
	return Complex(++this->re, this->im);
}
Complex Complex::operator--()
{
	return Complex(--this->re, this->im);
}

//后置++，--
Complex Complex::operator++(int)
//Complex operator++(const int)		//亦可
{
	return Complex(this->re++, this->im);
	//拆分开则为下列三行
	/*Complex Com(*this);
	++this->re;
	return Com;*/
}
Complex Complex::operator--(const int)
{
	return Complex(this->re--, this->im);
}
Complex Complex::operator!() const
{
	return Complex(this->re, -this->im);
}
double Complex::operator()() const
{
	return sqrt(pow(this->re, 2) + pow(this->im, 2));
}

std::ostream& operator<<(std::ostream& os, const Complex& Com)
{
	return os << '(' << Com.real() << ',' << Com.imag() << ')';
}

Complex operator+(const Complex& Com1, const Complex& Com2)
{
	return Complex(Com1.re + Com2.re, Com1.im + Com2.im);
}
Complex& operator+=(Complex& Com1, const Complex& Com2)
{
	Com1.re += Com2.re;
	Com1.im += Com2.im;
	return Com1;
}
Complex operator-(const Complex& Com1, const Complex& Com2)
{
	return Complex(Com1.re - Com2.re, Com1.im - Com2.im);
}
Complex& operator-=(Complex& Com1, const Complex& Com2)
{
	Com1.re -= Com2.re;
	Com1.im -= Com2.im;
	return Com1;
}
Complex operator*(const Complex& Com1, const Complex& Com2)
{
	return Complex((Com1.re * Com2.re) - (Com1.re * Com2.re), (Com1.im * Com2.re) + (Com1.re * Com2.im));
}
Complex& operator*=(Complex& Com1, const Complex& Com2)
{
	Com1.re = (Com1.re * Com2.re) - (Com1.re * Com2.re);
	Com1.im = (Com1.im * Com2.re) + (Com1.re * Com2.im);
	return Com1;
}
Complex operator/(const Complex& Com1, const Complex& Com2)
{
	double acbd = (Com1.re * Com2.re) + (Com1.re * Com2.re);
	double bc_ad = (Com1.im * Com2.re) + (Com1.re * Com2.im);
	double c2d2 = Com2.re * Com2.re + Com2.im * Com2.im;
	return Complex(acbd / c2d2, bc_ad / c2d2);
}
Complex& operator/=(Complex& Com1, const Complex& Com2)
{
	double acbd = (Com1.re * Com2.re) + (Com1.re * Com2.re);
	double bc_ad = (Com1.im * Com2.re) + (Com1.re * Com2.im);
	double c2d2 = Com2.re * Com2.re + Com2.im * Com2.im;
	Com1.re = acbd / c2d2;
	Com1.im = bc_ad / c2d2;
	return Com1;
}

bool operator==(const Complex& Com1, const Complex& Com2)
{
	if (Com1.real() == Com2.real() && Com1.imag() == Com2.imag())
		return true;
	else
		return false;
}
bool operator!=(const Complex& Com1, const Complex& Com2)
{
	if (Com1.real() != Com2.real() || Com1.imag() != Com2.imag())
		return true;
	else
		return false;
}
bool operator<(const Complex& Com1, const Complex& Com2)
{
	if (Com1() < Com2())
		return true;
	else
		return false;

}
bool operator<=(const Complex& Com1, const Complex& Com2)
{
	if (Com1() <= Com2())
		return true;
	else
		return false;
}
bool operator>(const Complex& Com1, const Complex& Com2)
{
	if (Com1() > Com2())
		return true;
	else
		return false;
}
bool operator>=(const Complex& Com1, const Complex& Com2)
{
	if (Com1() >= Com2())
		return true;
	else
		return false;
}

String.h

#pragma once
#include <iostream>
#include <cstring>

class String
{
private:
	char *m_StrData;
public:
	String(const char *strp = nullptr)
	{
		if (nullptr != strp)
		{
			this->m_StrData = new char[strlen(strp) + 1];
			strcpy_s(m_StrData, strlen(strp) + 1, strp);
		}
		else
		{
			this->m_StrData = new char[1];
			*(this->m_StrData) = '\0';
		}
	}
	String(const String& strp)
	{
		this->m_StrData = new char[strp.leng() + 1];
		strcpy_s(this->m_StrData, strp.leng() + 1, strp.m_StrData);
	}
	String& operator= (const String& strp)
	{
		if (this != &strp)
		{
			delete[] m_StrData;
			m_StrData = new char[strp.leng() + 1];
			strcpy_s(this->m_StrData, strp.leng() + 1, strp.m_StrData);
			return (*this);
		}
		return (*this);
	}
	~String()
	{
		if (nullptr != m_StrData)
			delete[] this->m_StrData;
	}

	//字符个数
	unsigned int leng() const
	{
		return strlen(this->m_StrData);
	}

	char& operator[](const unsigned int off)
	{
		return *(m_StrData + off);
	}
	const char& operator[](const unsigned int off) const
	{
		return *(m_StrData + off);
	}
	String* operator->()
	{
		return this;
	}
	const char* operator*() const
	{
		return (this->m_StrData);
	}
	//重载<<
	friend std::ostream& operator<<(std::ostream&, const String&);
};

std::ostream& operator<<(std::ostream& os, const String& strp)
{
	return os << strp.m_StrData;
}

如有错误或不足欢迎评论指出！创作不易，转载请注明出处。如有帮助，记得点赞关注哦(⊙o⊙)
更多内容请关注个人博客：https://blog.csdn.net/qq_43148810