C++ 09 类与对象(运算符重载)

已于 2023-03-21 16:46:14 修改
阅读量529 收藏
点赞数
分类专栏： C++ 文章标签： c++ 开发语言 算法
于 2023-03-21 11:31:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/peng_258/article/details/129684858
版权
本文详细介绍了C++中的运算符重载，包括加号运算符、左移运算符、递增运算符、赋值运算符以及关系运算符的重载。通过实例展示了如何通过成员函数和全局函数来实现运算符重载，并讨论了浅拷贝和深拷贝的概念。此外，还提到了函数调用运算符的重载，即仿函数的使用。
摘要由CSDN通过智能技术生成

目录

一、运算符重载简介

二、加号运算符重载

2.1 通过成员函数，可以实现两个对象相加属性后返回给新的对象

 2.2 通过全局函数，可以实现两个对象相加属性后返回给新的对象

三、左移运算符重载

四、递增运算符

五、赋值运算符

六、关系重载运算符

七、函数调用运算符重载

一、运算符重载简介

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

注意：

对于内置的数据类型(int)的表达式的运算符是不可能改变的；

不要滥用运算符重载(+号当-号用)；如：

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

二、加号运算符重载

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

② 对于内置的数据类型, 编译器知道如何运算 

 对于两个person类型的对象，是不可以实现相加运算的：

2.1 通过成员函数，可以实现两个对象相加属性后返回给新的对象

PersonAddPerson是一个成员函数，this->m_A是当前类中的成员变量m_A

 编译器给PersonAddPerson起了一个名字：operator+

 2.2 通过全局函数，可以实现两个对象相加属性后返回给新的对象

#include <iostream>
using namespace std;

//加号运算符重载
class Person
{
public:

    //1、成员函数重载+号
    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;
};

/*
//全局函数重载+号
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.operator+(p2);
    
    //全局函数重载本质调用 
    //Person p3 = operator+(p1,p2);
    
    Person p3 = p1 + p2; //重载本质被简化后的形式

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

    Person p4 = p1 + 10; //Person + int

    cout << "p3.m_A：" << p3.m_A << endl;
    cout << "p3.m_B：" << p3.m_B << endl;

    cout << "p4.m_A：" << p4.m_A << endl;
    cout << "p4.m_B：" << p4.m_B << endl;

}


int main()
{
    test01();

    system("pause");

    return 0;

}

运行结果：

p3.m_A：20
p3.m_B：20
p4.m_A：20
p4.m_B：20
请按任意键继续. . .

三、左移运算符重载

① 左移运算符重载：可以输出自定义数据类型。

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

左移运算符cout输出：

对于对象p，是不能直接输出其属性的：

#include <iostream>
using namespace std;

//左移运算符
class Person
{

    friend ostream& operator<<(ostream& out, Person& p);	

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

    /*
    //利用成员函数重载 左移运算符  p.operator<<(cout) 简化版本 p << cout
    //成员函数不能利用重载<<运算符，因为无法实现cout在左侧
    //当不知道返回值是什么类型的时候，可以先写个void，以后再改
    void operator<<(Person& p)
    {
        
    }
    */
    
private:
    int m_A;
    int m_B;
};

//只能利用全局函数重载左移运算符
//如果返回类型为void，那么就无法无限追加，也没有办法在后面添加换行符
ostream & operator<<(ostream &cout, Person &p) //本质 operator << (cout , p) , 简化 cout << p
                                               //cout是别名，这里可以取out、kn...
                                               //cout为ostream输出流数据类型                                                    
{
    cout << "m_A= " << p.m_A << " m_B=" << p.m_B;
    return cout;
}

void test01()
{
    Person p(10,10);

    cout << p << " hello world" << endl;
}


int main()
{
    test01();

    system("pause");

    return 0;

}

运行结果：

m_A= 10 m_B=10 hello world
请按任意键继续. . .

四、递增运算符

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

② 前置递增返回的是引用，后置递增返回的是值。

#include <iostream>
using namespace std;

//重载递增运算符

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

