【C++】运算符重载

已于 2022-08-01 19:40:29 修改
阅读量403 收藏
点赞数 1
分类专栏： C++ 文章标签： c++
于 2022-07-09 19:50:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xuan3215/article/details/125622872
版权

目录

运算符重载

加 号 （+） 运 算 符 重 载

        成员函数重载

        全局函数重载

左 移 （<<） 运 算 符

 递 增 （++） 运 算 符 重 载

        前置递增

        后置递增

赋 值 （=） 运 算 符 重 载

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

函 数 调 用 运 算 符 重 载

运算符重载

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

加 号 （+） 运 算 符 重 载

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

成员函数重载

在成员函数内对运算符进行重载，重载 operator+ 写在公共权限下。

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

// 成员函数重载 +
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 = 20;
    p2.m_B = 20;

    Person p3 = p1 + p2;

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

int main(){
    test();
    system("pause");
    return 0;
}

Person p3 = p1 + p2;

本质:

Person p3 = p1.operator+(p2);

不用用 operator+ 用别的可不可以呢？

 答案是不可以

全局函数重载

#include<iostream>
#include<string>
using namespace std;
// 成员函数重载 +
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 = p2.m_B + p2.m_B;
    return temp;
}
void test(){
    Person p1;
    p1.m_A = 10;
    p1.m_B = 10;
    Person p2;
    p2.m_A = 20;
    p2.m_B = 20;

    Person p3 = p1 + p2;

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

int main(){
    test();
    system("pause");
    return 0;
}
Person p3 = p1 + p2;

本质：

Person p3 = operator+(p1, p2);

函数重载 + 也可以是不同类型

左 移 （<<） 运 算 符

让 cout 输出对象 p

将 operator<< 写在成员函数

调用的时候就要 operator<<(cout) 简化： p<<cout 

无法实现 cout 在左侧

所以不会利用成员函数重载 << 运算符，

只能利用全局函数重载左移运算符

#include<iostream>
using namespace std;
// <<
class Person {
public:
    int m_A;
    int m_B;
};
void operator<<(ostream& cout, Person& p) {
    cout << p.m_A << endl << p.m_B << endl;
}
void test01()
{
    Person p;
    p.m_A = 10;
    p.m_B = 10;

    cout << p;
}
int main() {
    test01();
    system("pause");
    return 0;
}

 cout 类型 ：ostream

本质

operator<<(cout,p);

简化

cout << p;

链式编程思想：

 需要对 operator<< 重载进行返回 cout 

ostream& operator<<(ostream& cout, Person& p) 
{
    cout << p.m_A << endl << p.m_B << endl;
    return cout;
}

 最后全局函数重载左移运算符需要访问类中的私有成员需要运用友元技术

#include<iostream>
using namespace std;
// <<
class Person {
    // 友元
    friend ostream& operator<<(ostream& cout, Person& p);
public:
    // 构造
    Person(int a, int b) :m_A(a), m_B(b) {

    }
private:
    int m_A;
    int m_B;
};
ostream& operator<<(ostream& cout, Person& p){
    cout << p.m_A << endl << p.m_B << endl;
    return cout;
}
void test01()
{
    Person p(10, 20);
    cout << p << endl;
}
int main() {
    test01();
    system("pause");
    return 0;
}

 递 增 （++） 运 算 符 重 载

前置递增

#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;
    }
private:
    int m_Num;
};

ostream& operator<<(ostream& cout, MyInteger& myint) {
    cout << myint.m_Num << endl;
    return cout;
}
void test() {
    MyInteger myint;
    cout << myint;
    cout << ++myint;
}
int main() {
    test();
    system("pause");
    return 0;
}
MyInteger& operator++()
{
    // 进行 ++ 运算
    m_Num++;
    // 在返回自身做返回
    return *this;
}

返回类型为引用，是为了防止返回的数据是一个新的数据而不是自身，

为了一直对一个数据进行操作

如果返回类型不写成引用则对象只能做一次++

后置递增

当前置 ++ 和 后置 ++ 同时重载时，这时重载的成员函会发生二义性

 可以写占位参数来重载，但只能写 int 来占位

#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;
    }
    // 后置递增 
    MyInteger& operator++(int)
    {
        // 记录结果
        // 堆上开辟空间进行返回
        MyInteger* temp = new MyInteger;
        // 递增
        m_Num++;
        // 返回记录值
        return *temp;
    }
private:
    int m_Num;
};

ostream& operator<<(ostream& cout, MyInteger& myint)
{
    cout << myint.m_Num;
    return cout;
}

void test1()
{
    MyInteger myint1;
    cout << myint1 << endl;
    cout << myint1++ << endl;
    cout << myint1 << endl;
}

void test2()
{
    MyInteger myint2;
    cout << myint2 << endl;
    cout << ++myint2 << endl;
}
int main()
{
    test1();
    system("pause");
    return 0;
}

 后置递增不能返回引用，局部变量会在函数结束时被销毁，但可以通过 new 在堆区创建全局变量就可以返回引用

#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;
    }
    // 后置递增 
    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 test1()
{
    MyInteger myint1;
    cout << myint1 << endl;
    cout << myint1++ << endl;
    cout << myint1 << endl;
}

