C++核心编程(8)--运算符重载

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

目录

8 运算符重载

8.1 加号运算符重载

8.2 左移运算符重载

8.3 递增运算符重载

8.4 赋值运算符重载

8.5 关系运算符重载

8.6 函数调用运算符重载

8 运算符重载

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

 

8.1 加号运算符重载

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

class Person {
public:
    Person()
    {}；
	Person(int a, int b)
	{
		this->m_A = a;
		this->m_B = b;
	}
    
	//成员函数实现 + 号运算符重载
	Person operator+(const Person& p) {  //operator 加号运算符通用名称
		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+(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& 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.operaor+(p1); 成员函数重载本质调用
    //Person p3 = operaor+(p1 , p2); 全局函数重载本质调用 
	Person p3 = p2 + 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;
}

总结1：对于内置的数据类型的表达式的的运算符是不可能改变的

总结2：不要滥用运算符重载

 

8.2 左移运算符重载

作用：可以输出自定义数据类型，成员函数无法实现。

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

class Person {
	friend ostream& operator<<(ostream& out, Person& p); //友元，全局函数访问私有成员变量

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

	//成员函数 实现不了 cout << p
    //p.operator<<(cout) 简化版本 p << cout 不是我们想要的效果
	//void operator<<(Person& p){ //只有一个对象
	//}

private:
	int m_A;
	int m_B;
};

//全局函数实现左移重载
//例子：void operator<<(cout, Person &p) //本质 operator<<(cout , p) 简化为 cout << p
//cout 的数据类型是 ostream（输出流对象）， ostream对象只能有一个需要引用传递
ostream& operator<<(ostream& out, Person& p) {  //out 是 cout 的引用，可取别名
	out << "a:" << p.m_A << " b:" << p.m_B;
	return out; //返回ostream& ，后面还可以继续输出流
}

void test() {
	Person p1(10, 20);
	cout << p1 << "hello world" << endl; 
}

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

 

8.3 递增运算符重载

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

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

class MyInteger {
	friend ostream& operator<<(ostream& out, MyInteger myint);

public:
	MyInteger() {
		m_Num = 0;
	}
	//前置++  , ++m_Num
	MyInteger& operator++() {  //返回引用为了一直对一个数据进行递增操作
		//先++
		m_Num++;
		//再返回
		return *this; //取自身返回
	}

	//后置++  , m_Num++
    //记录当前本身的值，然后让本身的值加1，但是返回的是以前的值，达到先返回后++；
	MyInteger operator++(int) { //形参占位，防止函数重定义，区分前置和后置递增函数
		//先 记录当时结果
		MyInteger temp = *this;   //取自身
        //后让本身的值加1
		m_Num++;
        //最后 返回的是以前的值
		return temp; //因为返回的是局部对象，所以不能返回引用
	}

private:
	int m_Num;
};

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


//前置++ 先++ 再返回
void test01() {
	MyInteger myInt;
	cout << ++myInt << endl;
	cout << myInt << endl;
}

//后置++ 先返回 再++
void test02() {

	MyInteger myInt;
	cout << myInt++ << endl;
	cout << myInt << endl;
}

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

 

8.4 赋值运算符重载

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

  1. 默认构造函数(无参，函数体为空)

  2. 默认析构函数(无参，函数体为空)

  3. 默认拷贝构造函数，对属性进行值拷贝

  4. 赋值运算符 operator=, 对属性进行值拷贝

 

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

示例：

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

	//重载赋值运算符 
	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;
	}