public:
    MyInteger()
    {
        m_Num = 0;
    }
    
    //重载前置++运算符,返回引用是为了一直对一个数据进行递增操作,而返回值并不是一直对一个数据进行递增操作                    
    MyInteger& operator++()
    {
        //先进行++运算
        m_Num++;

        //再将自身做一个返回
        return *this;  //把自身做一个返回
    }

    //重载后置++运算符 int代表占位参数，可以用于区分前置和后置递增
    //后置递增不能返回引用，因为temp是局部变量，如果返回temp，当程序运行完后变量就释放了，再调用temp就是非法操作了           
    MyInteger operator++(int)
    {
        //先记录当时结果
        MyInteger temp = *this;
        //后 递增
        m_Num++;
        //最后将记录结果做返回
        return temp;
    }
private:
    int m_Num;
};

//只能利用全局函数重载左移运算符
ostream & operator<<(ostream &cout, MyInteger myint) //本质 operator << (cout , p) , 简化 cout << p
                                                     //cout是别名，这里可以取out、kn...
                                                     //cout为ostream输出流数据类型                                               
{
    cout << myint.m_Num;

    return cout;
}

void test01()
{
    MyInteger myint;

    cout << ++(++myint) << endl;
    cout << myint << endl;
}

void test02()
{
    MyInteger myint;

    cout << myint++ << endl;
    cout << myint   << endl;

}

int main()
{
    test01();
    test02();

    /*
    int a = 0;
    cout << ++(++a) << endl; //运行结果为2
    cout << a << endl;       //运行结果为2，表示一直对一个数据进行递增
    */

    system("pause");

    return 0;

}

运行结果：

2
2
0
1
请按任意键继续. . .

五、赋值运算符

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

  1. 默认构造函数(无参，函数体为空)
  2. 默认析构函数(无参，函数体为空)
  3. 默认拷贝构造函数，对属性进行值拷贝
  4. 赋值运算符operator=，对属性进行值拷贝                                                                                   
    void operator=(Person& p)
    {
        //编译器默认是提供浅拷贝
        //m_Age = p.m_Age;

        //浅拷贝带来的问题是，当创建数据在堆区时，析构代码导致内存重复释放，报错

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

#include <iostream>
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;

        //浅拷贝带来的问题是，当创建数据在堆区时，析构代码导致内存重复释放，报错
    
        //应该先判断是否有属性在堆区，如果有先释放干净，然后再深拷贝
        //p2 = p1;  p2的先释放掉，然后重新开辟新的堆区
        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);

    Person p3(23);

    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;

}

运行结果：

p1的年龄为：18
p2的年龄为：18
p3的年龄为：18
请按任意键继续. . .

六、关系重载运算符

#include <iostream>
using namespace std;
#include<string>

//重载关系运算符

class Person
{
public:
    Person(string name, int age)
    {
        m_Name = name;
        m_Age = age;
    }

    //重载 == 号
    bool operator==(Person& p)
    {
        if (this->m_Name == p.m_Name && this->m_Age == p.m_Age)
        {
            return true;
        }
        return false;
    }

    bool operator!=(Person& p)
    {
        if (this->m_Name != p.m_Name && this->m_Age != p.m_Age)
        {
            return true;
        }
        return false;
    }

    string m_Name;
    int m_Age;
};

void test01()
{
    Person p1("Tom", 17);

    Person p2("Jerry", 18);

    if (p1 == p2)
    {
        cout << "p1和p2是相等的！" << endl;
    }
    else
    {
        cout << "p1和p2是不相等的！" << endl;

    }

    if (p1 != p2)
    {
        cout << "p1和p2是不相等的！" << endl;
    }
    else
    {
        cout << "p1和p2是相等的！" << endl;

    }


}

int main()
{
    test01();
    
    system("pause");

    return 0;

}


运行结果：

p1和p2是不相等的！
p1和p2是不相等的！
请按任意键继续. . .

七、函数调用运算符重载

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

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

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

#include <iostream>
using namespace std;
#include<string>

//函数调用运算符重载

//打印输出类
class MyPrint
{
public:

