2024年最新一文详解C++运算符重载【自己动手封装一个xxx(2)，C C++面试C C++基础

于 2024-05-14 14:22:51 发布
阅读量899 收藏 29
点赞数 10
分类专栏： 程序员 文章标签： c语言 c++ 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_84978503/article/details/138853750
版权

img
img

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上C C++开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以戳这里获取

二、二元运算符重载

===========================================================================

通俗的来讲二元运算符重载是为了解决两个数据类型复杂的变量之间的运算操作；

操作符关键字使用语法:

类型 operater(要重载的运算符)(参数列表){实现方法}；

可以分为:1.全局函数操作符重载 2.成员函数操作符重载;

具体实现方法如下:

(友元函数可以对类的成员属性直接操作,有时结合使用更方便)

代码实现

代码如下：

#include

using namespace std;

class test {

private:

int a;

int b;

public:

test(int a = 0, int b = 0) {

this->a = a;

this->b = b;

}

int getA() {

return a;

}

int getB() {

return b;

}

friend test operator+(test& a, test& b);

test operator-(test& b);

void print() {

cout << “a:” << a << “b;” << b << endl;

}

~test() {

cout << “这里是析构函数,over” << endl;

}

};

//友元函数二元操作符重载;

test operator+(test& a, test& b) {

test c(a.a + b.a, a.b + b.b);

return c;

}

//非友元函数非成员函数操作符重载;

test operator*(test& a, test& b) {

test c(a.getA() * b.getA(), a.getB() * b.getB());

return c;

}

//成员函数操作符重载；

test test::operator-(test& b) {

test c(this->a - b.a, this->b - b.b);

return c;

}

int main_caozuofu() {

test a(1, 2), b(3, 4);

cout << “a.a:” << a.getA() << " a.b" << a.getB() << " b.a" << b.getA() << " b.b" << b.getB() << endl;

test c = a + b;//重载加操作符;（友元函数）

c.print();

test d = a * b;//重载加操作符；（全局非友元，非成员）

d.print();

test e = a - b;//重载减法操作符；（成员函数）

e.print();

return 0;

}

三、一元运算符重载

===========================================================================

一元运算符重载包括:前置加加减减，后置加加减减

前置加加前置减减:

1.友元函数

2.成员函数

直接对传进来的对象操作,操作后直接返回(如果用引用将对象传递进来可以不用返回

,因为引用已经对原来的对象进行了操作)操作完后直接使用结果

后置加加减减：(比前置加加减减多一部操作)

1.友元函数

2.成员函数

对传进来的对象AAAA进行备份,因为本次操作还使用对象改变前的变量,当操作完后将备份

的对象返回出去;其实此时的对象AAAA已经改变了,但是只要我们操作的好 表面看来就符

合了后置加加的语法;

⚠️注意:返回类型不是判断函数重载的标准,而一元运算符重载常常会有很多函数名相同函数参数相同的重载函数

此时可以用占位符化解它们之间的矛盾;使他们构成重载;

代码实现

代码如下：

#include

using namespace std;

class test_YY {

private:

int a;

int b;

public:

test_YY(int a=0,int b=0){//对象的初始化

this->a = a;

this->b = b;

}

friend test_YY& operator++(test_YY& b);

friend test_YY& operator–(test_YY& b, int);//由于与前置–运算符不构成重载所以要用占位符

test_YY& operator–();

test_YY& operator++(int);

void print() {

cout << “a:” << a << " b:" << b << endl;

}

};

test_YY& operator++(test_YY& b) {//友元函数进行前置加加的运算符符重载;

b.a++;

b.b++;

return b;

}

test_YY& operator–(test_YY& b,int) {//友元函数进行后置减减运算符重载；

test_YY t = b;

b.a–;

b.b–;

return t;

}

test_YY& test_YY::operator++(int) {//成员函数进行后置加加运算；int是占位符

test_YY t = *this;

this->a++;

this->b++;

return t;

}

test_YY& test_YY::operator–() {//成员函数进行前置减减运算符的重载

this->a–;

this->b–;

return *this;

}

