C++ 运算符重载

最新推荐文章于 2022-10-22 13:58:14 发布
最新推荐文章于 2022-10-22 13:58:14 发布
阅读量165 收藏
点赞数
分类专栏： C++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/smartboy_01/article/details/119087895
版权

运算符重载


对于内置的数据类型，编译器知道如何进行运算，但是对于自定义数据类型，编译器不知道如何运算，利用运算符重载 可以让符号有新的含义。
定义重载的运算符就像定义函数，只是函数的名字为 operator@，其中 @代表被重载的运算符。

运算符是一元还是二元取决于运算符函数中参数的个数。

  1. 全局函数（一个参数是一元，两个参数是二元）
  2. 成员函数（一元没有参数、二元一个参数，此时该类的对象用作左值）

不要滥用运算符重载，除非有需求，不能对内置数据类型进行重载 。

加号运算符重载

利用加号重载 ，实现Person数据类型相加操作 p1 + p2


class Person
{
public:
	Person() {};
	//使用属性列表进行赋值
	Person(int a, int b) :m_A(a), m_B(b)
	{};

	//利用成员函数实现加号运算符重载
	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;
};

//利用全局函数实现加号运算符重载
Person operator+(Person& p1, Person& p2)
{
	Person temp;
	temp.m_A = p1.m_A + p2.m_A;
	temp.m_B = p1.m_B + 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 test()
{
	Person p1(10, 10);
	Person p2(20, 20);

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

	Person p3 = p1.operator+(p2); //成员函数本质

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


	//运算符重载  可不可以发生 函数重载？  可以

	p1 + 10;
}
  • 利用成员函数 和 全局函数 都可以实现重载
  • 关键字 operator +
  • 成员函数本质 p1.operator+(p2)
  • 全局函数本质 operator+(p1,p2)
  • 简化为 p1 + p2（使用简化版时成员函数、全局函数只能使用一个）
  • 运算符重载 也可以发生函数重载

左移运算符重载


class Person
{
	friend ostream& operator<<(ostream& cout, Person& p1);

public:

	Person(int a, int b)
	{
		this->m_A = a;
		this->m_B = b;
	}

private:
	int m_A;
	int m_B;
};

//利用全局函数 实现左移运算符重载
ostream& operator<<(ostream& out, Person& p1)
{
	cout << "m_A = " << p1.m_A << " m_B = " << p1.m_B;
	return cout;
}


void test()
{
	Person p1(10, 10);

	cout << p1 << endl;
	
}
  1. 对于自定义数据类型，不可以直接用 cout << 输出，需要重载 左移运算符
  2. 如果利用成员 函数重载 ，无法实现让cout 在左侧，因此不用成员重载
//试图利用成员函数 做<<重载
void operator<<( Person & p)   
{

}
//调用，只能简化为p<<cout，不满足需求
 p.operator<<(cout)
  1. 利用全局函数，实现左移运算符重载ostream& operator<<(ostream &cout, Person & p1)
//利用全局函数 实现左移运算符重载
//形参out是实参cout的别名，所以函数体中也可以直接使用实参名
ostream& operator<<(ostream& out, Person& p1)
{
	cout << "m_A = " << p1.m_A << " m_B = " << p1.m_B;
	//返回原始对象，方便链式编程
	return cout;
}
  1. 如果想访问类中私有内存，可以将全局函数配置友元实现

递增运算符重载

  • 前置递增MyInter& operator++()
  • 后置递增MyInter operator++(int)
  • 前置++ 效率高于 后置++ 效率 ，因为后置++会调用拷贝构造，创建新的数据(一个临时对象)
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

class MyInter
{
	friend ostream& operator<<(ostream& cout, MyInter& myInt);
public:
	MyInter()
	{
		m_Num = 0;
	}

	//前置++ 重载，返回计算后的对象本身
	MyInter& operator++()
	{
		this->m_Num++;
		return *this;
	}

	//后置++ 重载，返回初始状态，再++
	MyInter operator++(int)
	{
		//先记录初始状态
		MyInter temp = *this;

		this->m_Num++;

		return temp;
	}

private:
	int m_Num;
};

//自定义数据类型重载<<，允许输出
ostream& operator<<(ostream& cout, MyInter& myInt)
{
	cout << myInt.m_Num;
	return cout;
}

void test01()
{
	MyInter myInt;
	cout << ++(++myInt) << endl;
	cout << myInt << endl;
}

void test02()
{
	MyInter myInt;
	MyInter ret = myInt++;	
	cout << ret << endl;
	cout << myInt << endl;
}

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


	//int a = 0;
	//cout << ++(++a) << endl;
	//cout << a << endl;

	//int b = 0;
	//cout << (b++)++ << endl; //后置++返回的是值，不允许再进行后置++操作

	system("pause");
	return EXIT_SUCCESS;
}

