C++编程——运算符重载

最新推荐文章于 2023-04-29 16:26:32 发布
最新推荐文章于 2023-04-29 16:26:32 发布
阅读量1.2k 收藏 1
点赞数
分类专栏： C++编程 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/professor_tao/article/details/124325466
版权

文章目录


运算符重载知识结构：
在这里插入图片描述

运算符重载的概念：对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型

1. 加号运算符重载

作用:实现两个自定义数据类型相加的运算

1.1 通过成员函数重载

class Person
{
public:
	//成员函数重载+号
	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;
	cout << "p3.m_A:" << p3.m_A << endl;
	cout << "p3.m_B:" << p3.m_B << endl;
}


int main()	
{
	test01();
	system("pause");
	return 0;
}

1.2 通过全局函数重载

class Person
{
public:	
	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;
}

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;
	cout << "p3.m_A:" << p3.m_A << endl;
	cout << "p3.m_B:" << p3.m_B << endl;
}


int main()	
{
	test01();
	system("pause");
	return 0;
}

注：运算符重载也可以发生函数重载

class Person
{
public:	
	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 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;
	cout << "p3.m_A:" << p3.m_A << endl;
	cout << "p3.m_B:" << p3.m_B << endl;

	Person p4 = p1 + 100;
	cout << "p4.m_A:" << p4.m_A << endl;
	cout << "p4.m_B:" << p4.m_B << endl;
}


int main()	
{
	test01();
	system("pause");
	return 0;
}

2. 左移运算符重载

2.1 通过成员函数重载

不会利用成员函数重载<<运算符，因为无法实现cout 在左侧

class Person
{
	//利用成员函数重载 左移运算符 p.operator<<(cout)简化为 p << cout
	//不会利用成员函数重载<<运算符，因为无法实现cout 在左侧
	//void operator<<(cout)
	//{

	//}

public:	
	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;

	cout << p1; //想要重载<<，使得这行代码能正常调用
}

2.2 通过全局函数重载

class Person
{
	friend ostream& operator<<(ostream &cout, Person &p); //利用友元，让全局函数访问Person的私有属性
public:
	Person(int a, int b)
	{
		m_A = a;
		m_B = b;
	}
private:	
	int m_A;
	int m_B;
 
};

//通过全局函数重载 
ostream& operator<<(ostream &cout, Person &p) //本质为operator <<(cout,p)简化为cout << p
{
	cout << "m_A = " << p.m_A << "m_B = " << p.m_B;
	return cout;
}

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

	//Person p2;
	//p2.m_A = 10;
	//p2.m_B = 10;

	cout << p1 << endl; //想要重载<<，使得这行代码能正常调用


}


int main()	
{
	test01();
	system("pause");
	return 0;
}

注：链式编程思想，全局函数重载的返回值为ostream&

3. 递增运算符重载

3.1 前置递增

注意：前置递增需要返回引用，为的是一直对一个数据进行递增

//自定义整型
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();
	system("pause");
	return 0;
}

3.2 后置递增

注意：后置递增需要返回值，因为不可以返回局部变量的引用

//自定义整型
class MyInteger
{
	friend ostream& operator<<(ostream& cout, MyInteger myint);
public:
	MyInteger()
	{
		m_Num = 0;
	}

	//重载前置++运算符  返回引用是为了一直对一个数据进行递增
	MyInteger& operator++()
	{
		m_Num++;
		return *this;
	}

	//重载后置++运算符
	//void operator++(int)   int代表占位参数，可用于区分前置与后置递增
	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;
}

int main()	
{
	test01();
	system("pause");
	return 0;
}

注：以为返回的不是引用，所以链式编程的思想没有体现。后置递增的代码是存在缺陷的，如假设myint.m_Num=0,根据C语言的语法，(myint++)++的值还是0，而myint输出的结果应该是2。但是因为不是引用传递，所以上述代码myint输出的结果是1。

4. 赋值运算符重载

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

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

默认赋值运算带来的问题：会导致内存的重复释放


class Person
{
public: 
	Person(int age)
	{
		m_Age = new int(age);
	}

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

	int *m_Age;
};

void test01()
{
	Person p1(18);
	Person p2(20);

	p2 = p1;

}

int main()	
{
	test01();
	system("pause");
	return 0;
}

对于test01函数假设p1先执行析构函数，则堆区的数据已经被释放了。那么当p2执行析构代码时，需要将堆区的数据再释放一次，就造成了堆区数据重复释放的问题。

赋值运算符重载代码：

class Person
{
public: 
	Person(int age)
	{
		m_Age = new int(age);
	}

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

	//重载赋值运算符
	Person& operator=(Person &p)
	{
		//应该先判断是否有属性在堆区，如果有先释放干净，然后再深拷贝
		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);

	p3 = p2 = p1;

}

