C++核心编程 day05 运算符的重载

最新推荐文章于 2024-11-16 10:02:08 发布
最新推荐文章于 2024-11-16 10:02:08 发布
阅读量51 收藏
点赞数
分类专栏： C++核心编程 文章标签： c++ 开发语言
月仙儿
本文链接：https://blog.csdn.net/qq_42198306/article/details/134199040
版权

C++核心编程 day05 运算符的重载

01. 数组类的封装

经过day04的内容，接下来需要强化锻炼一个关于类的封装的能力。现在需要定义一个数组的类，实现以下的一些功能：

  • 数组的构造方法，实现无参构造（默认数组容量为100），有参构造（参数为数组的容量）、拷贝构造函数。
  • 在数组的末尾插入一个元素。
  • 根据位置下标设置数组某个位置上的数据。
  • 获取数组中指定下标存储的数据。
  • 获取数组的容量。
  • 获取数组的当前大小。

根据上面的内容，我们将数组的定义和实现进行了分开，下面是实现代码：

Array.h

#pragma once
class Array
{
public:
	Array(); // 默认构造，给100容量
	Array(int capacity); // 有参构造
	Array(const Array & array); // 拷贝构造

	// 尾插法
	void pushBack(int val);

	// 根据位置设置数据
	void setData(int pos, int val);

	// 根据位置获取数据
	int getData(int pos);

	// 获取数组容量
	int getCapacity();

	// 获取数组大小
	int getSize();
	
	// 析构函数
	~Array();

	// 重载运算符[]
	int &operator[](int index);

private:
	int capacity; // 数组容量
	int size; // 数组大小
	int *pArray; // 堆区的数组指针
};

Array.cpp

#include "Array.h"
#include <iostream>
#include <cstdlib>
using namespace std;

// 默认构造，给100容量
Array::Array()
{
	cout << "默认构造函数调用" << endl;
	this->capacity = 100;
	this->size = 0;
	this->pArray = new int[this->capacity];
}

// 有参构造
Array::Array(int capacity)
{
	cout << "有参构造函数调用" << endl;
	this->capacity = capacity;
	this->size = 0;
	this->pArray = new int[this->capacity];
}

// 拷贝构造
Array::Array(const Array & array)
{
	cout << "拷贝构造函数调用" << endl;
	this->capacity = array.capacity;
	this->size = array.size;
	this->pArray = new int[this->capacity];
	memcpy(this->pArray, array.pArray, sizeof(int)* this->size);
}

// 尾插法
void Array::pushBack(int val)
{
	if (this->size == this->capacity)
	{
		return;
	}

	this->pArray[this->size ++] = val;
}

// 根据位置设置数据
void Array::setData(int pos, int val)
{
	if (pos >= this->size)
	{
		return;
	}

	this->pArray[pos] = val;
}

// 根据位置获取数据
int Array::getData(int pos)
{
	if (pos >= this->size)
	{
		return -1;
	}

	return this->pArray[pos];
}

// 获取数组容量
int Array::getCapacity()
{
	return this->capacity;
}

// 获取数组大小
int Array::getSize()
{
	return this->size;
}

// 析构函数
Array::~Array()
{
	if (this->pArray != NULL)
	{
		cout << "析构函数调用" << endl;
		delete[] this->pArray;
		this->pArray = NULL;
	}
}

// 重载运算符[]
int &Array::operator[](int index)
{
	return this->pArray[index];
}

接下来对数组进行测试，测试代码如下：

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
using namespace std;
#include "Array.h"

int main()
{
	Array arr;
	for (int i = 0; i < 10; i++)
	{
		arr.pushBack(i);
	}

	for (int i = 0; i < 10; i++)
	{
		cout << arr.getData(i) << " ";
	}
	cout << endl;

	Array arr2(arr);
	for (int i = 0; i < 10; i++)
	{
		cout << arr2.getData(i) << " ";
	}
	cout << endl;

	arr.setData(3, 100);
	cout << arr.getData(3) << endl;

	cout << "数组容量为: " << arr.getCapacity() << endl;
	cout << "数组大小为: " << arr.getSize() << endl;

	for (int i = 0; i < 10; i++)
	{
		cout << arr[i] << " ";
	}
	cout << endl;


	system("pause");
	return 0;
}

运行结果符合预期的要求。

在这里插入图片描述

02. 运算符重载