指针运算符重载

  • 智能指针,用途： 托管new出来的对象的释放
  • 设计smartPoint智能指针类，内部维护Person *，在析构时候释放堆区new出来的person对象
  • 重载-> *让 sp智能指针用起来向真正的指针

class Person
{
public:
	Person(int age)
	{
		cout << "Person的有参构造调用" << endl;
		this->m_Age = age;
	}

	void showAge()
	{
		cout << "年龄为： " << this->m_Age << endl;
	}

	~Person()
	{
		cout << "Person的析构调用" << endl;
	}

	int m_Age;
};

class SmartPoint
{
public:
	SmartPoint(Person* person)
	{
		this->m_person = person;
	}

	//重载->运算符
	Person* operator->()
	{
		return this->m_person;
	}
	//重载 * 运算符，返回的是Person的引用，因为返回原始对象就可以，不需要通过赋值创建新的对象
	Person& operator*()
	{
		return *m_person;
	}
	~SmartPoint()
	{
		if (this->m_person)
		{
			delete this->m_person;
			this->m_person = NULL;
		}
	}
private:
	//维护一个Person类型的指针
	Person* m_person;
};

void test()
{
	//Person * p = new Person(18);	
	//delete p;


	//利用智能指针 管理 new出来的person的释放操作,方法中的对象都创建在栈中，方法执行完后会调用对应的析构函数进行释放，起到自动管理指针的作用
	SmartPoint sp(new Person(18));


	//p->showAge();
	//sp->返回的是(Person * )->showAge();
	sp->showAge(); // 本质sp->->showAge(); 编译器简化为 sp->showAge();

	//(*p).showAge();
	//(*sp)解引用后返回的应该为Person类型的对象，对象再调用成员方法
	(*sp).showAge();

}

总结

  • 使用new创建的对象，创建在堆区，用完需要手动释放，否则只会在程序关闭后自动释放
  • 自定义智能指针时，可以类比真实的指针，对比两者间所支持的操作

虽然可以创建SmartPerson进行管理指针，但是每创建一个新类型都需要创建对应的智能指针太繁琐，还是建议自己维护指针（new / delete）

赋值运算符重载

编译器会默认个一个类添加4个函数：默认构造(空实现)、析构（空实现） 、 拷贝构造（值拷贝） 、 operator=（值拷贝）；如果类中有属性创建在堆区，利用编译器提供的 =赋值运算就会出现堆区内存重复释放的问题
解决方案：利用深拷贝重载 =运算符，函数声明如下Person& operator=( const Person &p),并自定义拷贝构造。


//编译器 默认给一个类4个函数   默认构造   析构   拷贝构造 （值拷贝）  operator= (值拷贝)
class Person
{
public:
	Person(char * name, int age)
	{
		this->m_Name = new char[strlen(name) + 1];
		strcpy(this->m_Name, name);
		this->m_Age = age;
	}

	//重载 =,使用深拷贝
	Person& operator=( const Person &p)
	{
		//先判断原来堆区释放有内容，如果有先释放
		if (this->m_Name != NULL)
		{
			delete [] this->m_Name;
			this->m_Name = NULL;
		}

		this->m_Name = new char[strlen(p.m_Name) + 1];
		strcpy(this->m_Name, p.m_Name);
		this->m_Age = p.m_Age;
		//返回当前对象的引用，用来链式操作
		return *this;
	}

	//拷贝构造，使用深拷贝
	Person(const Person & p)
	{
		this->m_Name = new char[strlen(p.m_Name) + 1];
		strcpy(this->m_Name, p.m_Name);
		this->m_Age = p.m_Age;
	}

	//析构，释放堆区创建的内容
	~Person()
	{
		if (this->m_Name!=NULL)
		{
			delete [] this->m_Name;
			this->m_Name = NULL;
		}
	}

