C++ 前置、后置递增（递减）运算符

最新推荐文章于 2024-03-09 12:49:34 发布
最新推荐文章于 2024-03-09 12:49:34 发布
阅读量892 收藏 2
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_49426289/article/details/116381784
版权

记录本人的学习过程，如果能够帮助到您，是我的荣幸

#include <cstdlib>
#include <string>
#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;
    }

    //重载后置++运算符
    //void operator++(int) int代表占位参数，可以用于区分前置和后置递增

    myInteger operator++(int)//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 test01()
{
    myInteger myint;
    cout<<++(++myint)<<endl;//包含了左移运算符和前置递增
    cout<<myint<<endl;
}
void test02()
{
    myInteger myint1;
    cout<<myint1++<<endl;//包含了左移运算符和后置递增
    cout<<myint1<<endl;
}
int main(){
    test01();
    return 0;
}

ostream用法

c++中的ostream这个类型，通常作为某个类的友元函数出现，用于<<(左移)操作重载中。
注意：
1、返回值也需要是ostream&形式 —ostream为输出流 &在这里为引用
2、函数定义是输出cout<<___；后面不需要加endl，其他与正常输出一 致

递增重载运算符

1.1 what

operator 是C++的一个关键字，它和运算符（如=）一起使用，表示一个运算符重载函数，在理解时可将operator和运算符（如operator=）视为一个函数名。

使用operator重载运算符，是C++扩展运算符功能的方法。使用operator扩展运算符功能的原因如下：

使重载后的运算符的使用方法与重载前一致
扩展运算符的功能只能通过函数的方式实现（实际上，C++中各种“功能”都是由函数实现的）

1.2 why

对于C++提供的所有操作符，通常只支持对于基本数据类型和标准库中提供的类的操作，而对于用户自己定义的类，如果想要通过该操作符实现一些基本操作（比如比较大小，判断是否相等），就需要用户自己来定义关于这个操作符的具体实现了。

比如，我们要设计一个名为“person”的类，现在要判断person类的两个对象p1和p2是否一样大，我们设计的比较规则是按照其年龄来比较，那么，在设计person类的时候，就可以通过对操作符“”进行重载，来使用操作符“”对对象p1和p2进行比较了（根据前面的分析，实际上比较的内容应该是person类中的数据成员“age”）。

我们上面说的对操作符“”进行重载，说是“重载”，是由于编译器在实现操作符“”功能的时候，已经为我们提供了这个操作符对于一些基本数据类型的操作支持，只不过由于现在该操作符所操作的内容变成了我们自定义的数据类型（如class），而默认情况下，该操作符是不能对我们自定义的class类型进行操作的，所以，就需要我们通过重载该操作符，给出该操作符操作我们自定义的class类型的方法，从而达到使用该操作符对我们自定义的class类型进行运算的目的。

1.3 how

实现一个操作符重载的方式通常分为两种情况：

  1. 将操作符重载实现为类的成员函数；
  2. 操作符重载实现为非类的成员函数（即全局函数）。

1.3.1 将操作符重载实现为类的成员函数

在类体中声明（定义）需要重载的操作符，声明方式跟普通的成员函数一样，只不过操作符重载函数的名字是“关键字 operator +以及紧跟其后的一个C++预定义的操作符”，样式如下（person是我们定义的类）：

前文介绍出自链接中

原文链接：https://blog.csdn.net/liitdar/article/details/80654324

代码实现如下：

赋值运算符

    bool operator==(const person& ps)
    {
        if (this->age == ps.age)
        {
            return true;
        }
        return false;
    }

加号(减号)运算符重载

#include <cstdlib>
#include <string>
#include<iostream>
using namespace std;
class person
{
public:
    int m_A;
    int m_B;
public:
    person(){
        cout<<"无参构造函数"<<endl;
    }
    person(int a, int b)
    {
        this->m_A = a;
        this->m_B = b;
    }
    person(int a,int b)
    {
        m_A = a;
        m_B = b;
    }
    //成员函数实现 + 号运算符重载
    person operator+(const person &p)//关键词(person) + operator + 以及紧跟其后的一个C++预定义的操作符
    {
        person temp;//调用无参构造 person(){};
        temp.m_A = this->m_A + p.m_A;
        temp.m_B = this->m_B + p.m_B;
        return temp;
    }

};
//全局函数实现 + 号运算符重载
person operator+(const person &p1,const person &p2)
{
    person temp(0,0);//调用有参构造函数 person(int a,int b)
    temp.m_A = p1.m_A + p2.m_A;
    temp.m_B = p1.m_B + p2.m_B;
    return temp;
}
void test01()
{
    person p1(10,10);
    person p2(10,10);
    person p3 = p1+p2;//相当于p1.operator+(p2)
    cout<<"m_A = "<<p3.m_A<<"m_B = "<<p3.m_B<<endl;
}
int main()
{

    test01();
    return 0;
}

执行结果：
在这里插入图片描述

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

左移运算符重载

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