运算符重载就是对已有的运算符进行重新定义并且赋予另一种功能。比如在C语言中&的作用是取地址符，而在C++中赋予了一种新的功能为引用。再比如<<在C语言中只能表示二进制左移，而在C++中在cout之后表示拼接。运算符的重载和定义一个普通函数的形式差不多，只不过函数名变成了operator + 运算符。在这个函数中，函数的形式参数取决于两个因数，该运算符是一元运算符还是二元运算符？该函数是重载在类中作为成员函数还是全局函数。如果该运算符被定义在类中作为成员函数，则该类的成员默认算作是一个运算数，作为左操作数。

在运算符的重载之中，我们可以写全局函数，也可以写成为成员函数。但是这里有个问题的时候当我们写成全局函数的时候就无法去访问类中的私有权限的变量，因此我们一般将运算符重载的全局函数形式与友元进行使用。让全局函数作为某一个类的好朋友。例如我们会对<<进行操作。一般来说cout是位于变量的左边的，而我们使用成员函数来进行运算符的重载之后，由于第一个操作数是该类本身的对象，所以会导致我们的变量在cout的左边，不适合我们平时的写法。因此我们需要使用全局函数去进行重载，这样第一个参数为ostream类型的引用，第二个参数为需要传入的类的对象，这样就可以保证cout位于对象的左边。但是这样会导致函数无法去访问某些私有变量，假设我们需要输出某些属性，这样我们就需要将该全局函数作为类的友元函数就可以访问私有属性了。

在C语言中的所有运算符，我们基本上都可以进行重载，但是当运算符的使用受到限制的时候，我们最好不能去重载。比如&&或者||之类的 ，由于这两个运算符会涉及到短路运算，而这种短路的效果是我们重载无法实现的，因此我们不去重载这两个运算符。重载的时候如果会改变十字的运算顺序，改变运算符的优先级，我哦们也是不可以进行重载的。下面给出C++中允许重载和不允许重载的运算符。如下：

在这里插入图片描述

01. 加号运算符重载

首先最简单的就是重载加法的运算符。例如这里有两个Person的实例，里面有两个成员变量，而我们加起来可以得到一个Person类的实例，其中的成员变量分别是另外两个成员变量之和。在这里我们可以选择是用全局函数重载加法运算符还是使用成员函数重载加法运算符。我们可以写出以下的两个重载的定义：

Person operator+(const Person &);	// 作为成员函数重载，该类的示例作为左操作数，形式参数作为右操作数。
Person operator+(const Person &, const Person &); // 作为全局函数重载加号运算符，第一个形式参数作为第一个操作数，第二个形式参数作为第二个操作数。

当然这是两个Person类的对象相加，如果我们需要使一个Person类的对象加上一个int类型的数据，使得结果是将Person对象中的成员变量值增加相应的量，。此时我们可以写成以下的重载定义：

Person operator+(const int &);	// 作为成员函数重载加号运算符，左操作数为该类的对象，右操作数是形式参数。
Person operator+(const Person &, const int &);	// 作为全局函数重载加号运算符，其中左操作数为第一个形式参数，右操作数为第二个形式参数。

这就是加号运算符的重载，接下来我们给一个示例代码，代码如下：

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
using namespace std;

class Person
{
public:
	Person()
	{
		this->m_a = 0;
		this->m_b = 0;
	}

	Person(int a, int b) :m_a(a), m_b(b) {}

	 利用成员函数实现加号运算符重载
	//Person operator+(Person &p)
	//{
	//	Person tmp;
	//	tmp.m_a = this->m_a + p.m_a;
	//	tmp.m_b = this->m_b + p.m_b;
	//	return tmp;
	//}

	int m_a;
	int m_b;
};

// 利用全局函数实现加号运算符重载
Person operator+(Person &p1, Person &p2)
{
	Person tmp;
	tmp.m_a = p1.m_a + p2.m_a;
	tmp.m_b = p1.m_b + p2.m_b;
	return tmp;
}

Person operator+(Person &p, const int &num)
{
	Person tmp;
	tmp.m_a = p.m_a + num;
	tmp.m_b = p.m_b + num;
	return tmp;
}

