四、类和对象——4.5运算符重载

最新推荐文章于 2024-11-08 09:08:26 发布
最新推荐文章于 2024-11-08 09:08:26 发布
阅读量165 收藏
点赞数
分类专栏： C++核心编程 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51174762/article/details/115704458
版权

文章目录

前言

运算符重载的方式：

  1. 运算符重载为成员函数
  2. 运算符重载为友元函数

一、加号运算符重载

1、成员函数重载+号

代码如下（示例）：

#include <iostream>
using namespace std;


class Person
{
public:
	//1、成员函数重载+号
	Person operator+(Person& p)
	{
		Person temp;
		temp.m_A = this->m_A + p.m_A;
		temp.m_B = this->m_B + p.m_B;
		return temp;
	}

	int m_A;
	int m_B;
};

void test01()
{
	Person p1;
	p1.m_A = 10;
	p1.m_B = 10;
	Person p2;
	p2.m_A = 10;
	p2.m_B = 10;

	Person p3 = p1 + p2;    //法1
	//成员函数本质调用
	//Person p3 = p1.operator+(p2);    //法2

	cout << "p3.m_A = " << p3.m_A << endl;
	cout << "p3.m_B = " << p3.m_B << endl;

}

int main()
{
	test01();

	return 0;
}

运行结果如下：

在这里插入图片描述

2、全局函数重载+号

代码如下（示例）：

#include <iostream>
using namespace std;


class Person
{
public:

	int m_A;
	int m_B;
};

//2、全局函数重载+号
Person operator+(Person& p1, Person& p2)
{
	Person temp;
	temp.m_A = p1.m_A + p2.m_A;
	temp.m_B = p1.m_A + p2.m_B;
	return temp;
}

void test01()
{
	Person p1;
	p1.m_A = 10;
	p1.m_B = 10;
	Person p2;
	p2.m_A = 10;
	p2.m_B = 10;

	Person p3 = p1 + p2;
	//全局函数本质调用
	//Person p3 = operator+(p1, p2);

	cout << "p3.m_A = " << p3.m_A << endl;
	cout << "p3.m_B = " << p3.m_B << endl;

}

int main()
{
	test01();

	return 0;
}

运行结果如下：
在这里插入图片描述

3、运算符重载也可以函数重载

代码如下（示例）：

#include <iostream>
using namespace std;


class Person
{
public:

	int m_A;
	int m_B;
};

//2、全局函数重载+号
Person operator+(Person& p1, Person& p2)
{
	Person temp;
	temp.m_A = p1.m_A + p2.m_A;
	temp.m_B = p1.m_A + p2.m_B;
	return temp;
}

Person operator+(Person& p1, int num)   //这个函数与上面的函数重载
{
	Person temp;
	temp.m_A = p1.m_A + num;
	temp.m_B = p1.m_B + num;
	return temp;
}

void test01()
{
	Person p1;
	p1.m_A = 10;
	p1.m_B = 10;
	Person p2;
	p2.m_A = 10;
	p2.m_B = 10;

	Person p3 = p1 + p2;
	Person p4 = p1 + 100;   //相当于 Person + int 

	cout << "p3.m_A = " << p3.m_A << endl;
	cout << "p3.m_B = " << p3.m_B << endl;

	cout << "p4.m_A = " << p4.m_A << endl;
	cout << "p4.m_B = " << p4.m_B << endl;

}

int main()
{
	test01();

	return 0;
}

运行结果如下：
在这里插入图片描述

总结

  1. 对于内置的数据类型（例如 int float…）的表达式的运算符时不可能改变的。
    ps: 第一条例如： 1 + 1 = 2；两个int型的数相加， 你想通过你的重载后使得 1+ 1 = 0 这样时不行的。我们只能改变自定义数据类型的表达式的运算符

  2. 不要滥用运算符重载

二、左移运算符重载

1.作用

  • 可以输出自定义数据类型

代码如下（示例）：

#include <iostream>
using namespace std;

