C++核心编程之类和对象--C++运算符重载

最新推荐文章于 2024-07-16 18:00:34 发布
最新推荐文章于 2024-07-16 18:00:34 发布
阅读量190 收藏
点赞数
分类专栏： # C++核心编程 文章标签： c++ 算法 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hjl011006/article/details/134164331
版权

目录

一、运算符重载

二、加号运算符重载

三、左移运算符重载

将类中的成员设置为私有属性，将全局函数设置为友元访问类中的成员

四、递增运算符

五、赋值运算符重载

六、关系运算符重载

七、函数调用运算符重载

一、运算符重载

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

二、加号运算符重载

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

是自定义的一个函数作用，函数的名称替换成编译器统一提供的名字

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

函数名 替换成 ： operator+

总结注意：

  1. 对于内置的数据类型的表达式的运算符是不可能改变的
  2. 不可以滥用运算符重载

示例：

#include<iostream>

using namespace std;

// 加号运算符重载

class person {

public:

    // 1.成员函数重载

    person operator+(person& p)

    {

        person temp;

        temp.A = this->A + p.A;

        temp.B = this->B + p.B;

        return temp;

    }

int A;

int B;

};

// 2.全局函数重载+号

person operator+(person& p1, person& p2)

{

    // 全局函数的本质调用是：

    // person p3 = operator+(p1,p2);

    person temp1;

    temp1.A = p1.A + p2.A;

    temp1.B = p1.B + p2.B;

    return temp1;

}

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

person operator+(person& p1, int num)

{

    person temp1;

    temp1.A = p1.A + num;

    temp1.B = p1.B + num;

    return temp1;

}



void test01()

{

    person p1;

    p1.A = 10;

    p1.B = 10;

    person p2;

    p2.A = 10;

    p2.B = 10;



    // 成员函数的本质调用是

    person p3 = p1.operator+(p2);

    cout << "成员函数的运算符重载调用后：" << endl << "p3.A:" << p3.A << "\tp3.B:" << p3.B << endl;



    // 全局函数重载的本质调用

    person p4 = operator+(p1,p2);

    cout << "全局函数的运算符重载调用后：" << endl << "p4.A:" << p4.A << "\tp4.B:" << p4.B << endl;



    // 成员函数与全局函数都可以用以下方式直接相加

    //person p6 = p1 + p2;

    //cout << "p3的A的值：" << p3.A << endl << "p3的B的值：" << p3.B << endl;



    //函数重载

    person p5 = p1 + 5;

    cout << "函数重载完后p5的A的值：" << p5.A << endl << "p5的B的值：" << p5.B << endl;



}

int main()

{

    test01();

    return 0;

}

运行结果：

三、左移运算符重载

作用：可以实现输出自定义类型

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

示例：

#include<iostream>

using namespace std;

// 左移运算符重载

class person {

public:

    // 1.成员函数重载左移运算符

    // 利用成员函数重载  左移运算符  p.operator<<(cout)  简化版本是： p<<cout

    // 一般不利用成员函数重载左移运算符,因为无法实现cout在左侧

    // 实现的方式是p << cout

    int A;

    int B;

};

// 2.全局函数重载左移运算符

ostream& operator<<(ostream& cout, person& p)

{

    // ostream 是输出流

    cout << "A = " << p.A << endl << "B = " << p.B << endl;

    return cout;// 返回的还是输出流对象，为了能够链式编程

}

    // cout重载完再返回cout，在重载调用完后还可以继续输出

    // return cout 或者 out 都是可以的, 用引用的方式调用，out本质上是cout的一个别名

void test01()

{

    person p1;

    p1.A = 10;

    p1.B = 10;

    cout << p1 << "Hello World!" << endl;

}

int main()

{

    test01();

    return 0;

}

运行结果：

将类中的成员设置为私有属性，将全局函数设置为友元访问类中的成员

示例：

#include<iostream>

using namespace std;

// 左移运算符重载

class person {

    friend ostream& operator<<(ostream& cout, person& p);

public:

    person(int a,int b)

    {

        this->A = a;

        this->B = b;

    }

private:

    // 1.成员函数重载左移运算符

    // 利用成员函数重载  左移运算符  p.operator<<(cout)  简化版本是： p<<cout

    // 一般不利用成员函数重载左移运算符,因为无法实现cout在左侧

    // 实现的方式是p << cout

    int A;

    int B;

};

// 2.全局函数重载左移运算符

ostream& operator<<(ostream& cout, person& p)

{

    // ostream 是输出流

    cout << "A = " << p.A << endl << "B = " << p.B << endl;

    return cout;// 返回的还是输出流对象，为了能够链式编程

}

