C++运算符重载详解-优快云博客

本文链接：https://blog.youkuaiyun.com/chentaowangyuanyuan/article/details/47663887

一运算符重载概述

二重载运算符的实现
1 作为成员函数重载运算符
A 双目运算符重载
B 单目运算符重载
2 作为全局（友元）函数重载运算符
A 双目运算符重载
B 单目运算符重载

三、重载的规则和原则：

-----------------------------------------------------------------------------------------------------------

一、运算符重载概述

运算符重载，就是对已有的运算符进行重新定义，赋予其另一个功能，以适应不同的数据类型，

即一个名字的运算符可以代表不同的运算操作。

例如，程序中可以利用“+”对整型数、单精度、双精度以及指针进行加法运算等，如：

int a=1+1; //对整型数加

double d=2.2+2.2; //对双精度加

int arr[10];

int *p=arr;

p=p+1; //对指针加 p指向了第二个元素

现在，若有一个自定义的复数类型Complex，有两个复数对象c1=(5+10i),c2=(10-0.5i)，

能否直接使用“+”进行两个复数对象相加，即如表达式c1+c2能够成立呢？

答案是：可以，但程序员必须对“+”重载，

因为对于内置类型C++自身已经帮这些类型做了+的重载，而这些新类型就需要我们自己去做。

二、重载运算符的实现

重载的运算符函数语法为:

Operator为关键字，专门用于定义重载的运算符函数，#代表要被重载的运算符。

<返回值类型> operator # (<形参列表>)

{

用户实现的相关操作在这里

}

例如：

Complex operator + (Complex &a, Complex &b)

{

1、作为成员函数重载运算符

作为成员函数重载时，运算符函数内的参数个数一般比运算符操作数个数少一个。

因为，对于类的非静态成员函数，第一个参数默认为指向对象的this指针

（例外：++,--作为后置时，有一个参数）。

A、双目运算符重载

作为非static成员函数重载双目运算符，只需要给出运算符右边操作数，左操作数为隐含的this指针，其函数原型声明为:

<返回值类型> operator # (<类型>);

函数定义形式为:

<返回值类型>[<类名::>] operator #(<类型> &<参数>)

｛

B、单目运算符重载

作为类的非静态成员函数重载单目运算符，一般不需要参数（后置++,--除外），

运算符的左操作数由函数隐含this指针提供，即运算符的前置用法。

函数的声明语法为:

<返回值类型> operator # ();

<pre name="code" class="cpp">// 成员函数重载.cpp : Defines the entry point for the console application.
/*
使用成员函数来重载operator 单目运算符取反运算符-。
*/

#include "stdafx.h"
#include "iostream"

using namespace std;

class Complex
{
public:
	Complex(double r = 0.0, double i = 0.0) :real(r), imag(i){}


	Complex operator -(const Complex& c); 		//重载双目运算符运算符减号-， 双目运算一个参数 
	Complex operator -()				//重载单目运算符取反-，单目运算没有参数
	{
		return Complex(-real, -imag);
	}
	friend ostream& operator <<(ostream& os, const Complex &c);

private:
	double real, imag;				//实部、虚部
};

Complex Complex::operator-(const Complex &c)
{
	return Complex(real - c.real, imag - c.imag);	//注意返回值类型
}

ostream& operator <<(ostream& os, const Complex& c)
{
	os << "(" << c.real << " ," << c.imag << " i）";
	return os;
}

int _tmain(int argc, _TCHAR* argv[])
{

	Complex c1(10, 5);
	Complex c2(10, -5);
	Complex c3, c4;

	c3 = -c1;				//调用单目运算符取反-
	c4 = c1 - c2;			<span style="white-space:pre">	</span>//调用双目运算符相减-

	cout << c3 << endl;
	cout << c4 << endl;

	return 0;
}

2、作为全局（友元）函数重载运算符

A、双目运算符重载

用全局（友元）函数来实现双目运算符重载时，需要两个函数，

函数声明语法为:

[friend]<返回值类型> operator # (<类型1>[<左参数>],<类型2>[<左参数>]);

运算符函数实现形式为:

< 返回值类型> operator # (<类型1>[<左参数>],<类型2>[<左参数>])

{

B、单目运算符重载

用全局（友元）函数实现单目运算符重载时，需要给出一个参数，并且该参数的类型必须是类、结构、枚举或它们的引用类型。

它重载的是运算符前置的用法，对于后置的++,--要增加第二个参数int,以和前置++,--区别。

函数声明的语法为:

[friend] <返回值类型> operator # (<类型>[<右参数>]);

其中，#代表被重载的运算符，<右参数>描述的是运算符右边的操作数。

实例双目与单目

// 成员函数重载.cpp : Defines the entry point for the console application.
/*
<span style="white-space:pre">	</span>使用友元函数来重载 双目目运算符== 和！=
*/

#include "stdafx.h"
#include "iostream"

using namespace std;

class Complex
{
public:
	Complex(double r = 0.0, double i = 0.0) :real(r), imag(i){}

	friend bool operator ==(const Complex &c1,const Complex &c2);	//友元重载双目运算符	
	friend bool operator !=(const Complex &c1, const Complex &c2);
	friend Complex operator -(Complex& c);				//友元重载单目运算符取反-	
	friend ostream& operator <<(ostream& os, const Complex &c);	//重载运算符<<

private:
	double real, imag;					
};

bool operator ==(const Complex &c1,const Complex &c2)
{
	return (c1.real == c2.real) && (c1.imag == c2.imag);
}

bool operator !=(const Complex &c1, const  Complex &c2)
{
	return !(c1 == c2);
}

Complex operator -(Complex &c)
{
	return Complex(-c.real, -c.imag);
}

ostream& operator <<(ostream& os, const Complex& c)
{
	os << "(" << c.real << " ," << c.imag << "i）";
	return os;
}

int _tmain(int argc, _TCHAR* argv[])
{

	Complex c1(10, 5);
	Complex c2(10,-5);
	Complex c3(10,-5);
	Complex c4;

	cout << "c1等于c2吗？" << (c1 == c2);<span style="white-space:pre">	</span>//记得给加括号，因为==的优先级低于<<
	cout << endl;
	cout << "c1不等于C2吗？" << (c1 != c2);
	cout << endl;
	cout << "c2等于c3吗？" << (c2 == c3);
	cout << endl;

	c4 = - c1;
	cout << c4 << endl;

	return 0;
}