class Person
{
public:
	/*void operator<<(cout)  //简化后为：p.operator<<(cout)
	{
	                //因此，不会利用成员函数来重载<<运算符，应为无法
	}*/             //实现简化后cout 在左侧，那就只能利用友元函数（全局函数）
	                //重载 左移运算符
	int m_A;
	int m_B;
};

void test01()
{
	Person p;
	p.m_A = 10;
	p.m_B = 10;

	cout << p.m_A << endl;
}

int main()
{
	test01();

	return 0;
}

上述写法是不对的，原因写在注释里了。

2.代码示例

代码如下（示例）：

#include <iostream>
using namespace std;

class Person
{
	friend ostream& operator<<(ostream& out, Person& p);
public:
	Person(int a, int b)
	{
		m_A = a;
		m_B = b;
	}
private:
	int m_A;
	int m_B;
};

ostream& operator<<(ostream& out, Person& p)     //ostream只能有一个，所以第一个形参是 引用
{
	out << "p.m_A = " << p.m_A << " p.m_B = " << p.m_B;
	return out;
}

void test01()
{
	Person p(10, 10);
	/*p.m_A = 10;
	p.m_B = 10;*/

	cout << p << endl;
}

int main()
{
	test01();

	return 0;
}

运行结果如下 ：
在这里插入图片描述

总结

  • 重载运算符配合友元可以实现输出自定义数据类型

三、递增运算符重载

作用

  • 通过重载递增运算符，实现自己的整型数据

代码示例1

代码如下（示例）：

#include <iostream>
using namespace std;

class MyInteger
{
	friend ostream& operator<< (ostream& cout, MyInteger myint);
public:
	MyInteger()
	{
		m_Num = 0;
	}
	//重载前置++运算符，返回引用是为了 一直对一个数据进行递增操作
	MyInteger& operator++()
	{
		m_Num++;          //先进行++运算
		return *this;     //再将自身做返回
	}
	//重载后置++运算符


private:
	int m_Num;
};

//重载左移运算符
ostream& operator<< (ostream& cout, MyInteger myint)
{
	cout << myint.m_Num;
	return cout;
}

void test01()
{
	MyInteger myint;

	cout << ++(++myint) << endl;
	cout << myint << endl;
}

int main()
{
	test01();

	return 0;
}

运行结果如下 ：
在这里插入图片描述

代码示例2

代码如下（示例）：

#include <iostream>
using namespace std;

class MyInteger
{
	friend ostream& operator<< (ostream& cout, MyInteger myint);
public:
	MyInteger()
	{
		m_Num = 0;
	}
	//重载前置++运算符，返回引用是为了 一直对一个数据进行递增操作
	MyInteger& operator++()
	{
		m_Num++;          //先进行++运算
		return *this;     //再将自身做返回
	}
	//重载后置++运算符
	MyInteger operator++(int)
	{
		//先 记录当时结果
		MyInteger temp = *this;
		//后 递增
		m_Num++;
		//最后将记录结果返回
		return temp;
	}

private:
	int m_Num;
};

//重载左移运算符
ostream& operator<< (ostream& cout, MyInteger myint)
{
	cout << myint.m_Num;
	return cout;
}

void test01()
{
	MyInteger myint;

	cout << ++(++myint) << endl;
	cout << myint << endl;
}

void test02()
{
	MyInteger myint;

	cout << myint++ << endl;
	cout << myint << endl;
}

int main()
{
	//test01();
	test02();

	return 0;
}

运行结果如下 ：
在这里插入图片描述

总结

  • 前置递增返回引用，后置递增返回值

四、赋值运算符重载

C++编译器至少给一个类添加4个函数

  1. 默认构造函数（无参，函数体为空）
  2. 默认析构函数（无参，函数体为空）
  3. 默认拷贝构造函数，对属性执行值拷贝。
  4. 赋值运算符operator=，对属性进行值拷贝。

如果类中有属性指向堆区，做赋值操作时也会出现深浅拷贝问题。

代码示例

代码如下（示例）：

#include <iostream>
using namespace std;