	char * m_Name;
	int m_Age;
};


void test()
{
	Person p1("Tom",10);
	
	Person p2("Jerry",19);
	p2 = p1;

	Person p3("", 0);
	p3 = p2 = p1;


	//使用拷贝构造进行复制
	Person p4 = p3;

	cout << "p1姓名： "<< p1.m_Name << "  p1年龄： " << p1.m_Age << endl;
	cout << "p2姓名： "<< p2.m_Name << "  p2年龄： " << p2.m_Age << endl;
	cout << "p3姓名： " << p3.m_Name << " p3年龄： " << p3.m_Age << endl;

}

int main(){

	test();

	//类比原始类型的操作，进行自定义=的重载操作
	/*int a = 10;
	int b = 20;
	int c;
	c = a = b;
	cout << "a = " << a << " b = " << b << " c = " << c << endl;*/


	system("pause");
	return EXIT_SUCCESS;
}

[]运算符重载

实现自定义数组类型[]取值及作为左值操作

  • 函数声明int& operator[](int index);
  • 实现访问数组时候利用[] 访问元素，函数实现如下
//返回& 引用类型是为了作为左值，允许对其进行赋值操作如：a[100] = 10000;因为只有引用类型可以作为左值，普通原始类型不允许作为左值
int& MyArray::operator[](int index)
{
	return this->pAddress[index];
}

函数调用运算符（）重载

  • 使用时候很像函数调用，因此称为仿函数，如下声明
void operator()(string text)
int operator()(int a,int b)
  • 仿函数写法不固定，比较灵活
  • 匿名函数对象的使用 cout << MyAdd()(1, 1) << endl; // 匿名函数对象 特点：当前行执行完立即释放
#include <string>

class MyPrint
{
public:
	void operator()(string text)
	{
		cout << text << endl;
	}
};


void MyPrint2(string str)
{
	cout << str << endl;
}

void test01()
{
	MyPrint myPrint;
	myPrint("hello world"); // 仿函数本质是一个对象,使用时像函数，所以又可以称为函数对象

	MyPrint2("hello world"); //普通函数调用
}



class MyAdd
{
public:
	int operator()(int a,int b)
	{
		return a + b;
	}
};

void test02()
{
	MyAdd myAdd;
	cout << myAdd(1, 1) << endl;
	cout << MyAdd()(1, 1) << endl; // 匿名函数对象，特点：当前行执行完立即释放
}

总结

  • 不要重载 &&和 ||，原因是无法实现短路特性
  • 建议：将<< 和 >>写成全局函数，其他可重载的符号写到成员即可。