#include <cstdlib>
#include <string>
#include<iostream>
using namespace std;
class person
{
    friend ostream& operator<<(ostream& cout,person &p);//作为友元类，能够访问类中的私有变量
private:
    int m_A;
    int m_B;
public:
    person(int a,int b)
    {
        m_A = a;
        m_B = b;
        cout<<m_A<<" "<<m_B<<endl;
    }
};
ostream& operator<<(ostream& cout,person &p)//采用全局函数，重载左移运算符
{
    cout<<"m_A: "<<p.m_A<<"m_B: "<<p.m_B;
    return cout;
}
void test01()
{
    person p(10,10);
    cout<<p<<endl;
}
int main()
{

    test01();
    return 0;

执行结果：
在这里插入图片描述

赋值运算符重载

#include <cstdlib>
#include <string>
#include<iostream>
using namespace std;
class person
{
public:
    int *m_age;
public:
    person(int age)
    {
        m_age = new int(age);//在堆区开辟空间
    }
    ~person()//释放堆区内存空间，因为是浅拷贝，堆区内存重复释放，程序崩溃
    {
        if(m_age != NULL)
        {
            delete m_age;
            m_age = NULL;
        }
    }
    //person& 要用引用形式
    //不返回person的原因是，返回值也会再一次调用拷贝构造，然后再返回值再拷贝，进入了无线拷贝死循环
    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;//*this解引用后相当于变量（对象）
    }


};
void test01()
{
    person p1(18);
    person p2(20);
    person p3(30);
    p3 = p2 = p1;//赋值运算操作，浅拷贝了,p1,p2的指针指向堆区的同一个地址和数据
    cout<<"p1's  age is : "<<*p1.m_age<<endl;

    cout<<"p2's  age is : "<<*p2.m_age<<endl;
    cout<<"p3's  age is : "<<*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;
    return 0;
}

执行结果：
在这里插入图片描述

关系运算符

#include <cstdlib>
#include <string>
#include<iostream>
using namespace std;
class person
{
public:
    string m_name;
    int m_age;
public:
    person(string name,int age)
    {
        this->m_age = age;
        this->m_name = name;
    }
    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;
        }
    }

};
    ostream& operator<<(ostream& cout,const person &p)
    {
        cout<<p.m_name;
        return cout;
    }
void test01()
{
    person p1("孙悟空" , 18);
    person p2("孙悟空" , 18);

    if(p1==p2)
    {
        cout<<"p1  = p2"<<endl;
        cout<<p1<<" "<<p2<<endl;
    }
    else{
       cout<<"!="<<endl;
    }
}
int main()
{
    test01();
    return 0;
}

执行结果：在这里插入图片描述

