C++运算符重载

已于 2023-05-07 19:35:11 修改
阅读量187 收藏
点赞数 1
分类专栏： c/c++ 文章标签： c++ 开发语言 c语言
于 2023-05-07 16:17:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/HeElLose/article/details/130543612
版权

C++运算符重载

1. 什么是运算符重载

自己理解：当c++执行 2+2 的操作时编译器能够识别运算，当执行类的相加操作时,比如person1+person2，编译器是识别不到的，那我们就应该自己定义运算，能够让编译器去识别。
官方定义：运算符的重载，实际是一种特殊的函数重载，必须定义一个函数，并告诉C++编译器，当遇到该运算符时就调用此函数来行使运算符功能。这个函数叫做运算符重载函数（常为类的成员函数）。用函数的方式实现了（+ - * / []数组 && || 逻辑 等）运算符的重载。

2. 运算符重载的基本格式

返回值类型 类名::operator重载的运算符(参数表)
   {
   ……
   }

operator是关键字，它与重载的运算符一起构成函数名。

3. 两种实现的方式（类内and类外）

3.1 类内实现

#pragma once
#include<iostream>
#include<string>
#include <vector>
#include <algorithm>
#include <ctime>
#include "myArray.h"
using namespace std;

class Person {
public:
	Person() {};
	Person(int a, int b)
	{
		this->m_A = a;
		this->m_B = b;
	}
	//成员函数实现 + 号运算符重载
	Person operator+(const Person& p) {
		Person temp;
		temp.m_A = this->m_A + p.m_A;
		temp.m_B = this->m_B + p.m_B;
		return temp;
	}


public:
	int m_A;
	int m_B;
};
void test() {

	Person p1(10, 15);
	Person p2(20, 20);

	//成员函数方式
	Person p3 = p2 + p1;  //相当于 p2.operaor+(p1)
	cout << "mA:" << p3.m_A << " mB:" << p3.m_B << endl;
}

int main() {

	test();

	system("pause");

	return 0;
}

3.2 类外实现

3.2.1 不加友元

#pragma once
#include<iostream>
#include<string>
#include <vector>
#include <algorithm>
#include <ctime>
#include "myArray.h"
using namespace std;

class Person {
public:
	Person() {};
	Person(int a, int b)
	{
		this->m_A = a;
		this->m_B = b;
	}
public:
	int m_A;
	int m_B;
};
//全局函数实现 + 号运算符重载
Person operator+(const Person& p1, const Person& p2) {
	Person temp(0, 0);
	temp.m_A = p1.m_A + p2.m_A;
	temp.m_B = p1.m_B + p2.m_B;
	return temp;
}
void test() {

	Person p1(10, 15);
	Person p2(20, 20);

	//成员函数方式
	Person p3 = p2 + p1;  //相当于 p2.operaor+(p1)
	cout << "mA:" << p3.m_A << " mB:" << p3.m_B << endl;
}

int main() {

	test();

	system("pause");

	return 0;
}

3.2.2 加友元

#pragma once
#include<iostream>
#include<string>
#include <vector>
#include <algorithm>
#include <ctime>
#include "myArray.h"
using namespace std;

class Person {
	friend Person operator+(const Person& p1, const Person& p2);
	friend void test();
public:
	Person() {};
	Person(int a, int b)
	{
		this->m_A = a;
		this->m_B = b;
	}
private:
	int m_A;
	int m_B;
};
//全局函数实现 + 号运算符重载
Person operator+(const Person& p1, const Person& p2) {
	Person temp(0, 0);
	temp.m_A = p1.m_A + p2.m_A;
	temp.m_B = p1.m_B + p2.m_B;
	return temp;
}
void test() {

	Person p1(10, 15);
	Person p2(20, 20);

	//成员函数方式
	Person p3 = p2 + p1;  //相当于 p2.operaor+(p1)
	cout << "mA:" << p3.m_A << " mB:" << p3.m_B << endl;
}

int main() {

	test();

	system("pause");

	return 0;
}

3.2.3 加友元和不加友元在代码中的区别

加友元

private:
	int m_A;
	int m_B;

不加友元

public:
	int m_A;
	int m_B;

4. 常见运算符重载

4.1 加号运算符重载

class Person {
public:
	Person() {};
	Person(int a, int b)
	{
		this->m_A = a;
		this->m_B = b;
	}
	//成员函数实现 + 号运算符重载
	Person operator+(const Person& p) {
		Person temp;
		temp.m_A = this->m_A + p.m_A;
		temp.m_B = this->m_B + p.m_B;
		return temp;
	}


public:
	int m_A;
	int m_B;
};