class Person
{
public:
	Person(int age)
	{
		m_Age = new int(age);
	}
	~Person()
	{
		if (m_Age != 0)
		{
			delete m_Age;
			m_Age = NULL;
		}
	}
	//重载 赋值运算符
	Person& operator=(Person& p)
	{
		//编译器是提供浅拷贝
		//m_Age = p.m_Age;

		//应该先判断是否有属性在堆区，如果有先释放干净
		if (m_Age != NULL)
		{
			delete m_Age;
			m_Age = NULL;
		}

		//深拷贝
		m_Age = new int(*p.m_Age);

		//返回对象本身
		return *this;
	}

	int* m_Age;
};

void test01()
{
	Person p1(18);
	Person p2(20);
	Person p3(25);
	p3 = p2 = p1;

	cout << "p1的年龄为：" << *p1.m_Age << endl;
	cout << "p2的年龄为：" << *p2.m_Age << endl;
	cout << "p3的年龄为：" << *p3.m_Age << endl;

}

int main()
{
	test01();

	return 0;
}

运行结果如下 ：
在这里插入图片描述

五、关系运算符重载

作用

  • 重载关系运算符，可以让两个自定义类型对象进行对比操作

重载==运算符

代码如下（示例）：

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

class Person
{
public:
	Person(string name, int age)
	{
		m_Name = name;
		m_Age = age;
	}
	//重载关系运算符==
	bool operator==(Person& p)
	{
		if (this->m_Name == p.m_Name && this->m_Age == p.m_Age)
		{
			return true;
		}
		else return false;
	}

	string m_Name;
	int m_Age;
};

void test01()
{
	Person p1("Tom", 18);
	Person p2("Tom", 18);

	if (p1 == p2)
	{
		cout << "p1和p2是相等的! " << endl;
	}
	else
	{
		cout << "p1和p2是不相等的！" << endl;
	}
}

int main()
{
	test01();

	return 0;
}

运行结果如下 ：
在这里插入图片描述

重载 != 运算符

代码如下（示例）：

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

class Person
{
public:
	Person(string name, int age)
	{
		m_Name = name;
		m_Age = age;
	}
	//重载 == 运算符
	bool operator==(Person& p)
	{
		if (this->m_Name == p.m_Name && this->m_Age == p.m_Age)
		{
			return true;
		}
		else return false;
	}

	//重载 != 运算符
	bool operator!=(Person& p)
	{
		if (this->m_Name == p.m_Name && this->m_Age == p.m_Age)
		{
			return false;
		}
		else return true;

	}

	string m_Name;
	int m_Age;
};

void test01()
{
	Person p1("Tom", 18);
	Person p2("Jerray", 18);

	if (p1 != p2)
	{
		cout << "p1和p2是不相等的! " << endl;
	}
	else
	{
		cout << "p1和p2是相等的！" << endl;
	}
}

int main()
{
	test01();

	return 0;
}

运行结果如下 ：
在这里插入图片描述

六、函数调用运算符重载

  • 函数调用运算符（）也可以重载
  • 由于重载后使用的方式非常像函数的调用，因此称为仿函数
  • 仿函数没有固定写法，非常灵活

代码示例

代码如下（示例）：

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

class MyPrint
{
public:

	//重载函数调用运算符
	void operator()(string test)
	{
		cout << test << endl;
	}
};

void test01()
{
	MyPrint myprint;
	myprint("hello world");  //由于使用起来非常类似于函数调用，因此称为仿函数
}

//仿函数非常灵活，没有固定的写法
//加法类
class MyAdd
{
public:
	int operator()(int num1, int num2)
	{
		return num1 + num2;
	}
};

void test02()
{
	MyAdd myadd;      //有名字
	int ret = myadd(100, 100);

	cout << "ret = " << ret << endl;

	//匿名函数对象：当前行执行完后立即被释放
	cout << MyAdd()(100, 100) << endl;  //没名字
}

int main()
{
	test01();    //第一个仿函数是void
	test02();    //第二个仿函数是int   
	             //所以说，仿函数没有固定的写法
	return 0;
}

