类与对象中的运算符重载

最新推荐文章于 2024-05-28 16:55:44 发布
最新推荐文章于 2024-05-28 16:55:44 发布
阅读量110 收藏
点赞数 1
分类专栏： C++学习 文章标签： c++ 数据结构 Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73648729/article/details/128979797
版权

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

  1. 加号运算符重载

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

成员函数重载：

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 test01()
{
    Person p1;
    p1.m_A = 10;
    p1.m_B = 10;
    Person p2;
    p2.m_A = 10;
    p2.m_B = 10;

    Person p3 = p1 + p2;

    cout << "p3.m_A=" << p3.m_A << endl;
    cout << "p3.m_B=" << p3.m_B << endl;
}
int main()
{
    test01();
    return 0;
}
成员函数本质调用
Person p3=p1.operator+(p2);

全局函数重载：

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

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 + p2;

    cout << "p3.m_A=" << p3.m_A << endl;
    cout << "p3.m_B=" << p3.m_B << endl;
}
int main()
{
    test01();
    return 0;
}
全局函数本质调用
Person p3=operator+(p1,p2);

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

class Person
{
public:
    int m_A;
    int m_B;
};

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 p3 = p1 + 20;

    cout << "p3.m_A=" << p3.m_A << endl;
    cout << "p3.m_B=" << p3.m_B << endl;
}
int main()
{
    test01();
    return 0;
}

注意：1.对于内置的是数据类型的表达式的运算符是不可能改变的

2.不要滥用运算符重载

2.左移运算符重载

作用：可以输出自定义数据类型

通常不会利用成员函数重载左移运算符，因为cout只能在右边

class Person
{
public:
    int m_A;
    int m_B;
};
void operator<<(ostream &cout, Person p)  //本质 operator <<(cout,p)  简化 cout<<p
{
    cout << "m_A=" << p.m_A << " m_B=" << p.m_B << endl;
}
void test01()
{
    Person p1;
    p1.m_A = 10;
    p1.m_B = 10;

    cout << p1;
}
int main()
{
    test01();
    return 0;
}

上述代码的17行如果改成 cout<<p<<endl; 编译器就会报错，需要将代码改进：

class Person
{
public:
    int m_A;
    int m_B;
};
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 test01()
{
    Person p1;
    p1.m_A = 10;
    p1.m_B = 10;

    cout << p1 << endl;
}
int main()
{
    test01();
    return 0;
}

3.递增运算符重载

作用：通过重载递增运算符，实现自己的整形数据

前置++

//自定义整形
class MyInteger
{
    friend ostream& operator<<(ostream& cout, MyInteger myint);
public:
    MyInteger()
    {
        m_Num = 0;
    }

    //重载前置++运算符
    MyInteger& operator++()
    {
        //先进行++运算
        m_Num++;
        //再将自身做返回
        return *this;
    }

private:
    int m_Num;
};

//重载左移运算符
//注意要以引用的方式（&）目的是对一个数据进行递增操作
ostream& operator<<(ostream& cout, MyInteger myint)
{
    cout << myint.m_Num;
    return cout;
}

void test01()
{
    MyInteger myint;
    cout << ++(++myint) << endl;
}

int main()
{
    test01();
    return 0;
}

后置++

//自定义整形
class MyInteger
{
    friend ostream& operator<<(ostream& cout, MyInteger myint);
public:
    MyInteger()
    {
        m_Num = 0;
    }

    //重载后置++运算符
    //void operator++(int)  int代表占位参数，可以用于区分前置和后置递增
    //不能以引用的方式返回，局部变量出了作用域会被销毁
    MyInteger operator++(int)
    {
        //先记录当时结果
        MyInteger temp = *this;
        //后递增
        m_Num++;
        //最后将记录返回
        return temp;
    }

private:
    int m_Num;
};

//重载左移运算符
//注意要以引用的方式（&）目的是对一个数据进行递增操作
ostream& operator<<(ostream& cout, MyInteger myint)
{
    cout << myint.m_Num;
    return cout;
}