//全局函数实现 + 号运算符重载
//Person operator+(const Person& p1, const Person& p2) {
//	Person temp(0, 0);
//	temp.m_A = p1.m_A + p2.m_A;
//	temp.m_B = p1.m_B + p2.m_B;
//	return temp;
//}

//运算符重载 可以发生函数重载 
Person operator+(const Person& p2, int val)  
{
	Person temp;
	temp.m_A = p2.m_A + val;
	temp.m_B = p2.m_B + val;
	return temp;
}

void test() {

	Person p1(10, 10);
	Person p2(20, 20);

	//成员函数方式
	Person p3 = p2 + p1;  //相当于 p2.operaor+(p1)
	cout << "mA:" << p3.m_A << " mB:" << p3.m_B << endl;


	Person p4 = p3 + 10; //相当于 operator+(p3,10)
	cout << "mA:" << p4.m_A << " mB:" << p4.m_B << endl;

}

int main() {

	test();

	system("pause");

	return 0;
}

4.2 赋值运算符重载

class Person
{
public:

	Person(int age)
	{
		//将年龄数据开辟到堆区
		m_Age = new int(age);
	}

	//重载赋值运算符 
	Person& operator=(Person &p)
	{
		if (m_Age != NULL)
		{
			delete m_Age;
			m_Age = NULL;
		}
		//编译器提供的代码是浅拷贝
		//m_Age = p.m_Age;

		//提供深拷贝 解决浅拷贝的问题
		m_Age = new int(*p.m_Age);

		//返回自身
		return *this;
	}


	~Person()
	{
		if (m_Age != NULL)
		{
			delete m_Age;
			m_Age = NULL;
		}
	}

	//年龄的指针
	int *m_Age;

};