int main() {

test_YY a1(1, 2), a2(3, 4);

// --a1;//如果没有定义后置++函数这里就不可以写成a1–；如果写成就找不到相应的函数

//原来a1的成员变量是1,2经过前置减减后变为0,1;

test_YY t = a1++;

t.print();

a1.print();

// ++a2;//前置++前a2的成员变量是3,4进行前置++后成员变量变成4，5

test_YY t1 = a2–;

t1.print();

a2.print();

return 0;

}

四、流运算符与友元函数的密不可分

==================================================================================

在这里插入图片描述

代码实现

代码如下：

#include

using namespace std;

class test3 {

private:

int a;

int b;

public:

test3 (int a = 0, int b = 0) {

this->a = a;

this->b = b;

}

void print() {

cout << “a:” << a << “b:” << b << endl;

}

friend ostream& operator<<(ostream & out,test3& a);

friend ostream& operator>>(ostream& in, test3& a);

friend test3& operator+(test3& a, int b);

};

ostream& operator<<(ostream& out,test3& a) {//友元函数对左移操作符重载；

out << a.a << " ";//如果用成员函数对流操作符进行重载那么操作符的左边就必须变成对象

out << a.b <<" 哈哈，我在这里"<< endl;//因为默认的指针传进成员函数时总是在参数列表的

return out;//第一位;

}

test3& operator+(test3& a, int b) {

a.a = a.a + b;

a.b = a.b + b;

return a;

}

/*ostream& operator>>(ostream& in, test3& a) {//左移操作符重载,失败；

cin >> a.a;

cin >> a.b;

return in;

}*/

int main_FriendAndWeiyi() {

test3 a1(200, 700),a3;

test3 a2(300, 800),a4;

a4 = a4 + 3;

// a4 = 3 + a4; //····错误写法 运算符重载操作有一定的顺序性’+'号前面的是第一个参数

a4.print();//······这也是流操作符为什么只能用友元函数进行重载的原因;

cout << a4 ;

cout << a1<<a2;

// cin >> a3 >> a4;

return 0;

}

五、赋值运算符与成员函数的密不可分

===================================================================================

在这里插入图片描述

代码实现

代码如下：

#include

#include

using namespace std;

class qwe123 {

private:

int lenth;

char* Fhao;

public:

qwe123() {

cout << “我是构造函数,但我不会初始化” << endl;

}

qwe123(char a[]) {//赋值操作重载实际上是深拷贝

this->lenth = strlen(a)+1;

// this->Fhao = a;//错误写法在此没有给this->指向的空间开辟内存不能在下面delete；

this->Fhao = new char[this->lenth];//在堆区给this-》申请一块空间

strcpy_s(Fhao, lenth, a);//将a数组中的东西拷贝到Fhao数组内

}

void print() {

cout << this->Fhao << endl;

}

qwe123& operator=(qwe123 &a);

~qwe123() {//析构函数无论对象有无初始化,无论对象怎样初始化,创建了对象就一定会析构

//所以析构函数判断如何析构对象的标准应是每一个对象的特征；

if (this->Fhao != NULL) {//有初始化的对象析构方式;因为创建对象时手动申请了内存

delete[] this->Fhao;//所以就在析构时手动关闭;

this->lenth = 0;

cout << “这里是析构函数，over” << endl;

}

else {//没有初始化对象的析构方式

cout << “这里是没有被初始化的对象被析构了” << endl;

}

}

};

qwe123& qwe123::operator=(qwe123 &a) {//赋值操作符的重载与深拷贝原理相同

if (this->Fhao != NULL) {

delete [] Fhao;//delete之前要有空间,如果是系统自己分配的空间就不能用delete

this->lenth = 0;

}

this->lenth = strlen(a.Fhao) + 1;

this->Fhao = new char[this->lenth];

strcpy_s(Fhao,this->lenth,a.Fhao);

return *this;

}

int main() {

char pp[] = “I am big man”;

char dd[] = “I am very kkl”;

qwe123 a1(pp),a2(dd),a3;

a1.print();

a1 = a2;

a2.print();

return 0;

}

六、索引运算符与等号不等号运算符

==================================================================================

在这里插入图片描述

代码实现

代码如下：

//流运算符,赋值运算符,下标运算符，等号不等号运算符的重载

#include

using namespace std;

class MyClass