int main()
{
	Person p1;
	Person p2(1, 3), p3(4, 3);

	cout << "p2.m_a = " << p2.m_a << " p2.m_b = " << p2.m_b << endl;
	cout << "p3.m_a = " << p3.m_a << " p3.m_b = " << p3.m_b << endl;

	p1 = p2 + p3;
	//p1 = p2.operator+(p3);	// 成员函数本质
	//p1 = operator+(p2, p3);		// 全局函数本质
	cout << "p1.m_a = " << p1.m_a << " p1.m_b = " << p1.m_b << endl;

	p1 = p1 + 10;
	cout << "p1.m_a = " << p1.m_a << " p1.m_b = " << p1.m_b << endl;

	int a = 30;
	p1 = p1 + a;
	cout << "p1.m_a = " << p1.m_a << " p1.m_b = " << p1.m_b << endl;

	system("pause");
	return 0;
}

02. 左移运算符重载

这里我们才重载一下左移运算符，实现某个类能够使用cout去进行输出。关于这里的注意事项我们在最前面已经提到过，这里就直接上代码和注释。

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
using namespace std;

class Person
{
	friend ostream &operator<<(ostream &, Person &);
public:
	Person(int a, int b):m_a(a), m_b(b) {}

	 利用成员函数重载左移运算符
	//ostream& operator<<(ostream &cout)	
	//{
	//	// 输出会变成 p << cout; 而我们习惯于把cout放左边，因此采取全局函数重载
	//	cout << "m_a = " << this->m_a << ", m_b = " << this->m_b << endl;
	//	return cout;
	//}

private:
	int m_a;
	int m_b;
};

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

int main()
{
	Person p1(12, 43);

	//p1.operator << (cout);
	//p1 << cout;

	cout << p1 << endl;

	system("pause");
	return 0;
}

03. 递增运算符重载

递增运算符为++，递减运算符和递增运算符的重载是类似的，因此此处只说递增运算符。递增运算符我们分为前置运算符和后置运算符，那么我们怎么去区分究竟是重载了前置自增运算符还是后置自增运算符。这里的解决方法其实就是我们前面说的一个占位参数。假如有个自定义的MyInter类，我们来看看这两个重载的声明：

// 前置递增
MyInter& operator++();

// 后置递增
MyInter operator++(int);

这里就是一个关于占位参数的使用。或许你会问第一个为什么是引用，而后置递增中我们使用的却是一个普通的变量作为返回值。我们来回忆一下C语言的一些语法。在C语言中我们执行++ ++a是可以的，而我们执行a ++ ++之后得到的a或许就不是你想要的结果，假如a的初始值为0，那么前置自增运算符两次得到的结果就是2，而两次后置自增运算符得到的结果就是1了。其实无论后置递增中你写多少个，原来的变量都只会执行一次递增，因为后面的已经不是变量自身了，也就是我写成a ++ ++ ++ ++ ++ ++ ++得到的最终的a结果还是1。因此我们才会前置写变量的引用，后置返回值为一个变量。接下来我们来看一个示例代码。

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
using namespace std;

class MyInter
{

	friend ostream &operator<<(ostream &, MyInter &);

public:
	MyInter() 
	{
		this->m_number = 0;
	}
	MyInter(int a) :m_number(a){}

	// 重载前置++
	MyInter& operator++()
	{
		this->m_number++;
		return *this;
	}

	// 重载后置++
	MyInter operator++(int)
	{
		// 记录初始状态
		MyInter tmp = *this;
		this->m_number++;
		return tmp;
	}

private:
	int m_number;
};

ostream &operator<<(ostream &cout, MyInter &myInter)
{
	cout << myInter.m_number;
	return cout;
}

int main()
{
	MyInter a = 10;

	cout << a << endl;	// 10
	cout << a++ << endl;	// 10
	cout << a << endl;	// 11
	cout << ++a << endl;	// 12
	cout << a << endl;	// 12
	cout << ++ ++a << endl;	// 14
	cout << a << endl;		//14
	cout << a++ ++<< endl;	// 14
	cout << a << endl;	// 15

	system("pause");
	return 0;
}

04. 指针运算符重载

指针运算符主要包括*和->，重载的作用主要在于智能指针的使用。也就是对象的释放全部交由智能指针来完成，用户不需要管理堆区内存的释放。智能指针的示例如下：

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
using namespace std;

class Person
{
public:
	Person(int age) :m_age(age) 
	{
		cout << "Person的有参构造函数调用" << endl;
	}

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

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

private:
	int m_age;
};

class SmartPoint
{
public:
	SmartPoint(Person *pPerson) :m_pPerson(pPerson)
	{
		cout << "SmartPoint的有参构造函数调用" << endl;
	}

