【C++】运算符重载

已于 2024-08-02 21:45:51 修改
阅读量297 收藏 3
点赞数 6
分类专栏： C++ 文章标签： c++ 开发语言 笔记 学习
于 2024-08-02 19:54:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_60546365/article/details/140829774
版权

目录

一、示例

二、operator

三、加减号重载

四、左移运算符重载 ( << )

五、递增运算符重载（++）

六、赋值运算符重载 （=）

七、关系运算符重载（> < = !=）

八、函数调用运算符重载

查漏补缺：

一、示例

如果我想实现以下代码，按照下面的写法是不能正常运行的。

class Person
{
public:

    int m_A;
    int m_B;
};

Person p1;
p1.m_A = 10;
p1.m_B = 10;

Person p2;
p2.m_A = 10;
p2.m_B = 10;

Person p3;
p3 = p1 + p2;

按照以上学过的内容，可以自己写成员函数，实现两个对象相加属性后返回新对象

Person add(Person &p)
{
    Person temp;
    temp.m_A = this -> m_A + p.m_A;
    temp.m_B = this -> m_B + p.m_B;
    return temp; //返回值会创建一个新的对象出来
}
二、operator

编译器起一个通用重载的名称：operator

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

注意：

①对于内置的数据类型的表达式的运算符是不可能改变的：int、float、double

②不要滥用运算符重载：把加法写成减法...

三、加减号重载

* 通过成员函数重载 + 号运算符

class Person
{
public:
    
    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;
    
};

void test()
{
    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 = p1 + p2;
}

* 通过全局函数重载 + 号运算符

class Person
{
public:

    int m_A;
    int m_B;
    
};

Person operator+ (Peerson &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;
}

void test()
{
    Person p1;
    p1.m_A = 10;
    p1.m_B = 10;

    Person p2;
    p2.m_A = 10;
    p2.m_B = 10;
    
    //原理：Person p3 = operator+ (p1,p2);
    //简化如下：
    Person p3 = p1 + p2;
}

* 运算符函数重载

class Person
{
public:

    int m_A;
    int m_B;
    
};

Person operator+ (Peerson &p1, int num)
{
    Person temp;
    temp.m_A = p1.m_A + num;
    temp.m_B = p1.m_B + num;
    return temp;
}

void test()
{
    Person p1;
    p1.m_A = 10;
    p1.m_B = 10;

    //原理：Person p3 = operator+ (p1,num);
    //简化如下：person + int
    Person p3 = p1 + 10 ;
}
四、左移运算符重载 ( << )

* 使得cout可以输出person类数据

class Person
{
    friend ostream & operator<<(ostream &cout,Person p)；

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

private:

    //利用成员函数来重写左移运算符
    //如果不知道该函数应该返回什么 可以先写一个void做测试
    //通常不会使用成员函数重载<<运算符，因为无法实现 cout在左侧 会出现 p << cout 的简化方式
    //void operator<<( cout )
    //{}
    
    int m_A;
    int m_B;
};

//只能利用全局函数重载左移运算符
//不清楚cout是什么类型，可以右键跳转定义
//ostream标准输出流对象，因为全局只有一个，所以需要用引用方式传过来
ostream & operator<<(ostream &cout,Person p) //本质：operator<< (cout,p) 简化形式：cout << p
{
    cout << "m_A = " << p.m_A << " m_B = " << p.m_B;
    return cout;
}

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

    //调用完返回cout就可以链式编程不断追加
    cout << p << endl;
}
五、递增运算符重载（++）

可以利用该方法写一个int数据类型

** 注意前置递增和后置递增的返回类型区别

class MyInt
{

    friend ostream& operator<<(ostream& cout,MyInt mint);

public:
    MyInt()
    {
        m_Num = 0;
    }

    //成员函数重载前置++运算符
    //返回引用不返回值，为了一直对一个数据进行递增操作，而非对一个新的数据进行操作
    MyInt& operator++()
    {
        //先进行++运算
        m_Num++;
        //再将自身作为返回
        return *this; //this指向自身，*将其解引用
    }

    //成员函数重载后置++运算符
    //int代表的是占位参数，用于区分前置和后置递增，只能写int其他不行
    //后置需要返回值，不能返回应用，因为temp是局部对象，返回引用是非法操作
    MyInt operator++(int)
    {
        //先返回结果（记录当时结果）
        MyInt temp = *this;
        //再进行递增
        m_Num++;
        //最后将结果返回
        return temp;
    }

private:
    int m_Num;

};

ostream& operator<<(ostream& cout,MyInt mint)
{
    cout << mint.m_Num;
    return cout;
}