{

public:

MyClass(int a,int b);

MyClass(char a[]);

~MyClass();

friend ostream& operator<<(ostream &out, MyClass& a);

bool operator==(MyClass& a);

bool operator!=(MyClass& a);

char& operator[](int i);

MyClass& operator=(MyClass& a);

void print() {

cout << (*this)[4] << endl;//运行成功实例,这里的(*this)等效于一个对象;

cout << "哟西 " << this->p<<endl ;

}

void printp(MyClass& a) {

int i = 0;

i = strlen(a.p) + 1;

for (int j = 0;j < i;j++) {

cout << a[j] << " ";

}

}

private:

int a;

int b;

int len;

char* p;

};

MyClass::MyClass(char a[]) {

this->len = strlen(a)+1;

this->p = new char[this->len];

strcpy_s(this->p, this->len, a);

}

MyClass::MyClass(int a=0,int b=0)

{

this->a = a;

this->b = b;

}

MyClass::~MyClass()

{

if (this->p != NULL) {

delete[] p;

}

cout << “这里是析构函数,over，over” << endl;

}

ostream& operator<<(ostream &out,MyClass &a) {//重载了输出流操作符

out << a.a << “” << a.b << endl;

return out;

}

MyClass& MyClass::operator=(MyClass &a) {

if (this->p != NULL) {

delete[] p;

this->len = 0;

}

this->len = strlen(a.p) + 1;

this->p = new char[this->len];

strcpy_s(this->p, this->len, a.p);

return *this;

}

//等号与不等号均只拿类里面一个成员变量（len）展开来说；

bool MyClass::operator==(MyClass& a) {//等号操作符重载；

if (this->len == a.len) {

return true;

}

else return false;

}

bool MyClass::operator!=(MyClass& a) {//不等号操作符重载；

if (this->len != a.len) {

return true;

}

else return false;

}

char& MyClass::operator[](int i) {//调用方式：对象名[]//得到的东西可以经过操作设置,

//在这里得到的是字符数组里面的某个字符

//cout << “this ok”<<endl;这句话用于测试该函数有没有被调用；

return (this->p)[i];//this->p代表this对象里面的一个成员变量,在这里是一个字符数组

//并且在这里return 时调用了默认的[]操作函数

}

int main_HH() {

char aa[] = “I am big shuai” ;

char bb[] = “I am zhu zhi chong”;

char dd[] = “Shuai bi”;

MyClass a1(1, 2), a2(3, 4);

MyClass b1(aa), b2(bb),b3(dd);

cout << a1 << a2;

b1 = b2=b3;//经过这里赋值函数之后,b1,b2,b3的len均相等;

// b1.print();

// b1.printp(b1);

cout << b1[4] << endl;//成功将对象里面的字符拿出来,并调用了重载的[]函数

if (b1 == b2) {//b1b2相等调用了这里

cout << “等号函数，重载成功over” << endl;

}

if (b1 != a1) {//b1,.a1的len不相等所以这里也进行了输出

cout << “这里是不等号,over” << endl;

}

return 0;

}

七、小括号与逻辑运算符

=============================================================================

在这里插入图片描述

代码实现

代码如下：

#include

using namespace std;

class XLJ {

private:

int a;

int b;

public:

XLJ(int a=0, int b=0) {

this->a = a;

this->b = b;

cout << “这里是,构造” << endl;

}

void print() {

cout << “a:” << a << “b:” << b<<endl;

}

int operator()(int a, int b);

bool operator&&(XLJ& a) {//两个对象重的a都为0

if (this->a == 0 && a.a == 0) {

return true;

}

else {

return false;

}

}

bool operator||(XLJ& a) {//逻辑或只要两个对象里面有一个a是0就为真;

if (this->a == 0 || a.a == 0) {

return true;

}

else return false;

}

};

int XLJ::operator()(int a=0, int b=0) {

cout << “这里调用了，小括号运算符” << endl;

return a + b;

}

int main() {

XLJ a1(1, 2),a2,a3;//构造时调用的是构造函数;

a1.print();//构造出来对象后再用()就调用括号运算符

cout << a2(3,4) << endl;

cout << a1(1, 2) << endl;

if (a1 && a2) {

cout << “this cure &&” << endl;

}

if (a1 || a2) {

cout << “this || 运算” << endl;

}

if (a3 && a2) {

cout << “this && victor” << endl;

}

return 0;

}

八、不等号运算符重载

============================================================================