void test02()
{
    MyInteger myint;
    cout << myint++ << endl;
    cout << myint << endl;
}
int main()
{
    test02();
    return 0;
}

总结：前置递增返回的是引用，后置递增返回值

4.赋值运算符重载

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

  • 默认构造函数（无参，函数体为空）

  • 默认析构函数（无参，函数体为空）

  • 默认拷贝构造函数，对属性进行值拷贝

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

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

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 p1(18);
    Person p2(20);
    Person p3(30);

    p3 = p2 = p1;  //赋值操作 

    cout << "p1的年龄为:" << *p1.m_Age << endl;
    cout << "p2的年龄为:" << *p2.m_Age << endl;
    cout << "p3的年龄为:" << *p3.m_Age << endl;
}
int main()
{
    test01();
    return 0;
}

5.关系运算符重载

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

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;
        }
        else
        {
            return false;
        }
    }
    //重载 ！=
    bool operator !=(Person& p)
    {
        if (this->m_Name != p.m_Name || this->m_Age != p.m_Age)
        {
            return true;
        }
        else
        {
            return false;
        }
    }
    string m_Name;
    string m_Age;
};
void test01()
{
    Person p1("Tom", 18);
    Person p2("Tom", 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();
    return 0;
}

6.函数调用运算符重载

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

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

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

示例1：

//打印输出类
class MyPrint
{
public:
    //重载函数调用运算符
    void operator()(string test)
    {
        cout << test << endl;
    }
};
void test01()
{
    MyPrint myPrint;
    myPrint("hello world");//由于使用起来非常类似于函数调用，因此称为仿函数
}
int main()
{
    test01();
    return 0;
}

示例2：

//加法类
class MyAdd
{
public:
    int operator()(int num1, int num2)
    {
        return num1 + num2;
    }

};

void test01()
{
    MyAdd myadd;
    int ret = myadd(100, 100);
    cout << "ret= " << ret << endl;

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

int main()
{
    test01();
    return 0;
}

夏微凉.
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
类中运算符重载
qq_24503095的博客
11-23 5037
运算符重载 运算符重载时一种形式的C++多态 1、运算符重载的格式： operator op(parameter-list); 其中，op必须时有效的C++运算符。 2、调用方式 obj = obj1 + obj2; obj = obj1.operator+(obj2); 在运算符表示法中，运算符左侧的对象是调用对象，运算符右侧的是作为参数被传递的对象。 3、重载限制 至少有一个操作上是用户定...
C++实践分数类中运算符重载的方法参考
01-21
【项目-分数类中的运算符重载】 （1）实现分数类中的运算符重载，在分数类中可以完成分数的加减乘除（运算后再化简）、比较（6种关系）的运算。 class CFraction { private: int nume; // 分子 int deno; // ...
类和对象之运算符重载
可乐不解渴
06-05 416
三、运算符重载 3.1 概念 在 C++语言中，可以用关键字 operator 加上运算符来表示函数，叫做运算符重载。 C++编译器在对运算符进行编译处理时，将一个运算符编译成以下形式： 例如两个复数相加函数： Complex Add(const Complex &a, const Complex &b); 可以用运算符重载来表示： Complex operator +(const Complex &a, const Complex &b); 3.2 运算符重载
C++类和对象，运算符重载
世界仙境与冷酷尽头's Blog
07-25 340
C++类和对象
【C++】类的运算符重载
weixin_43856994的博客
07-11 1123
运算符重载： 主要作用：实现类对象之间的运算； 隐式调用和显式调用; 类内部进行运算符重载只需要一个参数，因为类对象本身就是一个参数； 规则: 运算符重载不允许发明新的运算符； 不能改变运算符操作对象的个数； 运算符被重载后，其优先级和结合性不会改变； 不能重载的运算符： ​​​​​​ ​ Complex.h #ifndef COMPLEX_H #define COMPLEX_H class Complex{ public: Com.
运算符重载
tzjvon的博客
12-24 325
运算符重载实质上是函数重载    一般格式如下:     函数类型 operator 运算符名称(形参表列) c++不允许用户自己定义新的运算符，只能对已有的c++运算符进行重载     重载不能改变运算符运算对象(即操作数)的个数     重载不能改变运算符的优先级     重载不能改变运算符的结合性     重载运算符的函数不能有默认参数     重载的运算符必须和用户定义的自
类的使用：重载运算符
qq_63775204的博客
04-15 125
类的使用：重载运算符
C++类与对象：运算符重载
qq_45481606的博客
07-14 768
什么是运算符重载： C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，有返回值，函数名及参数列表；其返回值类型与参数列表与普通的函数类似。 编译器对于自定义类型的对象，都不支持基本操作符（>,<,++,–）对对象进行操作；只能进行重载 关键字：operator 函数原型：返回值类型 operator操作符(参数列表)，关键字operator后面接需要重载的运算符符号 注意： 不能重载非运算符； 重载操作符函数参数，必须有一个类类型或枚举类...
python 对象之间的依赖关系和运算符重载 示例
10-27
python 对象之间的依赖关系和运算符重载 示例
实验二 运算符重载的应用.doc
02-25
含实验心得，非常详细
实验六函数重载与运算符重载
09-28
实验六函数重载与运算符重载 实验六函数重载与运算符重载
实验项目五：类和对象_实验项目六：运算符重载.zip
05-05
实验项目五：类和对象 实验项目六：运算符重载
C++：round函数用法
Solititude的博客
05-28 224
C++：round函数用法
C++ enum 和 string互转
一个大佬的博客
05-28 275
【代码】C++ enum 和 string互转。
【C++】类与对象(上)
m0_73911405的博客
05-28 702
为什么会右边报错，左边不报错？
关于C++的特殊类定制
m0_62126248的博客
05-28 164
C++的一些特殊性质的类如何进行设计
【C++】vector的基本使用
qq_64818885的博客
05-28 705
💗💗⭐个人专栏——⭐💫点击关注🤩一起学习C语言💯💫。
【贪心算法】C++ 解决算法题：买卖股票 / K次取反 / 按身高排序 / 优势洗牌
最新发布
卜及中的博客
05-28 648
贪心算法在每一步选择中都采取当前状态下最优决策的算法。贪心算法通常用来解决最优化问题，其在贪心算法中，我们并不总是考虑到未来可能发生的情况，而是只关注当前的最优选择。这种贪心选择性质使得贪心算法特别适合解决那些具有最优子结构性质的问题，即局部最优解能够推导出全局最优解的问题。需要注意的是，贪心算法并不适用于所有的问题，因为并非所有问题都具有最优子结构性质。在某些情况下，贪心算法得到的结果可能并不是全局最优解，而只是一个较好的解。因此，在应用贪心算法时，需要仔细分析问题的特性，以确定贪心算法是否适用于该问题。
C++(25): C++17探索：std::optional
tecsai的博客
05-28 186
std::optional是C++17标准引入的一个新的标准库组件。这是一个轻量级的容器，旨在以类型安全的方式包装可能为空的值。std::optional为处理可能缺失的数据提供了一种优雅而简洁的方法，这在以往通常需要使用专门的“存在”标志或复杂的错误处理机制。 简单点讲，std::optional在使用上并不复杂，主要用来替代那些需要返回NULL，或以返回-1表示错误等的场合。这样做最直观的一个改进就是易读性增强了。
学习-python面向对象之运算符重载
06-28
### 回答1： 运算符重载是指在类中定义特殊方法，使得该类的实例对象可以像内置类型一样进行运算。Python中支持运算符重载，可以通过定义特殊方法来实现。例如，可以通过定义__add__方法来重载加号运算符，使得两个对象可以相加。 在Python中，运算符重载的方法名都以双下划线开头和结尾，例如__add__、__sub__等。这些方法可以重载加减乘除等运算符，也可以重载比较运算符、逻辑运算符等。 运算符重载可以使得代码更加简洁、易读，同时也可以提高代码的可维护性和可扩展性。但是需要注意的是，过度使用运算符重载可能会导致代码难以理解和维护，因此需要谨慎使用。 ### 回答2： Python是一门支持面向对象（OOP）编程的语言，它提供了很多方便的机制来帮助我们更好地定义和使用对象。其中之一就是运算符重载。 运算符重载是指在类中定义特殊方法来重载Python内置运算符的行为。比如，我们可以重载加号（+）运算符，使得两个对象相加时返回我们自己定义的结果。这样就可以让我们的对象像普通类型（如int和float）一样使用加号。 以下是使用方法： ```python class MyClass: def __init__(self, value): self.value = value def __add__(self, other): # 自己定义的加法 return MyClass(self.value + other.value) a = MyClass(1) b = MyClass(2) c = a + b # c的值是一个MyClass对象，其value属性为3 ``` 在上述代码中，`__add__`方法是用来重载`+`运算符的方法。当两个MyClass对象相加时，它们的`__add__`方法会被调用，然后返回自己定义的结果。 还有其他运算符也可以被重载，比如减号`-`，乘号`*`，等等。此外，Python还提供了一些通用的重载方法，比如`__eq__`用来实现相等比较，`__str__`用来定义对象的字符串表示等等。 需要注意的是，运算符重载虽然可以让我们的代码更加方便易读，但也容易被滥用。如果重载的运算符和普通的类型行为不一致，就容易引起混淆和错误。因此，在使用运算符重载时需要做好注释和测试，确保代码的正确性和可读性。 总之，Python的面向对象编程支持运算符重载，这为我们提供了更加灵活和方便的对象定义和使用方式。但重载运算符也需要谨慎使用，化简代码的同时不要失去代码的可读性和正确性。 ### 回答3： 运算符重载是 Python 面向对象编程中的一个重要概念，它是指将已有的运算符赋予新的功能，使之具有更广泛的适用性。Python 提供了许多运算符，如加减乘除、比较、逻辑运算符等，这些运算符可以用于不同的数据类型，如整数、浮点数、字符串、列表等。运算符重载可以自定义这些运算符的行为，使之适用于用户自己定义的类。 在 Python 中，运算符的重载使用特殊的方法来实现。这些方法的名称都以 "__" 开头和结尾，例如 "__add__" 就是用来实现加法运算符重载的方法。这些方法通常会被定义在类中，用来定义类的运算符行为。在使用运算符时，Python 会自动调用对应的运算符重载方法，以便完成需要的运算。 以下是一些常用的运算符重载方法： __add__(self, other)：重载加法运算符“+”，用来添加两个对象的值。 __sub__(self, other)：重载减法运算符“-”，用来计算两个对象的差。 __mul__(self, other)：重载乘法运算符“*”，用来计算两个对象的积。 __div__(self, other)：重载除法运算符“/”，用来计算两个对象的商。 __eq__(self, other)：重载相等运算符“==”，用来比较两个对象是否相等。 __ne__(self, other)：重载不等运算符“!=”，用来比较两个对象是否不相等。 __lt__(self, other)：重载小于运算符“<”，用来比较两个对象的大小。 __le__(self, other)：重载小于等于运算符“<=”，用来比较两个对象的大小。 __gt__(self, other)：重载大于运算符“>”，用来比较两个对象的大小。 __ge__(self, other)：重载大于等于运算符“>=”，用来比较两个对象的大小。 使用运算符重载可以方便地扩展 Python 的运算符行为，使之适用于用户自定义的类。但是，使用运算符重载也需要注意一些问题，如运算符的优先级、运算符的结合性等。在使用运算符重载时，需要谨慎思考，以确保运算符行为符合预期。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

夏微凉.

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值