常用的＜＜,＞＞,+=,-=,+,-,++,--前置和后置的运算符重载总结

目录

一、关于运算符重载

二、+，-，+=，-=，前后置的++，--，<<,>>的重载和使用（题目：时分秒加减）

---

一、关于运算符重载：

1、格式：

返回类型 operator 运算符（形参表）{函数体}

简而言之，比如+号，原本是用于两数字相加，不能直接用于两个类对象，所以为了简便地对两个类的对象进行相关的加法操作，需要对+号重载。

注意：一般不改变运算符的优先级、目数和结合性。

 2、重载简单举例. 如下是一个对+的重载：

class C{
private:
       int x,y;
public:
       xxx operator+(C& a)
{
       return C(x+a.x,y+a.y);
}

 C a1,a2,sum;

 sum=a1+a2; //此时sum对象中x,y值即为各自加和。 

 return处的《类名接括号》，指生成一个没有名字的临时对象，该对象被按括号内容初始化并返回。

本质上是：sum=a1.operator+(a2);

---加号的左结合性,当+左为“C”类对象时

==>就调用函数operator+()。

3、重载为友元. 此时无隐含的this指针；

所以，操作数不变的前提下，形参就要增加一个咯。纯成员函数时，参数为目数-1.

这时的加：

friend C operator+(const C& a,const C& b)
{
            return C(a.x+b.x,a.y+b.y);
}

长这样。 此时它的本质是：operator+(a,b).

总结：①单目重载为类的成员函数方便些，也更直观；

②操作数有隐式类型转换时，用友元；

③必须纯成员的四个运算符：=，[]，（），->。

④不可重载的五个：“ * ”，“ ：”，“ ：：”，sizeof ，“   ？ ：  ”。

⑤重载不能有默认参数（否则改变了操作数个数）；

⑥特殊：输入输出，其第一个操作数i/ostream，而此操作数又不在编写时类中所定义的，只能友元。（且输入输出改变流状态，故不可const）

格式：friend istream& operator>>(istream&,类名&）；//要返回istream对象的引用：连续读取

调用时括号（istream& 对象名随意如in,C& 对象如a）in>>c----->本质：operator>> (out,a);

二、＜＜,＞＞,+=,-=,+,-,++,--前置和后置的运算符重载见下题中代码。

【问题描述】编写一个程序，定义一个时间类Time，包含三个属性： hour, minute 和 second。

题目其实就是两部分：time类大概结构声明出来+重载函数编写。

像这样先想想提纲，则思路清晰矣。。。唉。。。

要求通过运算符重载实现如下功能:

• 时间输入输出(>>、<<)；  //成员数据不能private

• 时间增加减少若干(+=、-=)，例：Time& operator+=(const Time&);Time& operator-=(const Time&)；

• 时间前、后自增加/减少1秒(++、--)，前自增例：Time& operator++(); 后自增例：Time operator++(int)；

【输入形式】

• 输入固定为两个Time实例(time1，time2),每个实例占一行；

• Time实例输入格式为：hour minute second。

【输出形式】

• Time实例输出格式为：hour:minute:second；

• 每个输出实例占一行。

• 依次输出以下表达式的值

• time1 += (time2++)

• time1 -= time2

• ++time2

• time2 += (time1--)

• --time1

• time2 -= time1     

#include <bits/stdc++.h>
using namespace std;
#define hour 24*3600;
class time {
public:
    int h;
    int m;
    int s;
    int sum;
    void add(){sum=h*3600+m*60+s;
        if(h==0&&m==0&&s==0)sum+=hour;
    }
    void jdg(){ if(sum>=24*3600) sum-=hour;
                if(sum<0) sum+=hour;
    }
    friend time operator+=(time& a,const time &c);
    friend time operator-=(time& a,const time &c);
    friend istream &operator>>(istream &, time &a);
    friend ostream &operator<<(ostream &, const time &a);
    time operator++(int);
    time operator--(int);
    time operator++(){
        ++sum;
        return *this;}
    time operator--() {
        --sum;
        return *this;}
}x,y ;

 先是直接声明一个time类。（sum是总秒数，将小时、分钟都化成秒来计算，这样计算简单）

1、其中定义了两个void函数：分别算出sum、以及用来排除24：XX：XX与负数的情况。

2、剩下就是重载声明，定义可见下文。

3、最后main()里根据问题抄下算式即可。

（如上是整个time类的声明，下面是剩余函数定义和主函数）

class time time::operator ++(int){  //后置++转置时，先创建临时对象xc保存当前对象值并用于返回                                       
   time xc=*this;
   ++(*this);                       //原对象调用前面已经定义过的前置++
   return xc;}
class time time::operator --(int){
    time xc=*this;
    --(*this);
    return xc;
}
istream& operator>>(istream&in,class time& a){          //输入
    in>>a.h>>a.m>>a.s;
    return in;}
ostream& operator<<(ostream&out,class time& a){        //输出，包括一些整理操作
    a.jdg();
    int i,j,k;
    int count=a.sum;
        i=count/3600;count%=3600;
        j=count/60;count%=60;
        k=count;
        out<<setfill('0')<<setw(2)<<i<<":"<<setfill('0')<<setw(2)
            <<j<<":"<<setfill('0')<<setw(2)<<k<<endl;
        return out;
}
class time operator +=(class time& a,const class time& b){    //+=转置
   a.sum+=b.sum;
   a.jdg();
   return a;}
class time operator -=(class time& a,const class time& b){    //-=转置
    a.sum-=b.sum;
    a.jdg();
    return a;
}
int main(){
    cin>>x>>y;
    x.add();
    y.add();
    x+=(y++);
             cout<<x;
    x-=y;
             cout<<x;
    ++y;
             cout<<y;
    y+=(x--);
             cout<<y;
    --x;
             cout<<x;
    y-=x;
             cout<<y;
    return 0;}

【样例输入】

21 10 35
10 15 25

【样例输出】

07:26:00
21:10:34
10:15:27
07:26:01
21:10:32
10:15:29

没说清楚的地方欢迎各位前来询问，感谢支持！