	// 重载->运算符
	Person *operator->()
	{
		return this->m_pPerson;
	}

	// 重载*运算符
	Person& operator*()
	{
		return *this->m_pPerson;
	}

	~SmartPoint()
	{
		cout << "SmartPoint的析构函数调用" << endl;
		if (this->m_pPerson != NULL)
		{
			delete this->m_pPerson;
			this->m_pPerson = NULL;
		}
	}

private:
	Person *m_pPerson;
};

int main()
{
	// 利用智能指针，管理new出                    来的Person的释放操作
	SmartPoint sp(new Person(18));
	// sp->m_pPerson->m_age
	sp->showAge(); // 本质为 sp->->showAge(); 编译器简化为sp->showAge();
	(*sp).showAge(); 

	system("pause");
	return 0;
}

05. 赋值运算符重载

在类的定义中，编译器会默认提供四个函数，分别是无参构造函数、析构函数、拷贝构造函数（值拷贝）、operator=函数（值拷贝）。而这里的赋值运算符重载就是去重载=。因为我们大部分时候创建的对象都是放在堆区上的。如果使用默认的赋值运算是简单的值拷贝。当我们要释放某一个变量的内存，则会出现重复释放同一块内存的情况，就会导致程序出错崩溃。赋值运算符重载的示例代码如下：

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
using namespace std;

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

	// 重载 =
	Person &operator=(const Person &p)
	{
		// 判断原来堆区是否有内容，有则释放
		if (this->name != NULL)
		{
			delete[] this->name;
			this->name = NULL;
		}

		this->name = new char[strlen(p.name) + 1];
		strcpy(this->name, p.name);
		this->age = p.age;

		return *this;
	}

	// 拷贝构造
	Person(const Person &p)
	{
		this->name = new char[strlen(p.name) + 1];
		strcpy(this->name, p.name);
		this->age = p.age;
	}

	// 析构函数
	~Person()
	{
		if (this->name != NULL)
		{
			delete[] this->name;
			this->name = NULL;
		}
	}

	char *name;
	int age;
};

ostream& operator<<(ostream &cout, Person &p)
{
	cout << "姓名: " << p.name << " ,年龄: " << p.age;
	return cout;
}