void test()
{
    MyInt mint;
    cout << mint << endl; // 0
    cout << ++mint << endl; // 1
    cout << mint++ << endl; // 1
    cout << mint << endl; // 2
}
六、赋值运算符重载 （=）

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

①默认构造函数：无参，函数体为空

②默认析构函数：无参，函数体为空

③默认拷贝构造函数：对属性进行值拷贝

④赋值运算符operator=，对属性进行值拷贝

class Person
{
public:

    Person(int age)
    {
        m_Age = new int(age); //将age数据创建在堆区，并使用指针维护该数据
    }

    //堆区数据由程序员手动创建及释放
    ~Person()
    {
        if(m_Age != NULL)
        {
            delete m_Age;
            m_Age = NULL;
        }
    }

    int *m_Age;
};

void test()
{
    Person p1(18);
    Person p2(20);

    //该方法为浅拷贝 会出现p1p2重复释放 程序崩溃
    p2 = p1;
    //利用深拷贝解决该问题

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

    cout << "p2的年龄为：" << *p2.m_Age << endl;
}

** 重载赋值运算符

class Person
{
public:

    Person(int age)
    {
        m_Age = new int(age); //将age数据创建在堆区，并使用指针维护该数据
    }

    //重载赋值运算符
    Person& operator=(Person &p)
    {
        //编译器提供的是浅拷贝：m_Age = p.m_Age; 不可取
        //先判断是否有属性在堆区，如果有需要先释放干净，再深拷贝
        if(m_Age != NULL)
        {
            dekete m_Age;
            m_Age = NULL;
        }

        m_Age = new(*p.m_Age);
        return *this;
    }


    //堆区数据由程序员手动创建及释放
    ~Person()
    {
        if(m_Age != NULL)
        {
            delete m_Age;
            m_Age = NULL;
        }
    }

    int *m_Age;
};

void test()
{
    Person p1(18);
    Person p2(20);
    Person p3(30);
   
    cout << "p1的年龄为：" << *p1.m_Age << endl;

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

    cout << "p3的年龄为：" << *p3.m_Age << endl;
}
七、关系运算符重载（> < = !=）

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

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.Age)
        {
            return true;
        }
            return false;
    }

    //重载关系运算符！=号
    bool operator==(Person &p)
    {
        if(this->m_Name == p.m_Name && this->m_Age == p.Age)
        {
            return false;
        }
            return true;
    }

    string m_Name;
    int m_Age;
    
};

void test()
{
    Person p1("Tom", 18);
    Person p2("Tom", 18);

    if(p1 == p2)
    {
        cout << "p1和p2是相等的" << endl;
    }
    else
    {
        cout << "p1和p2是不相等的" << endl;
    }
    
}
八、函数调用运算符重载

①函数调用运算符（）可以重载

②由于重载后使用的方法像函数的调用，故称为仿函数

③仿函数没有固定写法

class MyPrint
{
public:

    void operator()(string text)
    {
        cout << text << endl;
    }

};

void test01()
{
    //重载（）操作符，仿函数
    MyPrint myFunc;
    myFunc(“hello!”);
}

class MyAdd
{
public:

    int operator()(int num1, int num2)
    {
       return num1 + num2;
    }
};