可以根据需求对大于小于运算符进行重载;

这样可以很直观的对比出来两个对象的某一特征,找出哪个更胜一筹;

成员函数语法 bool operator(类名 &对象名){函数体进行对象的某一特征进行比较};

友元函数语法 bool operator(类名 &对象名，类名 &对象名){函数体同上};

代码实现

代码如下：

//大于小于运算符重载

//判断条件运算符返回值一般就0,1两种;

//并且符合返回1,也就是真,因为调用的场景一般就是if语句:

//if语句中只有判断条件为真才会执行代码块里面的语句；

//如果if语句为真那么下面附属的else 语句将不再执行；

#define _CRT_SECURE_NO_WARNINGS

#include

using namespace std;

class MyClass1

{

public:

MyClass1(char* b);

~MyClass1();

bool operator<(MyClass1& a);

bool operator>(MyClass1& a);

bool operator<=(MyClass1& a);

bool operator>=(MyClass1& a);

private:

int a;

char* m_p;

};

img
img

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上C C++开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以戳这里获取

=

可以根据需求对大于小于运算符进行重载;

这样可以很直观的对比出来两个对象的某一特征,找出哪个更胜一筹;

成员函数语法 bool operator(类名 &对象名){函数体进行对象的某一特征进行比较};

友元函数语法 bool operator(类名 &对象名，类名 &对象名){函数体同上};

代码实现

代码如下：

//大于小于运算符重载

//判断条件运算符返回值一般就0,1两种;

//并且符合返回1,也就是真,因为调用的场景一般就是if语句:

//if语句中只有判断条件为真才会执行代码块里面的语句；

//如果if语句为真那么下面附属的else 语句将不再执行；

#define _CRT_SECURE_NO_WARNINGS

#include

using namespace std;

class MyClass1

{

public:

MyClass1(char* b);

~MyClass1();

bool operator<(MyClass1& a);

bool operator>(MyClass1& a);

bool operator<=(MyClass1& a);

bool operator>=(MyClass1& a);

private:

int a;

char* m_p;

};