    //重载函数调用运算符
    void operator()(string test)
    {
        cout << test << endl;
    }

};

//正常函数
void MyPrint02(string test)
{
    cout << test << endl;
}

void test01()
{
    MyPrint myPrint;

    myPrint("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;

    //匿名函数对象
    cout << MyAdd()(100, 100) << endl;

    // MyAdd()为创建一个匿名对象，匿名对象的特点为当前行执行完立即释放
}

int main()
{
    test01();

    MyPrint02("hello world"); //由于使用起来非常类似于函数调用，因此称为仿函数

    test02();

    system("pause");

    return 0;

}

运行结果：

hello world
hello world
ret = 200
200
请按任意键继续. . .

Darren214
关注
专栏目录
C++操作题-设计一个Time类实现两个时间相加
编程小鹏的博客
04-08 3066
【问题描述】定义了一个以hours, minutes和seconds作为数据成员的Time类。设计了成员函数将两个Time对象相加（即时间相加），并进行相应的检查，查看增加的分钟数及秒数是否大于59。如果秒数大于59，则分钟数向前递增1。类似地，如果分钟数大于59，则小时数向前增1。 【输入形式】输入两个由时、分、秒构成的时间。 【输出形式】输出输入的两个时间相加后的时间 【样例输入】 2 34 45 1 47 56 【样例输出】 the result is:4:22:41 【样例输入】 2 67 1
C++类和对象——运算符重载
weixin_47207479的博客
11-13 434
C++ 各种运算符的重载
类和对象-C++运算符重载
lyxawdn的博客
03-16 1334
运算符重载概念：对已有的运算符重新定义，赋予其另一种功能，以适应不同的数据类型。 一、加号运算符重载 编译器本身掌握了1+1=2、 2+2=4之类的运算（内置数据类型），但当两个自定义的数据类型需要进行相加运算时，编译器不知道怎么处理。 我们当然可以通过函数来实现自定义数据类型的相加 class Person { public: int m_A; int m_B; }; Person p1; p1.m_A = 10; p2.m_B = 10; Person p2; p2.m_A = 10; p2.m_B
C++类与对象笔记十二：运算符重载一：加号运算符重载
xiaoyaolangwj的博客
01-14 845
运算符重载概念：对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型。自定义数据类型相加。 对加号运算符的重载：两种情况： 成员函数实现加号运算符重载 全局函数实现加号运算符重载 通过成员函数来实现，那么必须依托于实例对象来调用。 而基于全局函数，则不用考虑实例调用的情况。因此，传入的参数个数不同。 返回值类型：两个对象相加属性后，返回一个新的对象。因为加号可以不断往后累加，所以符合链式编程的规则，所以返回值与传入类型相同。 成员函数的加号运算符重载 我们可以自己...
类和对象常见题目解法
qq_54717101的博客
10-27 392
求1+2+3+...+n、计算一年的第几天、日期差值、打印日期、日期累加
C++实践分数类中运算符重载的方法参考
01-21
【项目-分数类中的运算符重载】 （1）实现分数类中的运算符重载，在分数类中可以完成分数的加减乘除（运算后再化简）、比较（6种关系）的运算。 class CFraction { private: int nume; // 分子 int deno; // ...
P121~126C++类和对象C++运算符重载学习笔记.docx
04-13
C++运算符重载学习笔记 C++类和对象是面向对象编程的基础概念。运算符重载是C++中的一种重要机制，允许开发者重新定义已有的运算符，赋予其新的功能，以适应不同的数据类型。在本文中，我们将详细介绍C++运算符重载...
详解C++编程中的单目运算符重载与双目运算符重载
01-20
C++单目运算符重载 单目运算符只有一个操作数，如!a，-b，&c，*p，还有最常用的++i和–i等。重载单目运算符的方法与重载双目运算符的方法是类似的。但由于单目运算符只有一个操作数，因此运算符重载函数只有一个参数...
c++本科作业 矩阵运算 运算符重载
04-09
For this task, put your code in the following files: Matrix.cpp, Matrix.h. You are to write a class Matrix which includes appropriate fields associated with 2*2 matrices. A 2*2 matrix takes the ...
类和对象-常见OJ题
m0_73470633的博客
02-29 857
思路：可先用一个数组将天数先存起来（可以先按照平年计算），然后再判断日期是否为3月以上，因为只有这时才需要去判断是否为闰年，如果是3月以上并且是闰年，那需要在总天数上加1即可！思路：大体思路就是，先将天数加到“日”上，判断是否符合大于月份的天数，如果大于，那就月向上加；思路：相对简单，只需要去判断输入的天数是否符号当前月的天数即可，如果大于，那就月向上加！有两个日期，求两个日期之间的天数，如果两个日期是连续的我们规定他们之间的天数为两天。但是呢，这里有个问题就是，我们每次加上的数都比上一个数大，就是。
c++类与对象实现字符串相加（深拷贝函数）（定义一个MyString类，实现两个字符串相加。）
Kerryliuyue的博客
04-24 2501
#定义一个MyString类，实现两个字符串相加。要求定义类的数据成员为字 符指针，实现深拷贝函数。 要求：不能使用<string>,可以使用<cstring> include<iostream> #include<cstring> using namespace std; class MyString {public: MyString(); ...
【C++】类与对象（日期计算器）
最新发布
qinjh_的博客
03-04 1317
声明流插入时，应在类外面声明，不然this指针会占据第一个形参，Date就只能是左操作数了，打印时就会变成。在类外面声明时，为了不把private打开，可以进行友元声明，就可以在不打开private的情况下，访问private。上方实现时，有日期+天数和日期+=天数。二者实现其中一个即可复用另一个。但是要先实现哪一个更好呢？
C++ 操作符重载(1) 时间相加
alex1997222的博客
11-17 2851
重载操作符的目的:的  C++中预定义的运算符的操作对象仅限于基本的内置数据类型  大多时候我们需要对我们的类似类型进行类似运算,这个时候我们需要对运算符进行重新定义,赋予其新内容  赋予其新的功能,以满足自身的需求  运算符重载的实质就是函数重载或函数多态。运算符重载是一种形式的C++多态。目的在于让人能够用同名的函数来完成不同的基本操作。    基本格式如下: operator
C++：类与对象4
Breathmetoyou的博客
12-01 648
运算符重载 即：对已有的运算符（加减乘除等号）重新定义，赋予另一种功能，以适应不同的数据类型 1、加号运算符 - 实现两个自定义类型的相加
c++后置递增运算符重载为什么不能传引用
Sx_WWj的博客
02-14 671
C++后置递增运算符重载为什么不能传递引用
有关C++中类加法的两种方式
qq_41126898的博客
03-13 3130
众所周知，C++允许使用操作符重载，从而使类与类、类与常量直接相加，简化写法。 而操作符重载跟使用的顺序有关，并不是那么简单的，比如a是一个类，如果你只定义了成员操作符重载函数，则写成a+1没有问题，写成1+a就会报错了，这个问题有两种解决方式： 1.使用类的 构造转换函数 假设我们定义了一个Complex类 class Complex { private: int rel;//实部 int img;//虚部 public: Complex(int n):rel(n),img(0){}//构造转换函
C++学习笔记5
qq_50299271的博客
10-13 946
C++学习笔记
C++学习第八十七篇
huaming_wang的博客
12-06 104
/* * 运算符重载：对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型 * 加号运算符重载 * 左移运算符重载 * 递增运算符重载 * 赋值运算符重载 * 关系运算符重载 * 函数调用运算符重载 * 注意：对于内置的数据类型表达式的运算符是不可能修改的（如1+1） * 不要滥用运算符重载 */ #include<iostream> #include<string> using namespace std; class Person { public:.
C++复数类实现与运算符重载
在C++中，运算符重载是面向对象特性的一种体现，它允许程序员为已有的运算符赋予新的含义，以便在自定义类型（如类）上使用这些运算符。这个实验报告的核心是设计一个复数类（MyComplex），并重载常见的数学运算符...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值