int main()	
{
	test01();
	system("pause");
	return 0;
}

重载函数返回引用，能实现链式编程的思想。

5. 关系运算符重载

以==运算符的重载为例：


class Person
{
public: 
	Person(string name,int age)
	{
		m_Name = name;
		m_Age = age;
	}
	
	//重载==运算符
	bool operator==(Person &p)
	{
		if (m_Age == p.m_Age&& m_Name == p.m_Name)
		{
			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;
	}

}

int main()	
{
	test01();
	system("pause");
	return 0;
}

6. 函数调用运算符重载

  • 函数调用运算符()也可以重载
  • 由于重载后使用的方式非常像函数的调用，因此称为仿函数
  • 仿函数没有固定的写法，非常灵活
class MyPrint
{
public:
	 //重载函数调用运算符
	void operator()(string text)
	{
		cout << text << endl;
	}
};

void MyPrint02(string text)
{
	cout << text << endl;
}

void test01()
{
	MyPrint myprint;
	myprint("Hello World"); //仿函数调用
	MyPrint02("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;
}

int main()	
{
	test01();
	system("pause");
	return 0;
}
Stephen_Tao
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
c++编程学习：多态性&重载
qq_22613757的博客
12-05 639
多态性与重载 多态性是面向对象程序设计的重要特性之一。多态是会一个名字有很多种语义，或一个相同界面有很多多种实现；或是指发出同样的消息被不同类型的对象接收而导致完全不同的行为，即对象根据所接收到的消息做出相应的操作。 消息主要是指对象成员函数的调用，不同的行为指不同的实现。 多态的实现： 函数重载 运算符重载 虚函数 函数重载 多态性的一种形式，它是指允许在相同的作用域内，相同的...
C#重载详解
naer_chongya的博客
05-01 4531
到此为止，我们已经介绍了C#中重载方法的相关概念和实现方式，包括定义重载方法的规则和使用泛型约束的例子。通过重载方法，我们可以提高程序的可读性和复用性，使得程序更加灵活和通用。
C++语法——详解运算符重载
weixin_61857742的博客
07-28 3万+
运算符重载是C++的一个重要特性。有了运算符重载，在代码编写时能更好的实现封装。 一.运算符重载介绍 运算符重载，就是让原本已经存在的运算符有了新的用法和意义。 比如我们熟知的减号（-），原本是用来进行数字的相减处理。但经过运算符重载后，它可以用来进行其他类型的相减，像时间相减、日期相减、字符相减等等。只要是你能想到的，通过运算符重载基本都能够实现。 对于C++而言，运算符重载一般是作为类的成员函数出现。因为当我们需要运算符重载时，往往是类中一种特殊的类型需要处理或者类本身需要处理。就像我们可能会把.
C++运算符重载
Mi-ronin的博客
09-26 1126
对于基本类型的常量或变量进行运算时，我们可以使用 +、-、*、/ 等运算符，但是我们不可以使用运算符来进行对象之间的运算。 为了可以使得对象进行运算操作我们引入运算符重载这个概念。 利用 C++ 提供的“运算符重载”机制，赋予运算符新的功能，就能解决用+将两个复数对象相加这样的问题。
c++学习之运算符重载详解
qq_61422622的博客
04-29 5639
重载++和--运算符时，有点让人不知所措，因为我们总希望能根据他们出现在对象的前面还是后面而来调用不同的重载函数，例如当看见++a，会调用前置加加重载函数，看见a++，会调用后置加加的重载函数。++无论前置还是后置，我们发现他的函数重载时设计的参数将会是一样，但这样就无法确定该调用哪一个，考虑到要让参数不一样而来调用对象的前置函数还是后置函数，于是多利用了一个占位参数。这里我们定义了全局函数的+，重载了+运算符，但程序在对运算符调用时，还是会根据参数类型，调用重载后的运算符，还是调用默认的运算符。
C++运算符重载详解
qq_52905520的博客
10-06 3万+
C++运算符重载详解
C++程序设计 运算符重载实验（一）
04-03
C++程序设计实验——运算符重载，涉及单目、双目运算符的重载
C++编程思想——计算机科学丛书
07-03
本书作者根据自己学习C++的亲身体会及多年教学经验，用简单的例子和简练的叙述讲解C++编程，别具特色。全书共分十八章，内容涉及对象的演化、数据抽象、隐藏实现、初始化与清除、函数重载与缺省参数、输入输出流介绍...
C++编程思想——很实用的一本书
04-08
本书作者根据自己学习C++的亲身体会及多年教学经验，用简单的例子和简练的叙述讲解C++编程，别具特色。 全书共分十八章，内容涉及对象的演化、数据抽象、隐藏实现、初始化与清除、函数重载与缺省参数、输入输出流...
C++基础OI小教程 免费
01-12
—————————————————————————— 里面包含这些大块： 1.基础语法 1.1 Hello wold 1.2 好习惯 1.3 输入、运算符 1.4 C语言输入输出 1.5 数据类型 1.6 分支结构 1.7 循环结构 1.8 数组 ...
Java基础——面向对象编程（重载、重写、封装）
abelboy的博客
11-04 1169
Java基础——面向对象编程（重载、重写）重写与重载重写：重载可变个数形参方法的参数传递（重点、难点）封装访问权限修饰符构造方法 重写与重载 重写： 参数与返回值相同，权限不能小于所覆盖的方法，抛出的异常不能大于多于所覆盖的方法。 重载 方法名相同，参数不同（数量、类型、顺序），与访问权限修饰符返回类型无关也就是可以不同。 可变个数形参 格式：对于方法的形参： 数据类型 … 形参名 可变个数的形参...
面向对象编程之玩转重载
俗人世界
01-10 301
面向对象编程之玩转重载
Java编程基础之重载和重构的区别
我先测了
03-25 3897
1、重载(overloading) 是在一个类里面，方法名字相同，而参数不同。返回类型不做重载依据。直接上三份代码演示： public class OverLoadDemo1 { /** * 参数的数量不同 参数的类型不同 参数的顺序不同 */ // 调整参数类型为int，调整高度 public static void increaseSeetHight( int x){ Sy...
十个 C++ 运算符重载示例，看完不懂打我...
热门推荐
人人都懂物联网
11-28 3万+
下面是一些 C++ 运算符重载示例，包括算术运算符、赋值运算符、逻辑运算符、成员运算符、关系运算符等等，这些都是使用频率较高的几个运算符重载案例。 ⭐️ 所有示例代码均存放于 GitHub: getiot/cpp-courses/operator_overloading 。 示例 1：一元运算符重载 一元运算符即只对一个操作数进行操作的运算符，例如：!obj、-obj、++obj 、obj++ 或 obj-- 等等。 下面示例将对负号（-）进行重载： #include <iostream> u
c++ 运算符重载
物联黄同学的博客
09-26 3014
前言 本篇内容参考了b站up主黑马程序员的视频，这是链接https://www.bilibili.com/video/BV1et411b73Z?p=126 什么是运算符重载？ 运算符重载类似于函数重载，回顾函数重载，我们会发现，发生函数重载使得同名函数具有不同的应用，运算符重载也是如此，针对不同的对象，运算符重载可以有不同的应用。但是，我们在做运算符重载时并不是扩大一个运算符的功能，而是扩大它应用的范围。 运算符重载的应用场景 运算符重载常用于对类或者结构体的运算符操作，例如，一个类有几个int属性，然
c++运算符重载与输入输出流重载
weixin_68269316的博客
03-24 7489
运算符重载 运算符重载——赋予运算符具有操作自定义类型数据功能 运算符重载本身也是一种函数，我们有两种写法——友元类运算符重载函数和类运算符重载 运算符重载的实质本身就是函数调用 我们要注意它的写法： 函数返回值 :运算完成后的值决定的 函数名 : operator 加上重载运算符组成函数名 例如operator+就是重载加号 参数 ：看运算符的操作数,具体参数个数是要看你重载函数形式是什么 函数体 : 写运算符具体想要...
C++运算符重载(超全）
LancasterLiu的博客
06-27 3万+
C++运算符重载 1) 运算符重载的本质为函数重载，但有一定的规则需要遵循。[1] (1)重载运算符时,运算符的运算顺序和优先级不变,操作数个数不变。 (2)不能创造新的运算符,只能重载C++中已有的运算符,并且规定有6个运算符不能重载,如表所示。 不能重载的运算符 含义 . 类属关系运算符 .* 成员指针运算符 :: 作用域运算符 ?: 条件运算符 # 编译预处理符号 sizeof() 取数据类型的长度 (3)运算符重载是针对新类型的实际需求,对原有的运算符进行适当
C++运算符重载 (含代码)
DRZ_2000的博客
01-17 956
文章目录一 概念介绍二 代码演示 一 概念介绍   当运算符作用于自定义的类类型的运算对象时，需要通过运算符重载重新定义该运算的含义。重载的运算符是具有特殊名字的函数：它们的名字由关键字 operator 和其后要定义的运算符号共同组成，如operator+。和其他函数一样，重载的运算符也包含返回类型、函数名、参数列表以及函数体。   运算符重载按照重载函数定义位置的不同可分为两类：一类是在类内，作为类的成员方法；另一种是定义在类外的非成员函数，即普通的全局函数。对于类内成员方法：函数仅一个参数，运算符左
c++第十章运算符重载
最新发布
11-18
C++中的运算符重载是指对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型。第十章主要介绍了C++中运算符重载的相关知识，包括运算符重载的概念、运算符重载的方法、运算符重载的限制等。 以下是...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值