void test2()
{
    MyInteger myint2;
    cout << myint2 << endl;
    cout << ++myint2 << endl;
}
int main()
{
    test1();
    system("pause");
    return 0;
}

赋 值 （=） 运 算 符 重 载

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

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

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

堆区数据需要释放，在析构函数中完成，编译器提供的赋值运算符是浅拷贝，对地址也进行拷贝，所以在释放的时候会导致堆区内存重复释放

 这里需要深拷贝

#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;
        }
    }
    // 重载 赋值=
    void operator=(Person& p)
    {
        // 先判断是否有属性在堆区
        // 有先释放
        // 再深拷贝
        if (m_Age != NULL)
        {
            delete m_Age;
            m_Age = NULL;
        }
        m_Age = new int(*p.m_Age);
    }
    int* m_Age;
};

void test1()
{
    Person p1(18);
    Person p2(20);
    p2 = p1; // 赋值 
    cout << "p1 的年龄：" << *p1.m_Age << endl;
    cout << "p2 的年龄：" << *p2.m_Age << endl;
}

int main(){
    test1();
    system("pause");
    return 0;
}

这里重载=函数返回值为 void ，C++中允许连续赋值 

int a = 10;
int b = 20;
int c = 30;
a = b = c;

当上面提供的重载不能进行连续赋值，链式无法进行

所以需要进行改进

#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)
    {
        // 先判断是否有属性在堆区
        // 有先释放
        // 再深拷贝
        if (m_Age != NULL)
        {
            delete m_Age;
            m_Age = NULL;
        }
        m_Age = new int(*p.m_Age);
        // 返回对象本体
        return *this;
    }
    int* m_Age;
};

void test1()
{
    Person p1(18);
    Person p2(20);
    Person p3(30);
    p2 = p1 = p3; // 赋值 
    cout << "p1 的年龄：" << *p1.m_Age << endl;
    cout << "p2 的年龄：" << *p2.m_Age << endl;
    cout << "p3 的年龄：" << *p3.m_Age << endl;
}

int main(){
    test1();
    system("pause");
    return 0;
}

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

作用：可以让两个自定义类型对象进行对比操作

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

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 false;
        }
        else
        {
            return true;
        }
    }
    string m_Name;
    int m_Age;
};