[外链图片转存中…(img-j4KtlIMw-1715667748737)]
[外链图片转存中…(img-CQF4wNvJ-1715667748737)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上C C++开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以戳这里获取

2401_84978503
关注
  • 10
    点赞
  • 踩
  • 29
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C/C++常用关键字详解
dvlinker的技术专栏
08-03 9648
本文详细讲述了一些常用的或者有特殊用途的C/C++关键字。
一文详解 C++ 日志框架
青春不老，奋斗不止！
10-18 7454
日志框架 - 一个经过专门设计的实用程序，用于规范应用程序的日志记录过程。
如何封装.h和.a静态库使得头文件中不含有暴露内部实现的private成员变量
u010286868的博客
05-29 7742
参考：C++类怎么将一些成员的声明定义都放到cpp文件中 http://bbs.csdn.net/topics/350125990实现：分为四个文件： 最终需要交给别人的只有network.h和network.a，而network.a包含了network.cpp、networkImp.cpp和networkImp.h下面查看各个文件的内容：1. network.h(交给别人的头文件)cla
一文详解C++运算符重载【自己动手封装一个xxx.h库】
一个非常Cool的人
02-08 1214
介绍了常用的c++运算符重载,包括成员函数实现方式与友元函数实现方式,每一种方式都有代码作为示例,最后讲述了类的分文件实现,自己封装一个xxx.h库。喜欢的话留下点赞与关注吧。(^_−)☆
C++ 封装之运算符重载
jun8086的博客
10-31 300
C++语言预定义的运算符只能操作基础数据类型，对于用户自定义的类型，在进行运算时也需要类似的操作。对运算符（例如+、-、*、/）赋予新的运算方式。使对象的运算操作更加简洁明了；③无法改变运算符所需要的操作数。①无法改变运算符优先级。②无法改变运算符结构性。④无法创建新的运算符。
C++重载运算符
hong__fang的专栏
07-10 916
本文主要介绍：结构体中重载运算符、类重载运算符以及容器排序重载运算符。 1、结构体重载运算符typedef struct tagSaveImgFile { tagSaveImgFile &operator = (tagSaveImgFile &other) //放在结构体内部 { m_scale = other.m_scale; m_imgPath
C++ 运算符重载operator
daiyunxing0545的博客
11-22 146
//MyTime.h #ifndef MYTIME_H_ #define MYTIME_H_ class Time { private: int hours; int minutes; public: Time(); Time(int h, int m = 0); void AddMin(int m); void AddHr(int h); void Reset(int h = ...
一文详解C++字符编码的转换-综合文档
05-22
字符编码在计算机科学中是一个非常重要的概念，它决定了如何在计算机内部以及在不同系统之间存储、传输和处理文本数据。随着互联网的普及和全球化的推进，字符编码转换成为处理多种语言和文化信息的关键技术之一。...
一文全面掌握底层难点C和C++中的字节对齐（含C源码）
05-29
几种类型数据所占字节数 什么是对齐 自然对齐 规则对齐 实验对比 首先看这个结构体 ...#pragma pack()用法详解 例子 对齐的作用和原因 举个例子 什么时候需要进行内存对齐. 对齐的实现 总结
一文读懂c++11 Lambda表达式
01-19
1.简介 1.1定义 C++11新增了很多特性，Lambda表达式（Lambda expression）就是其中之一，很多语言都提供了 Lambda 表达式，如 Python，Java ，C#等。...以往C++需要传入一个函数的时候，必须事先进行声明，视情
Day31.C++05
xu_06161014的博客
06-14 131
Day31.C++05 001.加号运算符重载 #define _CRT_SECURE_NO_WARNINGS #include<iostream> using namespace std; class Person { public: Person() :m_A(1),m_B(1){} Person(int a,int b):m_A(a),m_B(b){} //+号运算符重载 成员函数 /*Person operator+(const Person& p) { P
封装C++文件（以“圆”这个项目为例子）
举子人间
07-18 269
要求：通过C++创建一个圆类（半径和圆心）然后输入一个点的坐标，判断出这个点在圆内、圆上、还是圆外。 #include<iostream> #include<string.h> #include "Circle.h" #include "Point.h" using namespace std; //点类 class Point { public: void setX(int x) { m_x = x; } int getX() { return m_x;
一元运算符重载
siwuxie095's blog
05-06 1220
-------------------siwuxie095                         在 C++ 中，运算符重载既是重点，也是难点    那么，什么是运算符重载呢？    所谓 运算符重载，就是给原有运算符赋予新的功能              如：原来的加号 + 是用来做数字相加操作的，但我们往往 会用加号 + 去
【C++】运算符重载 ④ ( 一元运算符重载 | 使用 全局函数 实现 前置 ++ 自增运算符重载 | 使用 全局函数 实现 前置 - - 自减运算符重载 )
最新发布
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
10-04 247
一、一元运算符重载 1、一元运算符列举 2、为下面的类实现运算符重载操作 3、使用 全局函数 实现 前置 ++ 自增运算符重载 4、使用 全局函数 实现 前置 - - 自减运算符重载 二、完整代码示例
C语言程序组成（.c文件和.h文件的编写规范）
CC的博客
07-08 4433
C语言程序组成（.c文件和.h文件的编写规范）
C++ 运算符重载详解
私房菜
01-17 1398
来源： http://blog.csdn.net/shift_wwx/article/details/79075543 前言： 上一篇博文 中已经将运算符重载的规则详细的列出来了，博文是转载的，写的也很详细。这一篇结合运算符总结一些例子，用于理解。 一、二元运算符 二元运算符需要两个参数，下面是二元运算符的实例。我们平常使用的加运算符（ + ）、减运算符（ - ）、乘
C++一元运算符重载
成长日记的博客
03-22 1942
运算符重载是给原有运算符赋予功能新的，实际上就是函数重载 一元运算符就是只对一个操作数运算 下面通过两个例子来说明 -（负号）的重载：1、友元函数重载 2、成员函数重载 ++符号的重载（++也是一元运算符）:3、前置++重载 4、后置++重载 关键字是：operator 1、友元函数重载 #include<iostream> using namespace ...
C++ sizeof运算符详解：类型字节计算与特点
sizeof是一个单目运算符，在C++中用于获取一个特定类型所占用的字节数，这对于理解内存管理和优化代码性能至关重要。该运算符的使用格式为`sizeof(<类型>)`，例如`sizeof(int)`会返回4，表示整型变量通常占4个字节。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值