C++ 符号重载 之 （ + - * / == != += -= *= /= )

最新推荐文章于 2024-08-30 08:30:00 发布
最新推荐文章于 2024-08-30 08:30:00 发布
阅读量5k 收藏 54
点赞数 6
文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/songbai220/article/details/106309196
版权

本文意在通过 复数 运算来体现 C++ 符号重载 之 （ +  -  *  /   ==  !=  +=  -=  *=  /= ) 

1、通过全局函数作为友元函数实现（ +  -  *  /   ==  !=  )的重载；

2、通过成员函数实现（ +=  -=  *=  /= )  的重载；

3、特别提醒需要注意（ *=  /= )  的重载，在重载的过程中，需要借助临时变量；

代码如下：

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<string>
using namespace std;

//创建复数类
class Complex
{public:
	Complex();
	Complex(double real, double imag);
	void display() const;
	//Complex operator+(const Complex &c) const;//以成员函数重载 + 号
	//以友元函数重载 + - * / == !=
	friend Complex operator+(const Complex &t1, const Complex &t2);
	friend Complex operator-(const Complex &t1, const Complex &t2);
	friend Complex operator*(const Complex &t1, const Complex &t2);
	friend Complex operator/(const Complex &t1, const Complex &t2);
	friend bool operator==(const Complex &t1, const Complex &t2);
	friend bool operator!=(const Complex &t1, const Complex &t2);
	//以成员函数重载 += -= *= /=
	Complex & operator+=(const Complex &t);
	Complex & operator-=(const Complex &t);
	Complex & operator*=(const Complex &t);
	Complex & operator/=(const Complex &t);
protected:
	double m_real;
	double m_imag;
	string m_flag = " + ";//为避免出现虚部为负数的时候，出现+ -*i的形式设立符号标识
};
//构造函数实现
Complex::Complex() { m_real = 0.0; m_imag = 0.0; }
Complex::Complex(double real,double imag):m_real(real),m_imag(imag){}
//成员函数实现
void Complex::display() const
{
	cout << m_real << m_flag << m_imag << "i" << endl;
}
//成员函数重载 + 号
//Complex Complex::operator+(const Complex &c) const
//{
//	Complex tem;
//	tem.m_real = this->m_real + c.m_real;
//	tem.m_imag = this->m_imag + c.m_imag;
//	return tem;
//	//精简写法,会自动创建一个“无名”的临时变量作为返回值，本法只适用于成员函数重载+号
//	//return Complex(this->m_real + c.m_real, this->m_imag + c.m_imag);
//}
//全局函数作为友元函数 重载 + 号
Complex operator+(const Complex &t1, const Complex &t2) 
{
	Complex tem;
	tem.m_real = t1.m_real + t2.m_real;
	tem.m_imag = t1.m_imag + t2.m_imag;
	//虚部符号判断，如果为 负，则改写 m_flag为“ - ”，并将虚部m_imag乘以 -1 转为正值（取绝对值）
	if (tem.m_imag < 0)
	{
		tem.m_flag = " - ";
		tem.m_imag *= -1;
	}
	return tem;
}
//全局函数作为友元函数 重载 - 号
Complex operator-(const Complex &t1, const Complex &t2)
{
	Complex tem;
	tem.m_real = t1.m_real - t2.m_real;
	tem.m_imag = t1.m_imag - t2.m_imag;
	//虚部符号判断，如果为 负，则改写 m_flag为“ - ”，并将虚部m_imag乘以 -1 转为正值（取绝对值）
	if (tem.m_imag < 0)
	{
		tem.m_flag = " - ";
		tem.m_imag *= -1;
	}
	return tem;
}
//全局函数作为友元函数 重载 * 号
Complex operator*(const Complex &t1, const Complex &t2)
{
	Complex tem;
	tem.m_real = t1.m_real * t2.m_real - t1.m_imag * t2.m_imag;
	tem.m_imag = t1.m_real * t2.m_imag + t1.m_imag * t2.m_real;
	//虚部符号判断，如果为 负，则改写 m_flag为“ - ”，并将虚部m_imag乘以 -1 转为正值（取绝对值）
	if (tem.m_imag < 0)
	{
		tem.m_flag = " - ";
		tem.m_imag *= -1;
	}
	return tem;
}
//全局函数作为友元函数 重载 / 号
Complex operator/(const Complex &t1, const Complex &t2)
{
	Complex tem;
	tem.m_real = (t1.m_real*t2.m_real + t1.m_imag*t2.m_imag) / (t2.m_real*t2.m_real + t2.m_imag*t2.m_imag);
	tem.m_imag = (t1.m_real*t2.m_imag + t1.m_imag*t2.m_real) / (t2.m_real*t2.m_real + t2.m_imag*t2.m_imag);
	//虚部符号判断，如果为 负，则改写 m_flag为“ - ”，并将虚部m_imag乘以 -1 转为正值（取绝对值）
	if (tem.m_imag < 0)
	{
		tem.m_flag = " - ";
		tem.m_imag *= -1;
	}
	return tem;
}
//全局函数作为友元函数 重载 == 号
bool operator==(const Complex &t1, const Complex &t2)
{
	if (t1.m_real == t2.m_real&&t1.m_imag == t2.m_imag)
		return true;
	else
		return false;
}
//全局函数作为友元函数 重载 != 号
bool operator!=(const Complex &t1, const Complex &t2)
{
	if (t1.m_real == t2.m_real&&t1.m_imag == t2.m_imag)
		return false;
	else
		return true;
}
//以成员函数 重载 += 号
Complex & Complex::operator+=(const Complex &t)
{
	//this->m_real = this->m_real + t.m_real;
	//this->m_imag = this->m_imag + t.m_imag;
	this->m_real += t.m_real;
	this->m_imag += t.m_imag;
	//虚部符号判断，如果为 负，则改写 m_flag为“ - ”，并将虚部m_imag乘以 -1 转为正值（取绝对值）
	if (this->m_imag < 0)
	{
		this->m_flag = " - ";
		this->m_imag *= -1;
	}
	return *this;
}
//以成员函数 重载 -= 号
Complex & Complex::operator-=(const Complex &t)
{
	//this->m_real = this->m_real - t.m_real;
	//this->m_imag = this->m_imag - t.m_imag;
	this->m_real -= t.m_real;
	this->m_imag -= t.m_imag;
	//虚部符号判断，如果为 负，则改写 m_flag为“ - ”，并将虚部m_imag乘以 -1 转为正值（取绝对值）
	if (this->m_imag < 0)
	{
		this->m_flag = " - ";
		this->m_imag *= -1;
	}
	return *this;
}
//以成员函数 重载 *= 号，这里需要借助临时变量
Complex & Complex::operator*=(const Complex &t)
{
	Complex tem = *this;//用临时变量存储原数据，
	//因为在接下来的第一步操作过后，原数据的实数部分this->m_real发生了变化
	//导致第二部计算虚数部分的操作，不在是原来的实部和虚部的计算
	this->m_real = tem.m_real * t.m_real - tem.m_imag * t.m_imag;
	this->m_imag = tem.m_real * t.m_imag + tem.m_imag * t.m_real;
	//虚部符号判断，如果为 负，则改写 m_flag为“ - ”，并将虚部m_imag乘以 -1 转为正值（取绝对值）
	if (this->m_imag < 0)
	{
		this->m_flag = " - ";
		this->m_imag *= -1;
	}
	return *this;
}
//以成员函数 重载 /= 号，这里需要借助临时变量
Complex & Complex::operator/=(const Complex &t)
{
	Complex tem = *this;//用临时变量存储原数据，
	//因为在接下来的第一步操作过后，原数据的实数部分this->m_real发生了变化
	//导致第二部计算虚数部分的操作，不在是原来的实部和虚部的计算
	this->m_real = (tem.m_real * t.m_real - tem.m_imag * t.m_imag) / (t.m_real * t.m_real + t.m_imag * t.m_imag);
	this->m_imag = (tem.m_real * t.m_imag + tem.m_imag * t.m_real) / (t.m_real * t.m_real + t.m_imag * t.m_imag);
	//虚部符号判断，如果为 负，则改写 m_flag为“ - ”，并将虚部m_imag乘以 -1 转为正值（取绝对值）
	if (this->m_imag < 0)
	{
		this->m_flag = " - ";
		this->m_imag *= -1;
	}
	return *this;
}
//偷懒，定义了2个全局复数 A，B
Complex A(3.0, 4.0);
Complex B(2.0, 5.0);
//打印出来做对比用
void cpr()
{
	cout << "=================================" << endl << endl;
	printf("A = ");
	A.display();
	printf("B = ");
	B.display();
}
//验证 + 号重载
void test01()
{
	cout << endl << "========= + - * / ===============" << endl <<endl;
	/*Complex A(-3.4, 4.5);
	Complex B(6.7, 8.9);*/
	Complex C = A + B;
	//Complex C = A.operator+(B);//这种写法只适用于成员函数重载+号的方式
	//C = A + B;
	cout << "A + B = ";
	C.display();
}
//验证 - 号重载
void test02()
{
	//cout << "========= - 号===============" << endl;
	/*Complex A(-3.4, 4.5);
	Complex B(6.7, 8.9);*/
	Complex C;
	C = A - B;
	cout << "A - B = ";
	C.display();
}
//验证 * 号重载
void test03()
{
	//cout << "========= * 号===============" << endl;
	/*Complex A(-3.4, 4.5);
	Complex B(6.7, 8.9);*/
	Complex C;
	C = A * B;
	cout << "A * B = ";
	C.display();
}
//验证 / 号重载
void test04()
{
	//cout << "========= / 号===============" << endl;
	/*Complex A(-3.4, 4.5);
	Complex B(6.7, 8.9);*/
	Complex C;
	C = A / B;
	cout << "A / B = ";
	C.display();
}
//验证 == 号重载
void test05()
{
	cout << endl << "=========== == != ===============" << endl << endl;
	/*Complex A(-3.4, 4.5);
	Complex B(6.7, 8.9);*/
	bool C = A == B;
	if (C)
	{
		cout << "A == B 成立" << endl;
	}
	else
	{
		cout << "A == B 不成立" << endl;
	}
}
//验证 != 号重载
void test06()
{
	//cout << endl << "======== != 号===============" << endl;
	/*Complex A(-3.4, 4.5);
	Complex B(6.7, 8.9);*/
	bool C = A != B;
	if (C)
	{
		cout << "A != B 成立" << endl;
	}
	else
	{
		cout << "A != B 不成立" << endl;
	}
}
//验证 += -= *= /= 符号号重载
void test07()
{
	cout << endl << "========= += -= *= /= ============" << endl << endl;
	/*Complex A(-3.4, 4.5);
	Complex B(6.7, 8.9);*/
	A += B;
	cout << "A += B = " ;
	A.display();
	//cout << "===============================" << endl;
	A -= B;
	cout << "A -= B = ";
	A.display();
	//cout << "===============================" << endl;
	A *= B;
	cout << "A *= B = ";
	A.display();
	//cout << "===============================" << endl;
	A /= B;
	cout << "A /= B = " ;
	A.display();
}