int main()
{
	Person p1("迪杰斯特拉", 46);
	Person p2("蘑古力", 43);

	Person p3("", 0);

	p3 = p1;
	cout << "p1的信息=>" << p1 << endl;
	cout << "p2的信息=>" << p2 << endl;
	cout << "p3的信息=>" << p3 << endl;

	p1 = p3 = p2;
	cout << "p1的信息=>" << p1 << endl;
	cout << "p2的信息=>" << p2 << endl;
	cout << "p3的信息=>" << p3 << endl;

	system("pause");
	return 0;
}
月仙儿
关注
专栏目录
C++之“赋值运算符重载“
2402_83250773的博客
10-22 752
赋值运算符重载
C++：拷贝构造函数和赋值运算符重载
2302_79988283的博客
04-25 2512
6. 虽然编译器会生成默认的拷贝构造函数，但仅仅会完成浅拷贝，如果拷贝的函数涉及空间申请（如stack），则会出现错误（两个函数会申请到同一块空间，销毁时会出现同一块空间释放2次，导致程序崩溃）。： 编译器自动生成的赋值运算符重载是浅拷贝，对于无空间申请的函数可以（如Date）,对于有空间申请的函数就不可以（如Stack），必须自己写。上图中，我故意将减法重载成加法，Sum执行的+是我重载的减法，但b执行的还是加法，说明内置类型的运算符不受重载运算符的影响。
C++运算符重载详解
qq_42757463的博客
05-11 3522
（类和对象）运算符重载本质还是函数调用，但C++编译器做了特殊的处理，在程序中，函数的实参书写在运算符+的两边，代替了函数名和括号的传统书写方式。好处。
【C++】运算符重载 | 赋值运算符重载
2301_76540463的博客
08-20 2784
1.常用的操作符有：+、-、*、/、++、--、=（赋值）、==（判断相等）、>、=、
C++ 运算符重载+赋值运算符重载
Jason_from_China的博客
09-20 903
当运算符被用于类类型的对象时，C++ 语言允许我们通过运算符重载的形式指定新的含义。C++ 规定类类型对象使用运算符时，必须转换成调⽤对应运算符重载，若没有对应的运算符重载，则会编译报错。运算符重载是具有特殊名字的函数，他的名字是由 operator 和后面要定义的运算符共同构成。和其他函数一样，它也具有其返回类型和参数列表以及函数体。重载运算符函数的参数个数和该运算符作用的运算对象数量一样多。
C++运算符重载
2401_83305953的博客
09-09 3396
如果不写赋值运算符重载函数，系统会自动生成，但是浅拷贝，一个字节一个字节的拷贝，对于占用资源的还是要自己写才好。对于类类型的使用运算符编译器是不知道要干嘛的就需要自己写函数，自己实现功能。要跟拷贝构造区分，拷贝构造是一个已经存在，给另一个初始化时进行的拷贝操作。日期 - 日期，日期 + 天数，日期 - 天数，这些都是有意义的。总结如果显示写了析构，就要显示写赋值运算符重载。对两个已经存在的类的对象进行赋值拷贝操作。运算符的作用，用于定义类的成员函数指针。就比如日期类的大小比较。
【C++】运算符重载详解
qq_64818885的博客
02-04 4463
运算符重载函数的参数取决于要重载的运算符的操作数个数和类型。
【C++ | 重载运算符】一文弄懂C++运算符重载，怎样声明、定义运算符，重载为友元函数
wkd_007的博客
06-21 4923
👉本文主要介绍了为什么需要重载运算符，重载运算符有哪些限制，怎样声明、定义运算符函数，怎样将运算符重载为友元函数。
【C++】运算符重载
炸掉地球的博客
06-26 1102
但是我们如果重载成全局函数，就需要类成员变量是公有属性，因为类外无法访问类的私有成员。但是这样就会破坏封装性。 因此，为了保证封装性，我们一般将运算符重载为类的友元函数或类的成员函数。
C++：拷贝构造函数、赋值运算符重载
2401_86551514的博客
09-10 2068
如果一个构造函数的第一个参数是自身类类型的引用，且任何额外的参数都有默认值，则此构造函数也叫做拷贝构造函数，也就是说拷贝构造是⼀个特殊的构造函数。这样写才是拷贝构造，通过同类型的对象初始化构造，而不是指针。这里可以完成拷贝，但是不是拷贝构造，只是⼀个普通的构造。也可以这样写，这里也是拷贝构造。
C++ 类和对象 赋值运算符重载
m0_72625526的博客
07-15 1321
运算符重载是通过定义特殊的成员函数或全局函数来实现的。
c++ “拷贝构造，运算符重载”
fanhailomg的博客
05-06 921
c++
C++初阶讲解—运算符重载汇总+实例（上）
m0_57781768的博客
11-17 1482
运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。
C++入门基础知识150—【关于C++ 输入/输出运算符重载】
最新发布
zhaoylzy的博客
11-16 887
关于【C++输入/输出运算符重载】 一、什么是输入/输出运算符 二、什么是输入输出运算符重载 三、输入输出运算符重载格式 四、输入输出运算符重载参数之间的区别 五、重载提取运算符 >> 和插入运算符
C++ 中的string类
2201_75357870的博客
11-15 789
end获得的不是最后一个字符的位置，而是最后一个字符的下一个位置！end()-1才是最后一个字符的位置。
c++中，头文件包含iostream.h和`＜iostream＞`的差别
南东先生
11-11 515
`iostream.h` 和`` 包含的是同一个文件，二者在功能上没有差别,只是写法不同。使用``是C++标准推荐的方式。
C++——智能指针
Wangx_wang的博客
11-12 972
介绍了几种智能指针的不同和实现思路以及循环引用的问题
C++ 编程基础（5）类与对象 | 5.7、友元
个人技术博客
11-14 1022
C++中的友元类与友元函数是一种强大的工具，它们允许程序员在保持类封装性的同时，实现对类内部数据的直接访问。然而，在使用时应谨慎考虑其对封装性、安全性和维护性的影响。只有在确实需要时才使用友元类和友元函数，以避免引入不必要的复杂性和潜在问题。
C++日期类实现比较运算符重载示例
本资源是一份名为"02-12.7实例2日期类...这对于理解面向对象编程中的类设计和运算符重载是很有价值的。通过这个实例，读者可以掌握如何在实际项目中处理日期相关的逻辑，以及如何在类的上下文中实现定制化的比较功能。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值