    /* 这样写也可
    Person& operator=(Person &p)
	{
		*m_Age = *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 << "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;
}

 

8.5 关系运算符重载

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

示例：

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;
}

 

8.6 函数调用运算符重载

  • 函数调用运算符 () 也可以重载

  • 由于重载后使用的方式非常像函数的调用，因此称为仿函数

  • 仿函数没有固定写法，非常灵活

示例：

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

};
void test01()
{
	//重载的（）操作符 也称为仿函数
	MyPrint myFunc;
	myFunc("hello world");
}


class MyAdd
{
public:
	int operator()(int v1, int v2)
	{
		return v1 + v2;
	}
};

void test02()
{
	MyAdd add;
	int ret = add(10, 10);
	cout << "ret = " << ret << endl;

	//匿名对象调用  
	cout << "MyAdd()(100,100) = " << MyAdd()(100, 100) << endl;
}

int main() {
	test01();
	test02();
	system("pause");
	return 0;
}
kaka的卡
关注
专栏目录
6-4 键值对表的管理（运算符重载）
qq_45550552的博客
06-17 2649
键值对(key-value pair)表中存储的是一个个键值对，如table[2016]=19.5表示该表中有一项的key为2016，其value为19.5。我们需要管理的表中， key为整数，而value可为浮点数，整数或字符。所以我们定义一个类模板，得到了三个相应的模板类。 键值对表的容量是有限的，当表中存储的key的数量达到上限时，将不存入新的键值对，但对表中已有的key仍然会继续更新其value。每行输入有三项，第一项是类型（1为浮点数，2为整数，3为字符），第二项是key，第三项是value。在处
练习 ~黑马程序员匠心之作-第三阶段C++核心编程-P121~P126-类和对象-C++运算符重载
qq_43964914的博客
07-24 418
黑马程序员匠心之作|C++教程从0到1入门编程 关于P121~P126-练习-类和对象-C++运算符重载1、加号运算符重载2、左移运算符重载3、递增运算符重载4、赋值运算符重载5、关系运算符重载6、函数调用运算符重载 1、加号运算符重载 2、左移运算符重载 3、递增运算符重载 4、赋值运算符重载 5、关系运算符重载 6、函数调用运算符重载 ...
(C++学习笔记七)运算符重载
qq_37459242的博客
05-31 160
八.运算符重载 1.Code : #include<iostream> using namespace std; //运算符重载的意义: //对已有的 运算符 重新进行定义,赋予其另一项功能,以适应不同的数据类型 // operator : 操作人员 // 一. 加号运算符重载 //作用: 实现两个自定义数据类型相加的运算 //总结1：对于内置的数据类型的表达式的的运算符是不可能改变的 //总结2：不要滥用运算符重载 class Person { public: Person()
关于运算符重载(总结)
Hapiman11的专栏
03-10 903
1、运算符重载是为了对用户自定义数据类型的数据的操作与内定义的数据类型的数据的操作形式一致。 不能重载的5个运算符：*成员指针访问运算符；：：域运算符；sizeof长度运算符；？：条件运算符；.成员访问符。 运算重载的三种方式：普通函数，友元函数，类成员函数。 当重载为成员函数时，双目运算符仅有一个参数。对单目运算符，重载为成员函数时，不能再显式说明参数。 重载为成员函数时，总时隐含了一个
重载C++中的++运算符(包含对+的重载)
mmmmmmyy的博客
07-26 7959
正确代码：  #include&lt;iostream&gt; using namespace std; class Complex { friend ostream &amp;operator &lt;&lt; (ostream &amp;out,const Complex &amp;c); private: int m_a; int m_b; public: Comple...
运算符重载
Arivn_emb
11-19 686
//创建num类： #include using namespace std; class num  { public:     num(){n=1;}     ~num(){}     int get()const{return n;}     void set(int x){n=x;} private:     int n; }; int main() {  
C++课后习题8-15中非编程问题的答案
07-12
本资源是C++课后习题8-15中非编程部分的答案集合，对于学习者来说，是一份非常有价值的参考资料。 1. **选择题**：C++的选择题通常涉及到语法、数据类型、运算符、控制结构、函数、类和对象等方面。例如，可能涉及...
c++核心编程指南中文版
09-29
### C++核心编程指南知识点概览 #### 一、引言 - **文档性质**: 这份文档被视为C++核心编程指南的一个早期草稿版本，它由C++语言的创造者Bjarne Stroustrup与Herb Sutter共同编辑，并由中国开发者李一楠负责翻译。 ...
C++运算符重载和继承
01-17
在C++编程中，运算符重载和继承是两个核心概念，它们极大地扩展了语言的能力，使得代码更加灵活且易于理解。本章我们将深入探讨这两个主题，并通过实际代码示例来阐述它们的工作原理。 首先，让我们关注“运算符...
C++核心编程讲义和相关代码
02-15
在"C++核心编程讲义和相关代码"中，我们将会深入探讨C++的基础概念、核心特性以及实际应用。这份讲义和代码集合是学习C++编程的理想资源，它将理论与实践相结合，帮助读者建立起坚实的C++编程基础。 1. **C++基础...
981.基于时间的键值存储（有关运算符重载）
嗑盐工作室
11-29 162
创建一个基于时间的键值存储类TimeMap，它支持下面两个操作： 1. set(string key, string value, int timestamp) 存储键key、值value，以及给定的时间戳timestamp。 2. get(string key, int timestamp) 返回先前调用set(key, value, timestamp_prev)所存储的值，...
内存管理(10)——运算符重载
qq_34573534的博客
08-26 126
1、==、Equals、HashCode 2、运算符重载==能够改变相等判断的规则。
C++ 学习之路(12)：运算符重载
Rioer的博客
04-08 1081
运算符重载的好处： 实现自定义类型之间的运算。 1、运算符重载函数 2、运算符重载函数有两种调用方法 显示调用： operator(aa,bb) 隐式调用：aa@bb ( @为运算符 aa、bb分别为两个不同的参数) 3、友元运算符重载函数 ① 友元运算符重载函数的原型 在类的内部声明格式如下： class X { …
关于operator运算符重载，简单练习说明原理
活到老学到老，技术成就梦想
08-05 805
namespace 运算符重载 {     class Program     {         static void Main(string[] args)         {             ClassOne one = new ClassOne(2);             ClassOne two = new ClassOne(3);            C
C++拷贝构造函数
珲太狼
06-26 3974
关键字:   C++      默认拷贝构造函数的行为如下: 默认的拷贝构造函数执行的顺序与其他用户定义的构造函数相同,执行先父类后子类的构造. 拷贝构造函数对类中每一个数据成员执行成员拷贝(memberwise Copy)的动作. a)如果数据成员为某一个类的实例,那么调用此类的拷贝构造函数. b)如
C++入门教程（14）运算符重载（operator+）
CV战士的日常
03-14 3127
运算符重载赋予了自定义的类可以进行运算符操作的能力，比如自己定义了一个Positon 的坐标类，希望可以通过加减来得到新的坐标，就可以通过运算符重载来实现 其实就是实现一个 operator+函数，这个函数以operator开头，接上一个运算符，运算符重载可以提高代码的可读性，如果不使用也可通过其他函数实现，完全可以达到相同的效果。 #include <iostream> using namespace std; class Position{ pu
C++运算符重载(operator overload)
fengzi
08-24 1986
C++中提供了运算符重载机制(operator overload 简称:Op).它可以为自定义数据类型重载运算符.实现构造数据类型也可以具有像基本数据类型一样的运算特征(C中没有改机制). 示例: using namespace std; struct Student{ int age; string name; }; b...
2020-12-10
今天的博客
12-10 91
赋值运算符重载 开始 //每日心得：独上高楼，望尽天涯路 //日期：12.8 //学习内容：赋值运算符重载 //重点： 1、p2 = p1 即 p2 调用赋值函数 传入 p1 类(p2) operator = ( p1 ) 2、p2 赋值应该先判断是否有属性在堆区， 如果有先释放干净，然后再深拷贝（重新建立新的指针） 3、指针管理对应的数据类型 #include <iostream> using namespace std; class Person { public: **//构造
C++编程：禁用重载与运算符规则详解
在C++嵌入式系统开发，尤其是基于Cortex-A8平台的环境中，有一些运算符由于其核心功能和语言设计原则，是不能被程序员重载或重新定义的。这些运算符包括： 1. `.` (成员选择)：用于访问类的对象成员，这是为了确保...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值