void test1()
{
    Person p1("李华", 18);
    Person p2("李华1", 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()
{
    test1();
    system("pause");
    return 0;
}

 函数调用运算符重载

  • 函数调用运算符  ( )  可以重载
  • 重载后使用的方式像函数的调用，故称为 仿 函 数
  • 仿函数没有固定的写法，非常灵活
#include<iostream>
#include<string>
using namespace std;

// 打印输出类
class MyPrint
{
public:
    void operator()(string text)
    {
        cout << text << endl;
    }
};

// 自定义函数
void MyPrint2(string text)
{
    cout << text << endl;
}


void test()
{
    MyPrint myPrint;
    // 仿函数
    myPrint("hello world");
    // 自定义函数
    MyPrint2("hello world");
}

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

void test2()
{
    MyAdd add;
    cout << add(10, 20) << endl;

    // 匿名函数对象
    cout << MyAdd()(20, 20) << endl;
}
int main()
{
    test();
    test2();
    system("pause");
    return 0;
}

L1099
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++关系运算符重载
希望我的博客，能帮上你解决学习中工作中所遇到的问题
11-07 389
关系运算符重载 **作用：**重载关系运算符，可以让两个自定义类型对象进行对比操作 示例： 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 ==
C++运算符重载
m0_66444993的博客
07-06 3073
目录一、运算符重载的概念 二、成员函数重载三、友元函数重载四、 特殊符号型的重载-- > 输入和输出流一般作为友元重载，不能作为成员函数重载1、是什么运算符重载指的是重载系统内部的运算符函数，是实现类静态多态性的方式之一。它本质上是函数重载。2、为什么我们平常常见的算术运算符、逻辑运算符等运算符都是系统库函数里面已经存在的，所以运算符可以直接用于我们常用的数据类型。然而对于我们自定义的类实例化的对象，系统没有与之相关的运算符可以操作，但是为了使我们编写程序时更加便捷，C++提供了一种方式——运算符重...
c++中运算符的重载
mxway的专栏
08-01 1086
程序1.cpp #include int main() { int a=3,b=2; cout<<a+b<<endl; return 0; }上面的程序中定义了两个整形变量a和b。并输出两个整形变量之和。 程序2.cpp #include using namespace std; class A { public: int getData() { return data;
c++学习心得第二期 友元+运算符重载
qq_37448336的博客
10-04 299
c++学习心得第二期 友元+运算符重载一、友元1 、全局函数做友元2. 类做友元3. 成员函数做友元二、运算符重载1.加号运算符重载2.左移运算符重载3.递增运算符重载4.赋值运算符重载5. 关系运算符重载6. 函数调用运算符重载 在程序里，有些私有属性 也想让类外特殊的一些函数或者类进行访问，就需要用到友元的技术 友元的目的就是让一个函数或者类 访问另一个类中私有成员 友元的关键字为 friend 友元的三种实现 全局函数做友元 类做友元 成员函数做友元 一、友元 1 、全局函数做友元 #incl
C++运算符重载（操作符重载）
最新发布
qq_41885018的博客
05-11 967
有时候我们需要让对象之间进行运算， C++ 提供的“运算符重载”机制，赋予运算符新的功能，就能解决用+将两个复数对象相加这样的问题。，因为左移运算符左边是cout，而想要调用类里的成员函数首先要是对象才行，而cout显然不是对象，括号运算符()也可以重载，对象名可以当成函数来使用（函数对象、仿函数）。除了 “ + ”，还有其他的运算符重载，如 “ - ”（减法运算）接着刚才的问题，我们利用运算符重载为运算符增加一些新的功能，，既可以接受const对象，也可以接受非const对象。
C++——运算符的重载
热门推荐
weixin_59179454的博客
05-30 1万+
运算符重载，就是对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型。让类类型的对象像基本数据类型一样去操作 例如：可以实现对象+,-* / % ==!运算符的重载实际是一种特殊的函数重载，必须定义一个函数，并告诉C++编译器，当遇到该重载的运算符时调用此函数。这个函数叫做运算符重载函数，通常为类的成员函数。定义运算符重载函数的一般格式：返回值类型 类名::operator重载的运算符(参数表) {……}operator是关键字，它与重载的运算符一起构成函数名。
C++运算符重载规则详解
09-03
C++运算符重载是语言特性之一，允许程序员为已存在的运算符赋予新的含义，以适应自定义数据类型的运算需求。然而，运算符重载并不是无限制的，它遵循一些特定的规则，以确保代码的清晰性和正确性。 首先，C++中大...
c++运算符重载
weixin_51448994的博客
03-03 442
c++运算符重载 C++允许在同一作用域中的某一函数和运算符指定多个定义，分别为函数重载和运算符重载。 一、运算符重载 运算符重载，就是赋予运算符新的含义。和函数重载一样，一个函数名可以用来代表不同功能的函数。 实质：调用函数的过程。 1.1为什么要进行运算符重载？ 因为自定义类型不能直接采取运算符操作 运算符重载是为了解决类对象之间的运算的，通常的运算符只用于算术运算，如常量int之间，因为编译器已经定义了；而一个类两个对象之间成员进行运算必须重新定义，让编译器在遇到对象运算时能按我们要求的进行运算
C++|运算符重载
Youth_R的博客
08-17 287
#include <iostream> using namespace std; class CComplex { public: CComplex(int r = 0, int i = 0) : mreal(r), mimage(i) {} CComplex operator+(const CComplex &src) { /*CComplex comp; comp.mreal = this->mreal + src.mreal; comp.mimage
C++运算符的重载
qq_42174306的博客
02-16 1093
C++运算符重载（operator）
c 语言允许在重载运算符时改变运算符的,C++ 运算符重载讲解与经典实例
weixin_33983809的博客
05-23 1679
原标题：C++ 运算符重载讲解与经典实例(点击上方公众号，可快速关注)来源：dingyuanpu链接：http://blog.csdn.net/dingyuanpu/article/details/5852825C++中预定义的运算符的操作对象只能是基本数据类型，实际上，对于很多用户自定义类型，也需要有类似的运算操作。例如：classcomplex{public:complex(doubler=0...
074-C++
xiaofeng3011的博客
06-09 182
C++ 二元运算符重载 #include using namespace std; class Box { double length; // 长度 double breadth; // 宽度 double height; // 高度 public: double getVolume(void) { return l
C++ 运算符重载
猫的博客
07-17 364
偷偷拿来记录一下萌新的cs路——day 29 C++加号运算符重载 day 38 左移运算符重载
c++ 运算符重载
物联黄同学的博客
09-26 3104
前言 本篇内容参考了b站up主黑马程序员的视频，这是链接https://www.bilibili.com/video/BV1et411b73Z?p=126 什么是运算符重载？ 运算符重载类似于函数重载，回顾函数重载，我们会发现，发生函数重载使得同名函数具有不同的应用，运算符重载也是如此，针对不同的对象，运算符重载可以有不同的应用。但是，我们在做运算符重载时并不是扩大一个运算符的功能，而是扩大它应用的范围。 运算符重载的应用场景 运算符重载常用于对类或者结构体的运算符操作，例如，一个类有几个int属性，然
C++中的 运算符重载
qq_24472227的博客
04-09 3455
C++的 各种运算符重载：加号、左移、递增、赋值、关系、函数调用
c++之运算符重载
sdau20171755的博客
05-26 476
c++之运算符重载运算符重载Vector结构namespace Wrox.ProCSharp.OOCSharp{   struct Vector   {      public double x, y, z;       public Vector(double x, double y, double z)      {         this.x = x;         this.y = y...
C++运算符重载详解
C++中的运算符重载是编程中一个重要的概念，它允许程序员根据需要为自定义数据类型扩展运算符的功能。在C++中，运算符重载是通过定义特定的成员函数或友元函数来实现的，目的是使得用户定义的类型能够像内置类型一样...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值