void test01()
{
	Person p1(18);

	Person p2(20);

	Person p3(30);

	p3 = p2 = p1; //赋值操作

    cout << "p1的年龄的地址为：" << p1.m_Age << endl;
    
	cout << "p1的年龄为：" << *p1.m_Age << endl;

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

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

int main() {

	test01();

	//int a = 10;
	//int b = 20;
	//int c = 30;

	//c = b = a;
	//cout << "a = " << a << endl;
	//cout << "b = " << b << endl;
	//cout << "c = " << c << endl;

	system("pause");

	return 0;
}

4.3 关系运算符重载

class Person
{
public:
	Person(string name, int age)
	{
		this->m_Name = name;
		this->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()
{
	//int a = 0;
	//int b = 0;

	Person a("孙悟空", 18);
	Person b("孙悟空", 18);

	if (a == b)
	{
		cout << "a和b相等" << endl;
	}
	else
	{
		cout << "a和b不相等" << endl;
	}

	if (a != b)
	{
		cout << "a和b不相等" << endl;
	}
	else
	{
		cout << "a和b相等" << endl;
	}
}


int main() {

	test01();

	system("pause");

	return 0;
}

4.4 [ ]数组重载

下标操作符 [] 通常用于访问数组元素。重载该运算符用于增强操作 C++ 数组的功能。下面的实例演示了如何重载下标运算符 []。

#include <iostream>
using namespace std;
const int SIZE = 10;
 
class safearay
{
   private:
      int arr[SIZE];
   public:
      safearay() 
      {
         register int i;
         for(i = 0; i < SIZE; i++)
         {
           arr[i] = i;
         }
      }
      int& operator[](int i)
      {
          if( i >= SIZE )
          {
              cout << "索引超过最大值" <<endl; 
              // 返回第一个元素
              return arr[0];
          }
          return arr[i];
      }
};
int main()
{
   safearay A;
 
   cout << "A[2] 的值为 : " << A[2] <<endl;
   cout << "A[5] 的值为 : " << A[5]<<endl;
   cout << "A[12] 的值为 : " << A[12]<<endl;
 
   return 0;
}

$ g++ -o test test.cpp
$ ./test 
A[2] 的值为 : 2
A[5] 的值为 : 5
A[12] 的值为 : 索引超过最大值
0

5. STL- 函数对象(使用重载的())

  • 重载函数调用操作符的类，其对象常称为函数对象
  • 函数对象使用重载的()时，行为类似函数调用，也叫仿函数
  • 函数对象(仿函数)是一个类，不是一个函数

5.1 函数对象的特点

特点：

  • 函数对象在使用时，可以像普通函数那样调用, 可以有参数，可以有返回值
  • 函数对象超出普通函数的概念，函数对象可以有自己的状态
  • 函数对象可以作为参数传递
#include <string>

//1、函数对象在使用时，可以像普通函数那样调用, 可以有参数，可以有返回值
class MyAdd
{
public :
	int operator()(int v1,int v2)
	{
		return v1 + v2;
	}
};

void test01()
{
	MyAdd myAdd;
	cout << myAdd(10, 10) << endl;
}

//2、函数对象可以有自己的状态
class MyPrint
{
public:
	MyPrint()
	{
		count = 0;
	}
	void operator()(string test)
	{
		cout << test << endl;
		count++; //统计使用次数
	}

	int count; //内部自己的状态
};
void test02()
{
	MyPrint myPrint;
	myPrint("hello world");
	myPrint("hello world");
	myPrint("hello world");
	cout << "myPrint调用次数为： " << myPrint.count << endl;
}

//3、函数对象可以作为参数传递
void doPrint(MyPrint &mp , string test)
{
	mp(test);
}

void test03()
{
	MyPrint myPrint;
	doPrint(myPrint, "Hello C++");
}

int main() {

	//test01();
	//test02();
	test03();

	system("pause");

	return 0;
}

5.2 谓词

概念：

  • 返回bool类型的仿函数称为谓词
  • 如果operator()接受一个参数，那么叫做一元谓词
  • 如果operator()接受两个参数，那么叫做二元谓词

5.2.1 一元谓词

#include <vector>
#include <algorithm>

//1.一元谓词
struct GreaterFive{
	bool operator()(int val) {
		return val > 5;
	}
};

void test01() {

	vector<int> v;
	for (int i = 0; i < 10; i++)
	{
		v.push_back(i);
	}

	vector<int>::iterator it = find_if(v.begin(), v.end(), GreaterFive());
	if (it == v.end()) {
		cout << "没找到!" << endl;
	}
	else {
		cout << "找到:" << *it << endl;
	}

}

int main() {

	test01();

	system("pause");

	return 0;
}

5.2.2 二元谓词

#include <vector>
#include <algorithm>
//二元谓词
class MyCompare
{
public:
	bool operator()(int num1, int num2)
	{
		return num1 > num2;
	}
};

void test01()
{
	vector<int> v;
	v.push_back(10);
	v.push_back(40);
	v.push_back(20);
	v.push_back(30);
	v.push_back(50);

	//默认从小到大
	sort(v.begin(), v.end());
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
	cout << "----------------------------" << endl;

	//使用函数对象改变算法策略，排序从大到小
	sort(v.begin(), v.end(), MyCompare());
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
}
@大宁字
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C++ 操作符重载
Chroniccandy的博客
10-03 1652
输出操作符"<<" 和输入操作运算符">>" 在C++中，左移运算符<<可以和cout一起输出,因此也常被称为"流插入运算符",或"输出运算符"。 但实际上！<<本来没有这样的功能,之所以能和cout一起使用来输出数据，是因为此<<操作符被重载了 输出操作符"<<" cout是ostream类的对象,ostream类和cout都是在头文件 <iostream> 中声明的,ostream类将<<重载为其成员函数,
C++ 自加运算符重载
weixin_42333471的博客
05-14 613
顺便学习使用“<<”与“>>”的重载 #include<iostream> using namespace std; class C { //重载“<<”与“>>”,作为全局函数，作为类的友元，访问类的私有成员变量 friend ostream & operator <<(ostream&out, C&a...
c++ 重载运算符和重载函数
weixin_30377461的博客
08-16 123
重载运算符和重载函数 C++ 允许在同一作用域中的某个函数和运算符指定多个定义，分别称为函数重载和运算符重载。 ———— 类似于 python 的魔法方法 重载声明是指一个与之前已经在该作用域内声明过的函数或方法具有相同名称的声明，但是它们的参数列表和定义（实现）不相同。 当您调用一个重载函数或重载运算符时，编译器通过把您所使用的参数类型与定义中的参数类型进行比较，...
C++之引用&重载
逍遥硖的博客
10-15 4362
c++的引用和函数重载笔记以及代码示例
C++学习笔记：(四)运算符重载 & 类型转换
Tyler_Zx的博客
08-08 9816
目录 6.运算符重载 6.1运算符重载的基本概念 6.2成员函数重载运算符 6.3友元函数重载运算符 6.4成员函数重载运算符和友元函数重载运算符比较 6.5类型转换 6.运算符重载 面向对象程序设计的重载有函数重载和运算符重载。函数重载是指在相同作用域内，若干个参数特征不同的函数使用相同的函数名，也称为函数名重载；运算符重载是另一种调用函数的方法，是指同样的运算符可以施加于不同类...
C++运算符重载规则详解
09-03
C++运算符重载是语言特性之一，允许程序员为已存在的运算符赋予新的含义，以适应自定义数据类型的运算需求。然而，运算符重载并不是无限制的，它遵循一些特定的规则，以确保代码的清晰性和正确性。 首先，C++中大...
C++运算符重载课件
09-17
中国农业大学C++课程课件，信息与电气工程学院学生专用。
c++运算符重载基础知识详解
09-04
C++运算符重载是编程中一个重要的概念，它允许我们为已有的运算符赋予新的含义，使得在处理自定义数据类型时，代码更加直观和简洁。在C++中，运算符重载并不是创建新的运算符，而是为已有的运算符提供不同的实现方式...
c++运算符重载
10-10
C++ 运算符重载教学指导 C++ 运算符重载是面向对象程序设计中的一种重要技术，它允许开发者重新定义编程语言中的运算符，以便更好地描述问题域中的对象行为。在本实验指导书中，我们将通过三个实验，分别介绍 ...
C++运算符重载三种形式1
08-08
C++运算符重载是C++中一个强大的特性，它允许程序员为自定义类型定义运算符的行为。在C++中，运算符重载有三种主要形式：成员函数、友元函数以及普通函数。每种形式都有其特定的使用场景和优缺点。 1. 成员函数重载...
C++运算符重载的思维导图
最新发布
03-26
运算符重载 、运算符重载规则 1.重载运算符的限制 2.运算符重载的语法形 式 、用成员或友元函数重载运算符 1.一元运算符2.二元运算符 3.用成员函数重载运算符 4.用友元函数重载 条件 ②例子 ③注意 5.讨论 6.总结 三...
C++运算符重载的方法详细解析
09-04
在C++中，运算符重载是一种特性，允许程序员为已有的运算符赋予新的含义，以便在自定义数据类型上使用。运算符重载不是创建新的运算符，而是为现有运算符提供不同的实现方式，使其能适配自定义类型的运算需求。通过...
c++运算符重载，重载运算符
01-04
### C++运算符重载详解 #### 一、前言 C++允许用户自定义类或结构体，并为这些类型重载内置运算符，从而使得这些类型能够像内置类型一样使用标准运算符进行操作。本篇文章将通过三个具体的示例来深入探讨C++中的...
C++运算符重载友元函数实例
08-17
在给定的实例中，你将学习如何实际应用这些概念，通过成员函数和非成员函数重载C++运算符，以及如何使用友元函数来实现特定的运算行为。通过练习和理解这些例子，你将更好地掌握C++中运算符重载和友元函数的使用。
关于C++重载时候用&
Tyeat的博客
04-16 785
c++中有些重载运算符为什么要返回引用，单单为了避免析构再构造吗？ 不是。「有些」重载运算符要返回的引用，是为了返回它本身。如class TestClass { private: int number; public: TestClass& operator+=(const TestClass& rhs) { number += rhs.number; return *th...
C++运算符重载详解
qq_52905520的博客
10-06 3万+
C++运算符重载详解
C++重载运算符以及operator=的重载
paulfrank_zhang的博客
10-11 1万+
重载运算符 问题引入 int a=10 int b=20 int c=a+b 对于内置数据类型编译器知道如何运算（+） 然后对于自定义类型 People p1+People p2 编译器是处理不了的，因为People类内部没有定义 操作符 +， 在People类内定义成员函数 #include <iostream> #include<string>...
C++的运算符重载
热门推荐
jacket_的博客
04-30 6万+
1.作为新手学习C++的运算符重载，首先应该了解C++的运算符重载有何现实意义？ 之前已对多态性有了相关总结，得出结论：函数重载体现出多态性。实际上，运算符重载也体现出了多态性。在C++中我们定 义的int、float、double等基本数据类型的变量后，就可以直接用“ + ”、“ -”、“ *”、“ / ”等运算符进行相关的计算，然后把得到的 计算 结果通过" ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

@大宁字

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值