C++面向对象编程（五）之运算符重载

最新推荐文章于 2019-09-28 11:11:11 发布

原创最新推荐文章于 2019-09-28 11:11:11 发布 · 870 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#C++ #运算符重载 #二元运算符

c++ 专栏收录该内容

16 篇文章

订阅专栏

本文详细解释了C++中运算符重载的概念、语法、应用场景，并通过实例展示了如何实现运算符重载，包括全局函数法、类成员函数法、友元函数法，以及如何使用运算符重载解决实际问题。

运算符重载：

用户根据自己的需要对C++以提供的运算符进行重载，赋予新的含义，使之一名多用。

运算符重载的本质是，函数调用。

重载运算符的函数一般格式如下：

类型类名:: operator 运算符名称（形参列表） // 这里应该把（operator 运算符名称）看成是函数名

说明：

一个运算符被重载后，原有的意义没有失去，只是定义了相对一特定类的一个新的运算符。

不能重载的运算符 . :: .* ?: sizeof

运算符函数可以重载为成员函数或者友元函数。

关键区别在于成员函数具体this指针，友元函数没有this指针。

定义运算符重载函数名的步骤

全局函数、类成员函数方法实现运算符重载步骤：

要承认操作符重载是一个函数，写出函数名 operator + ()
根据操作数，写出函数参数
根据业务，完善函数返回值（看函数返回引用？还是指针？还是对象），实现业务函数

#include <iostream>
using namespace std;

class Complex
{
private:
	int a;
	int b;
	friend Complex operator+(Complex &c1,Complex &c2);
	friend Complex& operator++(Complex &c1);
	friend Complex operator++(Complex &c1,int);
public:
	Complex(int a=0, int b=0)
	{
		this->a = a;
		this->b = b;
	}
	void printCom()
	{
		cout << a << " + " << b << "i" <<endl;
	}
	//
	Complex operator-(Complex&c2)
	{
		Complex tmp(this->a - c2.a,this->b - c2.b);
		return tmp;
	}
	Complex& operator--()
	{
		this->a --;
		this->b --;
		return *this;
	}
	//后置--
	Complex operator--(int)
	{
		Complex tmp = *this;
		this->a--;
		this->b--;
		return tmp;
	}
};

 

//函数名为operator+  1 全局函数法 实现 + 运算符重载
Complex operator+(Complex &c1,Complex &c2)
{
	Complex tmp(c1.a + c2.a, c1.b + c2.b);
	return tmp;
}
Complex& operator++(Complex &c1)
{
	c1.a++;
	c1.b++;
	return c1;
}

Complex operator++(Complex &c1,int)
{
	Complex tmp = c1;
	c1.a++;
	c1.b++;
	return tmp;
}

int main()
{
	Complex c1(1,2),c2(3,4);

	Complex c3 = c1 + c2;
	c3.printCom();
	//1 全局函数法（友元函数法） 实现 + 运算符重载
	//函数名为operator+ 
	//Complex operator+(Complex &c1,Complex &c2)
	 
	//2 类成员函数法 实现 - 运算符重载
	//c1.operator-(c2) //调用方式
	//Complex operator-(Complex&c2) //左操作数（左边形参）是通过this指针传递，因此不用写。
	Complex c4 = c1 - c2;
	c4.printCom();

	//前置++操作符，用全局函数法实现。
	//Complex& operator++(Complex &c1);
	++c1;
	c1.printCom();

	//前置--操作符，用类成员函数方法
	--c1;
	c1.printCom();
	//后置++操作符，用全局函数法实现 ,C++编译器使用函数占位参数以区别前置++
	//同理后置减减操作符，同样也使用函数占位参数区别前置——
	//Complex operator++(Complex &c1,int)
	c1++;
	c1.printCom();
	c1--;
	c1.printCom();
	//c1.operator--(c2)
	//Complex operator--(int)
	system("pause");
	return 0;
}

C++中通过一个占位参数来区分前置运算和后置运算。

（带有占位参数的运算符重载函数，代表是后置的运算符，如后置++，或者后置--）

友元函数实现操作符重载的应用场景：

当无法修改左操作数的类时，使用全局函数（通常设置为友元）进行重载。

友元函数重载运算符常用于运算符的左右操作数类型不同的情况。

例如用友元函数重载 << >> 操作符。

istream和ostream是C++预定义的流类
cin是istream的对象，cout是ostream的对象
运算符 << 由ostream 重载为插入操作，用于输出基本类型数据
运算符 >> 由 istream 重载为提取操作，用于输入基本类型数据
用友元函数重载 << 和 >> ,输出和输入用户自定义的数据类型。

#include <iostream>
using namespace std;
class Complex
{
private:
	int a;
	int b;
	friend ostream& operator<<(ostream &out, Complex &c1);

public:
	Complex(int a=0, int b=0)
	{
		this->a = a;
		this->b = b;
	}
	void printCom()
	{
		cout<<a<<" + " << b << "i" <<endl;
	}
public:

	//实现 + 运算符重载
	Complex operator+(Complex &c2)
	{
		Complex tmp(a + c2.a, b + c2.b);
		return tmp;
	}

	//前置++
	Complex& operator++()
	{
		a++;
		b++;
		return *this;
	}

	//后置++
	Complex operator++(int)
	{
		//先使用 在让c1加加
		Complex tmp = *this;
		//return c1;
		this->a ++;
		this->b ++;
		return tmp;
	}
	//成员函数法 实现 -运算符重载
	 Complex operator-(Complex &c2)
	{
		Complex tmp(this->a - c2.a, this->b - c2.b);
		return tmp;
	}

	 //前置--
	Complex& operator--()
	{
		this->a --;
		this->b --;
		return *this;
	}

	//后置--
	Complex operator--(int)
	{
		Complex tmp = *this;
		this->a--;
		this->b--;
		return tmp;
	}
};

ostream& operator<<(ostream &out, Complex &c1)
{
	out<<"12345 生活真是苦"<<endl;
	out<<c1.a << " + " << c1.b << "i" << endl;
	return out;
}

void main()
{
	int a = 10;
	Complex c1(1, 2), c2(3, 4);
	cout<<a<<endl; //按照数据类型 

	//1
	cout << c1 ;
	//2 ostream 类中 添加 成员函数 .operator<<
	//ostream
	//cout.operator<<(c1);

	//2 函数返回值当左值 需要返回一个引用
	cout << c1  << "aaddddd"; //连续输出
	//
	//cout.operator<<(c1) .operator<<("aaddddd");
	//void.operator<<("aaddddd");

	system("pause");
}

结论是：函数返回当左值，必须返回一个引用。而且返回一个引用可以实现链式编程。

=, [], ()和->操作符只能通过成员函数进行重载

重载等号=操作符。