运行结果如下 ：
在这里插入图片描述

总结

【唐老狮】C#——封装：运算符重载
MrTang_Unity的博客
02-26 353
​​目前我们学过的变量中，除了几种自定义的变量（结构体、类、枚举），语言本身的13种常用变量类型byte、int、float等等都默认支持用运算符进行计算，也支持条件运算符进行比较。今天我们要学习的内容就是如何让自定义的类型能够使用运算符进行运算和比较！ 【运算符重载】 概念 让自定义类和结构体 能够使用运算符 关键字 operator 固定语法 public static返回值operator运算符(参数列表) 特点 一定是一个公共的静态方法 返回值...
《黑马程序员》C++核心编程(二)——4.5运算符重载
sinat_37281674的博客
11-24 302
@toc 4.5 运算符重载 运算符重载概念：对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型 4.5.1 加号运算符重载 作用：实现两个自定义数据类型相加的运算 #include<iostream> #include<string> using namespace std; class Person { public: Person() {}; Person(int a, int b) { this->m_A = a; this->m_B
4.2 对象与类（二）——运算符重载
vinkuan的博客
04-14 153
1 运算符重载
C++类和对象（五）：运算符重载
NewsomTech
02-10 687
文章目录4.5.1 加号运算符重载4.5.2 左移运算符重载4.5.3 递增运算符重载4.5.4 赋值运算符重载4.5.5 关系运算符重载4.5.6 函数调用运算符重载 运算符重载概念：对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型 4.5.1 加号运算符重载 作用：实现两个自定义数据类型相加的运算 class Person { public: Person() {}; Person(int a, int b) { this->m_A = a; this->m
【c++】类和对象--四个默认成员函数+运算符重载
prerfect_cat的博客
06-27 539
累的声明和定义 c++中类的定义一般分为类的声明部分和类的实现部分。类的声明部分用来说明该类中的成员（数据成员，成员函数），告诉使用者“干什么”。类的实现部分用来定义成员函数，该函数用来对数据成员进行操作，告诉使用者“怎么做”。 类定义的形式：class <类名> { public: <成员函数或者数据成员的说明> protected: <成员函数或者数据成员的说
类和对象之运算符重载
可乐不解渴
06-05 622
三、运算符重载 3.1 概念 在 C++语言中，可以用关键字 operator 加上运算符来表示函数，叫做运算符重载。 C++编译器在对运算符进行编译处理时，将一个运算符编译成以下形式： 例如两个复数相加函数： Complex Add(const Complex &a, const Complex &b); 可以用运算符重载来表示： Complex operator +(const Complex &a, const Complex &b); 3.2 运算符重载
C++面向对象：运算符重载——以单目运算符++为例
C++面向对象程序设计中，运算符重载是一项关键特性，它允许程序员为已有的运算符赋予新的含义，以适应特定类的需求。在描述中提到的"重载单目运算符"是指那些只需要一个操作数的运算符，例如单目加法运算符`++`。在...
第7章 运算符重载.
icat的博客
04-27 869
多态性 发出同样的消息被不同类型的对象接收时有可能导致完全不同的行为。 运算符重载  必要性  C++中预定义的运算符的操作对象只能是基本数据类型。 int x , y; y = x + y ; 对于许多用户自定义类型（例如类），也需要类似的运算操作。这时就必须在C++中重新定义这些运算符，赋予已有运算符新的功能，使它能够用于特定类型执行特定的操作 运算符重载的实质 运算符重载：对已有的运...
12.c++面向对象——类与对象，成员函数，继承，构造&析构，友元函数，this指针，类的静态成员
strive for the best 的博客
04-16 276
C++类的定义 定义一个类，本质上是定义一个数据类型的蓝图。 类定义是以关键字 class 开头，后跟类的名称。类的主体是包含在一对花括号中。类定义后必须跟着一个分号或一个声明列表。例如，我们使用关键字 class 定义 Box 数据类型，如下所示： class Box { public: double length; // 盒子的长度 double breadth; // 盒子的宽度 double height; // 盒子的高度 }; 关键字 pub
面向对象程序设计——Java语言1
kxjzv3的博客
11-10 490
《面向对象程序设计——Java语言》这门课程计划用两个月的时间完成。 本课程的主要内容包括：面向对象程序设计基本概念、类设计、对象交互、抽象类与接口、继承与多态、内部类与匿名类、容器与范型、GUI基础知识等。 本课程是《程序设计入门-Java语言》的后续课程，本课程后续还会有《Java应用技术》，那门课会介绍文件操作、多线程编程、GUI编程、网络socket编程、数据库编程等。 预备知识 程序设计基础知识，如变量、运算符、表达式、判断语言、循环语句、数组、函数等。 第1周 类与对象 1.1 用
C++阶段03笔记02【类和对象(封装、对象的初始化和清理、对象模型和this指针、友元、运算符重载、继承、多态)】
upward
07-13 970
C++阶段03笔记02【类和对象(封装、对象的初始化和清理、对象模型和this指针、友元、运算符重载、继承、多态)】
C++——虚函数
weixin_50464560的博客
06-26 1419
虚函数的引入 同一个类中，不能定义两个相同的函数，即名字相同、参数相同的函数。但是在类的继承层次结构中，不同层次的类中可以出现名字相同、参数相同而功能不同的函数。下面通过一个例子来讲解动态多态性是如何实现的，虚函数是如何实现的。 例子： 建立一个基类Person类，派生类Student类，它们都有display这个同名的函数。 #include <iostream> #include <string> using namespace std; class Person { pub
Person类
qq_39822451的博客
03-10 1411
package com.xxxx.modules.common.web; public class Person { private String name; private int age; private int size; public Person(String name, int age, int size) { this.name ...
C++运算符重载遵循规则
阳春白雪的博客
02-24 547
运算符重载需要遵循以下规则： （1）除了类属关系运算符“.”、成员指针运算符“.*”、作用于运算符“::”、sizeof运算符和三目运算符“?:”以外，C++中所有的运算符都可以重载。 （2）重载运算符限制在C++语言中已有的运算符范围内的允许重载的运算符之中，不能创建新的运算符。 （3）运算符重载实质上是函数重载，因此编译程序对运算符重载的选择，遵循函数重载的选择原则。 （4）重载之后的运算符不...
【C++】类和对象（三）运算符重载 (其中有默认成员函数中的 赋值运算符重载、等等)
zhu_pi_xx的博客
08-31 1297
对于大结构体来说，传引用是很提高效率的，并且里面不需要改变，最好加上const，保证安全（保证里面不会写错），另外，因为this指针我们不能显示写，所以C++中为了修饰this指针指向的内容不能改变，就只能加在后面，如下所示......
Java：构造一个Person类，运用方法重载
qq_43220266的博客
11-07 6134
public class Person{ String name; //字符串 名字 int age; //int 年龄 private String secret="..."; //字符串 秘密 int height; // int 体重 //构造方法1 public Person(){} //可以创建一个空的对象，不提供参数 ...
C++继承
裙下的霸气的博客
11-16 405
C++继承
编译器、IDE对C/C++新标准的支持
最新发布
编程语言技巧经验分享
11-08 705
很遗憾的是，微软VC++对C99的支持直到VS2015才基本完全支持，在VS2012之前，仅仅支持C89. 也正是2015年之前，这么多人骂微软并纷纷转移到其它C语言编译器的原因。VS2019开始才正式宣布支持C11/C17.对于C++标准，VS2013开始支持C++11，VS2017支持C++17, VS2019支持C++20, 显然，微软更偏爱C++.
C 学习（4）
search7的博客
11-05 745
C语言学习，每个模块来自工作中的？？？
C++面向对象：运算符重载实践——以类成员函数实现双目运算符
"本教程介绍了如何使用类的成员函数重载双目运算符，特别是在C++面向对象程序设计中的应用。通过运算符重载，可以为自定义类提供与内置类型相似的操作，例如用加法运算符`+`进行复数的相加。" 在C++中，运算符重载...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值