// cout重载完再返回cout，在重载调用完后还可以继续输出

// return cout 或者 out 都是可以的, 用引用的方式调用，out本质上是cout的一个别名

void test01()

{

    person p1(100,100);

    cout << p1 << "Hello World!" << endl;

}

int main()

{

    test01();

    return 0;

}

运行结果：

四、递增运算符

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

示例：

#include<iostream>

#include<math.h>

using namespace std;

// 重载递增运算符



// 自定义整形

class my_Integer {

    friend ostream& operator<< (ostream& cout, my_Integer myint);

public:

    my_Integer()

    {

        my_num = 0;

    }

    // 重置前置++运算符

    my_Integer& operator++()

    {

        my_num++; // 进行++

        return *this;  // 返回自身

        // 返回引用是为了一直对一个数进行操作

    }



    // 重置后置++运算符

    // 后置++不能返回引用是因为不能返回局部变量

    my_Integer  operator++(int) // int 代表是占位参数  可以用于区分  前置和后置递增

    {

        // 先记录

        my_Integer temp = *this;

        // 后递增

        my_num++;

        // 最后将记录的结果返回

        return temp;

    }

private:

    int my_num;

};



// 重载左移运算符

ostream& operator<< (ostream& cout, my_Integer myint)

{

    cout << myint.my_num;

    return cout;

}



// 前置++

void test01()

{

    my_Integer myint;

    cout << "myint1,前置++" << endl << "++(++myprint) = " << ++(++myint) << " myprint = " << myint << endl;

}



// 后置++

void test02()

{

    my_Integer myint2;

    cout << "myint2,后置++" << endl << "(myprint2++) = " << myint2++ << " myprint2 = " << myint2 << endl;

}



int main()

{

    int a = 10;

    cout << "后置++，先输出数据，再++" << endl;

    cout << a++ << endl;

    cout << a << endl;



    int b = 10;

    cout << "前置++，输出++结果" << endl;

    cout << ++b << endl;

    cout << b << endl;



    test01();

    test02();

    return 0;

}

运行结果：

 

五、赋值运算符重载

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

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

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

示例：

#include<iostream>

#include<math.h>

using namespace std;

// 重载赋值运算符

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)// 链式编程的思想，需要返回本身

    {

        // 编译器提供的是两个指针指向同一个地址，在堆区的内容释放的时候只能释放一次，而引起的深，浅拷贝的问题

        // m_age = p.m_age;

        // 编译器提供的是浅拷贝，导致拷贝得到的是堆区地址，堆区的空间只能释放一次，而浅拷贝导致释放两次

 

        // 应该先判断是否有属性在堆区，如果有先释放然后深拷贝

        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 p(18) ;

    cout<<"p的年龄："<<*p.m_age<<endl;

    person p1(20);

    cout<<"p1的年龄："<<*p1.m_age<<endl;

    person p2(10);

    cout<<"p2的年龄："<<*p2.m_age<<endl;

    cout<<"-------------------------------"<<endl;

 

    cout<<"重载完=后："<<endl;

    p2=p1=p; // 返回的是自身，可以连等

    cout<<"p的年龄："<<*p.m_age<<endl;

    cout<<"p1的年龄："<<*p1.m_age<<endl;

    cout<<"p2的年龄："<<*p2.m_age<<endl;

}

int main()

{

    test01();

    return 0;

}

运行结果：

 

六、关系运算符重载

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

示例：

#include<iostream>

#include<math.h>

using namespace std;

// 重载关系运算符

class person {

public:

    person(string name, int age)

    {

        this->name = name;

        this->age = age;

    }

    // 重载==号

    bool operator==(person& p)

    {

        if (this->name == p.name && this->age == p.age)

        {

            return true;

        }

        return false;

    }
    
    // 重载不等号



    bool operator!=(person &p)

    {

        if(this->name == p.name && this->age == p.age)

        {

            return false;

        }

        return true;

    }



    string name;

    int age;

};



void test01()

{

    person p("TOM", 18);

    cout << "p的姓名：" << p.name << " p的年龄：" << p.age << endl;



    person p1("TOM", 20);

    cout << "p1的姓名：" << p1.name << " p1的年龄：" << p1.age << endl;

    person p2("TOM", 18);

    cout << "p2的姓名：" << p2.name << " p2的年龄：" << p2.age << endl;



    cout << "比较p与p1-------------------------" << endl;

    cout << "重载==后的判断：" << endl;

    if (p == p1) {

        cout << "p和p1是相等的" << endl;

    }

    else {

        cout << "p和p1是不相等的" << endl;

    }



    cout << "重载!=后的判断：" << endl;

    if(p!=p1){

        cout<<"p和p1是不相等的"<<endl;

    }else{

        cout<<"p和p1是相等的"<<endl;

    }

    cout << "比较p与p2-------------------------" << endl;

    cout << "重载==后的判断：" << endl;

    if (p == p2) {

        cout << "p和p2是相等的" << endl;

    }

    else {

        cout << "p和p2是不相等的" << endl;

    }

}