Grace随身听
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
简单了解C++语言中的二元运算符和赋值运算符
09-02
主要介绍了C++语言中的二元运算符和赋值运算符,文中列出了可重载的运算符列表,需要的朋友可以参考下
C++ 递增递减运算符以及复合运算符
diaodiaodediao的博客
12-15 710
递增递减运算符的应用以及复合运算符的应用
C++运算符重载，前置自增（前置++）和后置自增（后置++）代码分析
Dontla的博客
06-10 3445
返回递增之前的对象值：后置递增运算符需要在递增之前返回原始对象的值，以满足后置递增的语义。通过不同的返回值类型，前置递增和后置递增运算符的重载函数可以提供一致且符合预期的行为，与内置类型的递增操作保持一致，并允许连续的前置递增操作。这样的差异设计使得前置递增和后置递增的使用方式与内置类型的递增操作保持一致，同时也符合了C++中运算符重载的惯例。这是因为前置递增运算符用于直接对对象进行递增操作，并返回递增后的对象的引用。而在后置递增运算符（x++）的重载中，返回值的类型通常是对象类型（对象的副本），例如。
【Leetcode每日一刷】数组|双指针篇：977. 有序数组的平方、76. 最小覆盖子串（附滑动窗口法详解）
最新发布
Yaoyao2024的博客
03-09 874
当有可能含负数的有序数组平方后，最大值只有可能位于数组两侧，整个数组呈一个凹函数，从两边向中间递减。但是这题的关键如上，也就是平方后数组由两边向中间递减，最大值只有可能位于两侧。由于这样的特性，利用。，每次循环，将左指针和右指针处的元素进行比较。更新当前窗口中的数据情况，再拿去和题目所需的可行解进行比对，判断当前窗口内的情况是否可行！双指针， 从两边向中间探测，互相比较，逐渐挑出最大值，再到次最大值…——两者的情况进行比对，判断当前窗口中的情况是否可行。完全一样时，就可行，换句话说，就是不能直接把。
c++中前置/后置递增/递减
Yknjs的博客
12-22 1470
在c++中，前置递增++a与后置递增a++都是让变量a加一再赋值给自身，那么他们的区别在哪呢？ 前置递增++a是先让变量a+1再进行表达式的运算，而后置递增a++是先使用变量a与表达式进行运算后再+1，示例代码如下： void test01() { int a = 10; int b; b = ++a * 2; //先让a加1，然后进行表达式计算 cout << "test01,此时a的值为： " << a << endl; cout << "tes
c++ 递增运算符重载案例代码
10-13
参考“黑马程序员”c++ 课程 递增运算符重载 如有侵权请联系删除 本系列文件： 递增运算符重载 赋值运算符重载 关系运算符重载 函数调用运算符重载 加号运算符重载 左移运算符重载 供和我一样的c++新手参考，大家...
C++ 课程作业 多态性 运算符重载-综合（Point类）
04-25
请定义一个Point类，将前置++和后置++运算符重载为成员函数，实现成员变量m_x和m_y的加一操作 同时重载流插入运算符，实现对Point类对象的格式化输出。例如 Point p； cout; 输出结果为： （0,0） 请根据给定的main...
C++中的运算符和运算符优先级总结
09-02
主要介绍了C++中的运算符和运算符优先级总结,主要整理了算术、关系、逻辑、位和赋值运算符的用法,需要的朋友可以参考下
C++ 上课/复习ppt运算符重载.pptx
09-30
C++ 上课/复习ppt运算符重载.pptx
C++前置后置递增运算符操作
ISP行业的忠实粉丝
05-08 587
C++前置后置递增运算符操作 目录 C++前置后置递增运算符操作 1、前置递增 2、后置递增 3、前置和后置的区别 1、前置递增 前置递增 先让变量+1 然后进行表达式计算 2、后置递增 后置递增 先对变量进行表达式计算，再对变量加1 3、前置和后置的区别 #include<iostream> using namespace std; int main() {...
＜C++＞详解运算符重载之前置递增和后置递增
微凉秋意的博客
06-09 2610
不走心的努力，都是在敷衍自己。书接上文，今天的内容是运算符重载里的递增运算符重载；递增和递减原理是一样的，这里就只分享递增的重载；提到递增递减，我们都知道又前置和后置两种方法， 那今天就详解一下前置递增和后置递增的细节，拿捏递增运算符重载！ 形如"a++"、"++a"。如果a初始值为1，那么"a++"结果为1，但是实际上a等于2，先读取再加1；"++a"结果为2，实际也是2。这是对于基本运算类型，那么递增运算符重载的目的就是对于对象的属性也可以直接进行前置递增和后置......
C++的递增运算符和递减运算符
little_startoo的博客
05-16 462
C++的递增运算符和递减运算符
C++ 语言递增和递减运算符
既然选择了远方 便只顾风雨兼程 - 永强
02-21 1812
C++ 语言递增和递减运算符 递增运算符 ++ 和递减运算符 -- 为对象的加 1 和减 1 操作提供了一种简洁的书写形式。这两个运算符还可应用于迭代器，很多迭代器本身不支持算术运算，此时递增和递减运算符除了书写简洁外还是必须的。 递增和递减运算符有两种形式：前置版本和后置版本。 前置版本的运算符首先将运算对象加 1 (或减 1)，然后将改变后的对象作为求值结果。 后置版本也会将运算对象加 1 (或减 1)，但是求值结果是运算对象改变之前那个值的副本。 //=======================
C++递增运算符重载
Titoko的博客
03-03 428
C++递增运算符重载
运算符重载之前置递增和后置递增
yzfzzz的博客
01-04 1007
在C++中，运算符重载允许程序员自定义运算符的行为，以适应特定的类或对象。这在许多情况下都很有用，包括处理复杂的数学运算、自定义数据结构等。 前置递增和后置递增运算符的重载是运算符重载的常见示例。这两个运算符通常用于增加变量的值。
C++的前置递增和后置递增
weixin_43937959的博客
02-16 1395
C++的前置递增和后置递增的区别  直接上代码。 //递增 int main() { //后置递增 int a = 10; a++; //等价于a = a + 1 cout << a << endl; // 11 //前置递增 int b = 10; ++b; cout << b << endl; // 11 //区别 //前置递增先对变量进行++，再计算表达式 int a2 = 10; int b2 = ++a2 * 10;
递增运算符重载占位参数问题
retdr的博客
03-15 432
递增运算符重载占位参数问题 今天学习递增运算符重载时遇到了一个疑问，就是对于前置++和后置++，由于都需要使用operator++()指令，从而违反了“重载函数必须拥有不同的函数原型”的语法规定，例如： Base& operator++();//前置++ Base operator++(int)//后置++ 虽然由于运算属性返回类型不同，但是不属于函数原型所以不符合重载要求，所以只好给后置++加一个形参int来绕过语法限制。之后我就反复思考这个int是不是有什么含义或者隐含的逻辑来帮助区
C++后置递增运算符重载
wade1010的专栏
12-09 623
c++
c++后置递增运算符重载
07-28
在C++中，可以通过重载后置递增运算符（++）来定义自定义类型的行为...请注意，重载后置递增运算符时需要使用一个额外的（但无实际用途的）整数参数`int`，以便将其与前置递增运算符进行区分。这是C++语言规定的要求。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值