DevCsdner
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++(三十九)之左移运算符重载
shao15232的博客
03-10 312
我们在C++中使用输出的时候， 格式一般为： cout << xxx << endl; 那么我们的<<运算符就会出现两个操作数， cout是第一个操作数， xxx是第二个操作数。 所以假设我们把<<重载符号写入在类内部， 那么第一个操作数就会变成对象 instance.cout << xxx... 会变成这样的格...
c++学习心得第二期 友元+运算符重载
qq_37448336的博客
10-04 196
c++学习心得第二期 友元+运算符重载一、友元1 、全局函数做友元2. 类做友元3. 成员函数做友元二、运算符重载1.加号运算符重载2.左移运算符重载3.递增运算符重载4.赋值运算符重载5. 关系运算符重载6. 函数调用运算符重载 在程序里，有些私有属性 也想让类外特殊的一些函数或者类进行访问，就需要用到友元的技术 友元的目的就是让一个函数或者类 访问另一个类中私有成员 友元的关键字为 friend 友元的三种实现 全局函数做友元 类做友元 成员函数做友元 一、友元 1 、全局函数做友元 #incl
C语言中能运算符重载吗,C++语言中什么运算符不能重载
weixin_29147045的博客
05-22 1879
2016-09-01 回答c语言没有重载的概念，重载是c++的内容c++运算符：算术运算符：+,-,*,/,%,++,--;位操作运算符：&,|,~,^(位异或),＜＜(左移),＞＞(右移)逻辑运算符：!,&&,||;比较运算符：＜,＞,＞=,＜=,==,!=;赋值运算符：=,+=,-=,*=,/=,%=,&=,|=,^=,＜＜=,＞＞=;其他运算符：[],(),-...
C++运算符重载详解
qq_52905520的博客
10-06 3万+
C++运算符重载详解
C++运算符重载
最新发布
m0_58495729的博客
10-22 803
C++学习路径之运算符重载
c++运算符重载
weixin_43821215的博客
03-21 2126
文章目录前言一、重载二元运算符1. 作为成员函数的二元重载运算符2.作为非成员函数的二元重载运算符二、重载一元运算符1.作为成员函数的一元重载运算符2.作为非成员函数的一元重载运算符3、重载一元前置与后置运算符：++和- -1. 重载前置的自增运算符2. 重载后置的自增运算符三、运算符作为成员函数和非成员函数的比较 前言 提示：这里可以添加本文要记录的大概内容： 运算符重载不是自动的，必须定义运算符重载函数来描述所需要的功能。通过像往常那样编写非static成员函数定义或者非成员函数定义就可以实现运算符重
c++ 运算符重载
物联黄同学的博客
09-26 3069
前言 本篇内容参考了b站up主黑马程序员的视频，这是链接https://www.bilibili.com/video/BV1et411b73Z?p=126 什么是运算符重载？ 运算符重载类似于函数重载，回顾函数重载，我们会发现，发生函数重载使得同名函数具有不同的应用，运算符重载也是如此，针对不同的对象，运算符重载可以有不同的应用。但是，我们在做运算符重载时并不是扩大一个运算符的功能，而是扩大它应用的范围。 运算符重载的应用场景 运算符重载常用于对类或者结构体的运算符操作，例如，一个类有几个int属性，然
C++运算符重载规则详解
09-03
C++运算符重载是语言特性之一，允许程序员为已存在的运算符赋予新的含义，以适应自定义数据类型的运算需求。然而，运算符重载并不是无限制的，它遵循一些特定的规则，以确保代码的清晰性和正确性。 首先，C++中大...
C++运算符重载课件
09-17
中国农业大学C++课程课件，信息与电气工程学院学生专用。
c++运算符重载基础知识详解
09-04
C++运算符重载是编程中一个重要的概念，它允许我们为已有的运算符赋予新的含义，使得在处理自定义数据类型时，代码更加直观和简洁。在C++中，运算符重载并不是创建新的运算符，而是为已有的运算符提供不同的实现方式...
DEVC++(1)单文件实现重载运算符的十六进制数类
zhazhazl的博客
10-04 1406
本文运用DEVC++软件，通过C++类的定义和重载运算符来实现十六进制数类的运算操作，代码以单文件的方式来构建。题目描述如下： 设计1~4位的无符号十六进制数据类class HEX. 可以创建如 ABCD、1234、DF09、AB、26之类的1~4位的十六进制的正整数。可以输入输出十六进制数据，可以实现十六进制数据和十进制数据的互换，可以实现2个十六进制数据的+、-、*、/、%操作。为实现上述目
C++运算符重载(超全）
热门推荐
LancasterLiu的博客
06-27 3万+
C++运算符重载 1) 运算符重载的本质为函数重载，但有一定的规则需要遵循。[1] (1)重载运算符时,运算符的运算顺序和优先级不变,操作数个数不变。 (2)不能创造新的运算符,只能重载C++中已有的运算符,并且规定有6个运算符不能重载,如表所示。 不能重载的运算符 含义 . 类属关系运算符 .* 成员指针运算符 :: 作用域运算符 ?: 条件运算符 # 编译预处理符号 sizeof() 取数据类型的长度 (3)运算符重载是针对新类型的实际需求,对原有的运算符进行适当
C++运算符重载三种形式1
08-08
C++运算符重载是C++中一个强大的特性，它允许程序员为自定义类型定义运算符的行为。在C++中，运算符重载有三种主要形式：成员函数、友元函数以及普通函数。每种形式都有其特定的使用场景和优缺点。 1. 成员函数重载...
C++运算符重载：流插入与流提取
该资源是一份关于C++运算符重载的课件，重点讨论了如何重载流插入运算符`和流提取运算符`>>`，以及多态性和运算符重载的基本概念、规则和应用。 在C++编程中，流插入运算符`和流提取运算符`>>`主要用于输入/输出...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值