void test02()
{
    MyAdd myadd;
    int ret = myadd(1,2);
    cout << "ret=" << ret << endl;

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

查漏补缺：

函数重载和函数重写的区别：https://blog.csdn.net/inter_peng/article/details/53940179

递增运算符复习：

int a = 10;
cout << ++a << endl; // 11
cout << a << endl; //11

int b = 10;
cout << b++ << endl; //10
cout << b << endl; //11

new关键字使用方法：https://blog.csdn.net/qq_15345177/article/details/88066050

XYN61
关注
  • 6
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++运算符重载规则详解
09-03
C++运算符重载是语言特性之一，允许程序员为已存在的运算符赋予新的含义，以适应自定义数据类型的运算需求。然而，运算符重载并不是无限制的，它遵循一些特定的规则，以确保代码的清晰性和正确性。 首先，C++中大...
C++运算符重载课件
09-17
中国农业大学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++运算符重载详解
qq_52905520的博客
10-06 3万+
C++运算符重载详解
C++运算符重载
m0_58495729的博客
10-22 816
C++学习路径之运算符重载
c++运算符重载
weixin_43821215的博客
03-21 2150
文章目录前言一、重载二元运算符1. 作为成员函数的二元重载运算符2.作为非成员函数的二元重载运算符二、重载一元运算符1.作为成员函数的一元重载运算符2.作为非成员函数的一元重载运算符3、重载一元前置与后置运算符：++和- -1. 重载前置的自增运算符2. 重载后置的自增运算符三、运算符作为成员函数和非成员函数的比较 前言 提示：这里可以添加本文要记录的大概内容： 运算符重载不是自动的，必须定义运算符重载函数来描述所需要的功能。通过像往常那样编写非static成员函数定义或者非成员函数定义就可以实现运算符重
c++ 运算符重载
物联黄同学的博客
09-26 3082
前言 本篇内容参考了b站up主黑马程序员的视频，这是链接https://www.bilibili.com/video/BV1et411b73Z?p=126 什么是运算符重载？ 运算符重载类似于函数重载，回顾函数重载，我们会发现，发生函数重载使得同名函数具有不同的应用，运算符重载也是如此，针对不同的对象，运算符重载可以有不同的应用。但是，我们在做运算符重载时并不是扩大一个运算符的功能，而是扩大它应用的范围。 运算符重载的应用场景 运算符重载常用于对类或者结构体的运算符操作，例如，一个类有几个int属性，然
C++ 运算符重载：C++ 运算符重载的高级技巧和最佳实践
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
04-03 833
【C++运算符重载】C++ 运算符重载：详解与实现
c++运算符重载详解
weixin_55939638的博客
05-20 599
C++中的运算符重载是一种特殊的函数，它允许我们自定义运算符在您自己的类中的行为。这样，您就可以为您的类添加新的功能，使其更方便、更易于使用。例如，假设您有一个名为“Point”的类，它表示二维平面中的一个点。其中“运算符”可以是任何有效的运算符（例如“+”、“-”、“*”、“/”等），而“参数”则是运算符操作的类对象。通过运算符重载，您可以为您的类添加更自然、更直观的操作方式，使其更符合人类直观的思维习惯。通过运算符重载，您可以为您的类添加特定的操作，从而在不同的应用程序中重用代码。
C++运算符重载总结
wo_ai_luo_的博客
11-10 1226
一定要自定义一个拷贝构造函数，这样在重载运算符返回对象副本的时候，编译器会自动调用拷贝构造函数，否则会出现结果错误。把‘=’运算符重载为类成员变量，并且将返回值设计成为该类的引用。除了‘=’运算符以外，其他的运算符重载最好设计成为友元函数。这就是我们今天要讲的运算符重载的总结.友元关系不会被派生类继承。
【C++ | 重载运算符】一文弄懂C++运算符重载，怎样声明、定义运算符，重载为友元函数
最新发布
wkd_007的博客
06-21 2189
👉本文主要介绍了为什么需要重载运算符，重载运算符有哪些限制，怎样声明、定义运算符函数，怎样将运算符重载为友元函数。
c++运算符重载基础知识详解
09-04
C++运算符重载是编程中一个重要的概念，它允许我们为已有的运算符赋予新的含义，使得在处理自定义数据类型时，代码更加直观和简洁。在C++中，运算符重载并不是创建新的运算符，而是为已有的运算符提供不同的实现方式...
C++运算符重载三种形式1
08-08
C++运算符重载是C++中一个强大的特性，它允许程序员为自定义类型定义运算符的行为。在C++中，运算符重载有三种主要形式：成员函数、友元函数以及普通函数。每种形式都有其特定的使用场景和优缺点。 1. 成员函数重载...
C++运算符重载的思维导图
03-26
运算符重载 、运算符重载规则 1.重载运算符的限制 2.运算符重载的语法形 式 、用成员或友元函数重载运算符 1.一元运算符2.二元运算符 3.用成员函数重载运算符 4.用友元函数重载 条件 ②例子 ③注意 5.讨论 6.总结 三...
C++运算符重载的方法详细解析
09-04
在C++中，运算符重载是一种特性，允许程序员为已有的运算符赋予新的含义，以便在自定义数据类型上使用。运算符重载不是创建新的运算符，而是为现有运算符提供不同的实现方式，使其能适配自定义类型的运算需求。通过...
c++运算符重载，重载运算符
01-04
### C++运算符重载详解 #### 一、前言 C++允许用户自定义类或结构体，并为这些类型重载内置运算符，从而使得这些类型能够像内置类型一样使用标准运算符进行操作。本篇文章将通过三个具体的示例来深入探讨C++中的...
C++运算符重载友元函数实例
08-17
在给定的实例中，你将学习如何实际应用这些概念，通过成员函数和非成员函数重载C++运算符，以及如何使用友元函数来实现特定的运算行为。通过练习和理解这些例子，你将更好地掌握C++中运算符重载和友元函数的使用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值