int main()
{
	cpr();
	test01();
	test02();
	test03();
	test04();
	test05();
	test06();
	test07();

	cout << endl;
	system("pause");
	return EXIT_SUCCESS;
}

运行结果：

=================================

A = 3 + 4i
B = 2 + 5i

========= + - * / ===============

A + B = 5 + 9i
A - B = 1 - 1i
A * B = -14 + 23i
A / B = 0.896552 + 0.793103i

=========== == != ===============

A == B 不成立
A != B 成立

========= += -= *= /= ============

A += B = 5 + 9i
A -= B = 3 + 4i
A *= B = -14 + 23i
A /= B = -4.93103 - 0.827586i

 

Redmaple925
关注
95_C++_string类型各自符号的重载【例如：‘+‘、 ‘-‘ 、‘=‘、‘==‘】
HanLongXia的博客
09-09 411
#include <iostream> using namespace std; #include <string.h> #pragma warning(disable:4996) class String { public: typedef char* Iterator; public: //构造函数 String() {} String(const char* str) { if (nullptr == str) { str = ""; }
C++_类和对象_C++运算符重载_关系运算符重载_对== !=重载实现对象的对比_---C++语言工作笔记059
添柴程序猿的专栏
06-02 368
然后我们再来看关系运算符的重载, 关系运算符就是下面这种,用来判断的符号 > < = 可以看到,普通的int类型,系统是知道怎么去判断相等的 但是如果我们自己写的类,比如上面 p1 == p2 这个时候系统就会报错,不知道怎么处理了 我们还是用代码去看看, 首先我们去写个person类,写上构造方法 可以看到有一个name属性,一个age属性 然后我们去写个测试方法test01,可以看到现在,p1 == p2 是报错的 然后我们去重载 == 号,传入..
详解c/c++赋值函数（重载=号运算符）
01-01
首先c++里的各种运算符都是用函数实现的，比如=，就等号函数。 所以当用=给一个对象赋值的时候，实际调用的是=号所对应的=号函数。 分析下面的代码 #include using namespace std; class Test{ public: explicit Test(){ data = 0; } explicit Test(int d):data(d){ cout <data << endl; } //拷贝构造函数 Test(const Test &t){ cout << Co
c++重载<, +, +=, =, ==, <<, >>等符号
一个人，在路上
05-18 588
以下示例中定义了一个class test, 重载了>等符号: #include #include using namespace std; class test{ public:      int v;         test():v(0){}      test(const int &a):v(a){}      test(const test &t1):v(t
C++的重载
最新发布
weixin_44259499的博客
08-30 364
函数重载：允许在同一作用域内定义多个同名函数，通过不同的参数列表（类型、数量或顺序）进行区分。它提高了代码的灵活性和可读性。运算符重载：允许为运算符赋予新的意义，使其可以操作用户自定义的类型。这使得自定义类型的对象也可以像基本数据类型一样方便地使用运算符。重载是C++语言的重要特性之一，它赋予了开发者在编写代码时更大的灵活性和表达能力。理解和熟练使用重载对于编写高效、可维护的C++代码至关重要。
[C++]C++等号运算符重载
FL1768317420的博客
03-19 416
重载的运算符是带有特殊名称的函数，函数名是由关键字 operator 和其后要重载的运算符符号构成的。运算符重载，就是对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型。有点类似复制构造函数，将等号（=）右边的本类对象的值复制给等号左边的对象。与其他函数一样，重载运算符有一个返回类型和一个参数列表。
重载+，=，+=
dongguxidu1的专栏
10-07 6014
//运算符重载掌握得不够 #include using namespace std; class F { int n; int d; public: F(int n = 0, int d = 1):n(n),d(d) {} friend ostream& operator<<(ostream& o,const F& f) { return o<< f.n << '/' << f.
C++之=运算符重载
Evan_work的博客
03-23 6739
1、类中没有指针成员 如果类中没有指针成员 ，不需要重载=运算，默认的浅拷贝就可以完成幅值。 #include <iostream> using namespace std; class Person { private: int a; int b; public: Person():a(0),b(0) { cout<<"无...
封装高精度+,-,*,/
qq_45879198的博客
12-10 1194
文章目录前言一、封装高精的+,-,*,/ 前言 将高精的+,-,*,/都用结构体封装了一遍 提示：以下是本篇文章正文内容，下面案例可供参考 一、封装高精的+,-,*,/ #include <bits/stdc++.h> #define maxn 100 //定义数组 using namespace std; struct Bigint{ //封装结构体 int len,a[maxn];//为了兼顾效率与代码复杂度，用len记录位数，a记录每个数位 Bigint(int x=0){
封装高精度整数模板(Bigint): +加 -减 *乘 /除 %模 (带一点点解释)
weixin_45488021的博客
02-11 1004
本代码支持： 重载运算符 + - * / % 正负整数(%没有） 全高精度 我菜狗我直接放代码： #include<bits/stdc++.h> #define ll long long using namespace std; namespace Bigint{ const int maxn=2e4+2; struct bigint{ int len, a[maxn]; bool symbol; // 数字长度， 数字， 符号 /
怎样在C++中重载++运算符?
suda_lv的博客
03-14 2131
我们知道在C++中重载运算符是很方便的，尤其是类对象之间的运算尤为方便。但是在重载的运算符中有一个比较特殊，就是++和--运算符。 我们拿++运算符（重载用于类对象之间的运算）来说，这个是存在前++和后++的，我们怎么在使用时辨识这两个++呢？在重载时又要注意什么问题呢？ 当我们重载一个运算符时，尽量不要失去原有的神韵，也就是说不要失去了原来的本意最好。于是我们先看看重载前的++运算符怎么使用
C++（二）运算符重载，+号举例
qq_41131523的博客
02-03 327
运算符重载的作用 内置 对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型 方法一：成员函数重载(Person类做假设) class Person{ public: Person operator+(Person &p) { Person temp; temp.m=this->m+p.m; temp.n=this->n+p.n; return tem...
初入c++（七）运算符的重载+、-、*、/、[]、自加++的重载
tr_ainiyangyang的博客
07-20 752
1.为什么要用到运算符的重载 所谓重载，就是赋予新的含义。函数重载（Function Overloading）可以让一个函数名有多种功能，在不同情况下进行不同的操作。运算符重载（Operator Overloading）也是一个道理，同一个运算符可以有不同的功能. 看下面这个代码：怎样实现虚数的加减。 #include using namespace std; cla
c/c++ 重载运算符 ==和!=的重载
weixin_30807779的博客
12-19 175
重载运算符 ==和!=的重载 问题：假如有一个类似于vector的类，这个类只能存放string，当有2个这个类的对象时，如何比较这2个对象。 自己重载==和!= 代码（重载==，！=） #include <iostream> #include <memory> #include <string> class string_vector{ friend b...
C++重载“=“
xuchaoxin1375的博客
09-30 963
#define _CRT_SECURE_NO_WARNINGS //program 13.2.1.cpp 重载"=" #include <iostream> #include <cstring> using namespace std; class String { private: char * str; public: /*利用初始化列表来建立构造函数(无参默认构造函数String(),该函数讲str初始化为NULL.*/ String ():.
+=,-=重载
crazty的博客
01-11 285
using namespace std; class Complex { public: Complex(int a, int b) { this->a = a; this->b = b; } friend Complex & operator+=(Complex &c1, Complex &c2); friend Complex &operator-=(Complex &c1, Complex &c2); Complex
== !=关系运算符重载
Scarlett的博客
10-19 321
1.1 自定义数据类型 不会内部做 比较 == ！= 1.2 所以要重载 == ！= #define _CRT_SECURE_NO_WARNINGS #include<iostream> #include<string> using namespace std; class Nick { public: Nick(string name, int id) { this->m_id = id; this->m_name = name; } bool o
C++运算符重载之=，+=，-=，*=，/=
qq_58665528的博客
01-10 2815
运算符+，-，*，/的重载https://blog.csdn.net/qq_58665528/article/details/122413141 有了上节的思考，我们再来想想运算符=的重载 1.对于a = b（a.operator(b)）我们不希望b的值被改变，所以参数b一定有const修饰，接着为了减少空间开销，提高运行效率，用引用要比创建一个新的Point对象要好的多，所以参数的类型为const Point& 2. 对于a = b = c(a.operator(b.operator(..
运算符重载（C++）
热爱编程小枫的博客
01-27 833
在C++中，运算符重载是一种机制，允许程序员自定义或改变某些运算符的行为，使其能适用于自定义的数据类型。运算符重载使得程序员能够以更自然、更直观的方式使用这些自定义类型。
定义一个复数类complex,重载运算符+*,使之能
03-25
够计算两个复数相乘。 class complex: def __init__(self, real=0, imag=0): self.real = real self.imag = imag def __mul__(self, other): return complex(self.real * other.real - self.imag * other.imag, self.real * other.imag + self.imag * other.real) def __str__(self): if self.imag >= 0: return f"{self.real}+{self.imag}i" else: return f"{self.real}{self.imag}i" a = complex(1, 2) b = complex(3, 4) c = a * b print(c) # 输出：(-5+10i)
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值