int main()

{

    test01();

    return 0;

}

运行结果：

 

七、函数调用运算符重载

  •  函数调用运算符（）也可以重载
  •  重载后的使用方式与函数的调用十分相似，因此称为仿函数
  •  仿函数没有固定的写法，非常灵活

示例：

#include<iostream>

#include<math.h>

using namespace std;

// 函数调用运算符重载

class my_print{

public:

    // 重载函数调用运算符

    void operator()(string test)

    {

        cout<<test<<endl;

    }

};

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

 

void myprint02(string test)

{

    cout<<test<<endl;

}

 

// 一个加法的类

class myadd{

public:

    int operator()(int num1,int num2)

    {

        return num1+num2;

    }

};

 

 

void test01()

{

    my_print mprint;

    // 使用起来特别类似函数调用，因此称为仿函数

 

    mprint("hello 重载函数调用运算符");// 重载了()类似于函数

 

    myprint02("函数也可以直接放入字符串");

}

void test02()

{

    myadd myADD;

    int ret = myADD(10,20);

    cout<<"自定义加法类的仿函数结果:"<<ret<<endl;

 

    // 匿名函数对象 myadd(),使用完成后立即自动释放

    cout<<myadd()(100,100)<<endl;

}

int main()

{

    test01();

    test02();

    return 0;

}

运行结果：

 

CE贝多芬
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++实验报告实验七-运算符重载
03-14
编写程序熟悉运算符重载函数的定义和使用； （2）.编写程序熟悉重载单目和双目运算符的方法； （3）.编写程序熟悉流插入和提取运算符的重载； 二、实验要求 1、创建一个二维坐标点point的类别，该类别能够存放一个二...
对point类重载++和--运算符
06-03
对point类重载++和--运算符.................................................................................
C++之类和对象--赋值运算符重载和const成员函数
2301_80157147的博客
04-22 2604
主要讲解赋值运算符，const成员函数和取地址以及const取地址
C++编程语言中重载运算符（operator）介绍
热门推荐
liitdar的博客
06-11 20万+
operator是C++的一个关键字，它和运算符（如“=”）一起使用，表示一个运算符重载函数，在理解时可将operator和待重载的运算符整体（如“operator=”）视为一个函数名。使用operator重载运算符，是C++扩展运算符功能的方法。使重载后的运算符的使用方法与重载前一致；扩展运算符的功能只能通过函数的方式实现。（实际上，C++中各种“功能”都是通过函数实现的）
C++面向对象（OOP）编程-运算符重载
发狂的小花的博客
12-15 1050
本文主要介绍C++面向对象编程中的多态的手段之一运算符重载，讲清运算符重载的本质，以及通过代码实现一些常用的运算符重载。
C++ 面向对象 - 运算符重载与友元函数
代码不会敲的博客
06-09 3189
C++ 预定义的运算符的操作对象只能是基本数据类型，但是实际上许多用户自定义类型（例如类），也需要类似的运算符操作，C++ 可以通过运算符重载来满足这种需求。运算符重载本质就是函数重载，也是 C++ 多态的一种形式。同样 C++ 的封装性和数据隐藏性，只有类自身的函数才可以不受限制的访问类的非公有成员；任何非成员函数直接访问类中非公有数据成员会导致编译错误。于是针对这一情况 C++ 推出了友元函数。本实训我们就来学习运算符重载和友元函数的使用。第1关 复数运算 第2关 学生信息转换 第3关 矩阵运算....
[C++核心编程-08]----C++类和对象之运算符重载
一伦明悦的博客
05-12 930
在C++中，运算符重载是一种允许你重新定义标准操作符（如+、-、*、/等）的特性，以便它们适用于自定义的数据类型。这种功能使得你可以像操作内置类型一样自然地操作自定义类型的对象。运算符重载是面向对象编程的一个重要特性，它增强了代码的可读性和可维护性。运算符重载允许你对类的对象使用C++内置的运算符进行操作。例如，你可以重载+运算符来实现两个对象的相加，或者重载*运算符来实现对象的乘法操作。这样一来，你就可以像处理基本数据类型一样处理自定义的数据类型。
C++ 运算符重载
qq_27278957的博客
12-26 7万+
前言 本文引用于“C语言中文网”，我整理出来放在博客，方便大家共同学习。所有知识点和代码均已亲测可用，如有疑问，可提出，一起讨论学习。 本章内容： 1. C++运算符重载的概念和原理 2. C++重载=（C++重载赋值运算符） 3. C++深拷贝和浅拷贝（C++深复制和浅复制） 4. C++运算符重载为友元函数 5. C++实现可变长度的动态数组 6. C++重载&lt;&lt;和&gt;...
C++面向对象程序设计 - 运算符重载
觉醒法师的专栏
04-20 1346
函数重载就是对一个已有的函数赋予新的含义，使之实现新的功能。因此一个函数名就可以用来代表不同功能的函数，也就是一名多用。运算符也可以重载，即运算符重载（operator overloading）。运算符重载的方法是定义一个重载运算符的函数，在需要执行被重载的运算符时，系统就自动调用该函数，以实现相应的运算。运算符重载实质上是函数的重载。
头歌：C++ 面向对象 - 运算符重载与友元函数
qq_65628600的博客
06-16 7308
c++头歌作业
C++ 语言重载运算符 - 输入和输出运算符
既然选择了远方 便只顾风雨兼程 - 永强
08-29 4344
C++ 语言重载运算符 - 输入和输出运算符 IO 标准库分别使用 >> 和 << 执行输入和输出操作，IO 库定义了用其读写内置类型的版本，而类则需要自定义适合其对象的新版本以支持 IO 操作。 1. 重载输出运算符 << 通常情况下，输出运算符的第一个形参是一个非常量 std::ostream 对象的引用。std::ostream 是非常量，因为向流写入内容会改变其状态。该形参是引用，因为我们无法直接复制一个 std::ostream 对象。 第二个形参一般来说是一个
C++编程入门--矩阵类重载运算符
MARS_098的博客
11-04 1万+
题目：定义3×3矩阵类Matrix，在其中重载运算符“+”、“-”、“*”，实现矩阵的基本运算。 首先，我们先确定这个矩阵类的基本功能，我们来声明其成员函数的功能，列出来如下： #include<iostream> using namespace std; class Matrix{ //矩阵类 private: int row, column; /...
详解C++编程中的重载流插入运算符和流提取运算符
01-20
”和“>>”进行了重载，使之作为流插入运算符和流提取运算符，能用来输出和输入C++标准类型的数据。因此，凡是用“cout<<”和“cin>>”对标准类型数据进行输入输出的，都要用#include 把头文件包含到本程序...
C++课程作业：类定义、运算符重载、类模板
06-09
C++课程作业：类定义、运算符重载、类模板
C++重载运算符的规则详解
12-31
（1）C++不允许用户自己定义新的运算符，只能对已有的C++运算符进行重载。例如，有人觉得BASIC中用“* *”作为幂运算符很方便，也想在C++中将“* *”定义为幂运算符，用“3* *5”表示35，这是不行的。 （2）C++允许...
c++ primer plus 第16章string 类和标准模板库,string 类输入
zhyjhacker的博客
07-14 1095
c++ primer plus 第16章string 类和标准模板库,string 类输入。
c++ 生成随机字符串
m0_56306892的博客
07-15 215
以下是一个示例代码，它使用std::random_device和std::mt19937生成随机字符，并将结果存储在一个字符串中。std::uniform_int_distribution<> distribution(0, max_index - 1) 创建一个均匀分布，以确保生成的随机数在字符集的索引范围内。输出随机字符串: 在主函数中调用generateRandomString生成一个长度为1024的随机字符串，并输出结果。std::random_device rd 用于生成一个随机种子。
C语言 2个日期相关的函数
waterHBO的博客
07-15 152
读代码的过程中，遇到2个日期相关的工具函数， 记录一下。比较日期，计算日期间隔（天数)
C++ std::thread 管理线程生命周期：join 和 detach
最新发布
m0_59680769的博客
07-16 975
方法用于同步主线程和子线程。也就是说，当主线程调用子线程的join方法时，主线程会被阻塞，直到子线程完成其执行。这意味着join方法确保主线程等待子线程结束，然后继续执行后续代码。t.join()方法则是让子线程在后台独立运行，与主线程分离。分离后的线程（也称为“游离线程”）不能再被join，它的资源会在该线程完成后自动释放。主线程会继续执行而不会等待该子线程。如果把std::this_thread::sleep_for(std::chrono::seconds(3));
C++运算符重载实战：面向对象编程中的++运算符
此外，通过深入学习类和对象、继承、派生以及多态性，可以构建更复杂、可维护的软件系统。参考书籍包括吕凤翥的《C++语言基础教程》、张国峰的《C++语言及其程序设计教程》以及郑莉等编著的《C++语言程序设计》，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值