C++运算符重载

加法运算符重载

在C++中除了函数可以重载之外，一些运算符也是可以重载的，首先是加法运算符，加法运算符可以实现两个数相加，但是自定义的属性比如类是不能相加的Class+Class在没有重载前编译器是不认识的，这里可以借助operator写一个函数来实现运算符的重载

格式： 类型+operator+（）{}

#include <iostream>
#include <string>
using namespace std;
class add{
        public:
        add(){
        }
        add(int a,int b){
                this->a=a;
                this->b=b;
        }
        add operator+(add num){
                add temp;
                temp.a=this->a+num.a;
                temp.b=this->b+num.b;
                return temp;
        }
        int a;
        int b;
};
void test(){
        add d1(10,20);
        add d2(100,200);
        add d3=d1+d2;
        cout<<"a的值是："<<d3.a<<"\n"<<"b的值是"<<d3.b<<endl;
}
int main(){
        test();
        return 0;
}

这里返回值是自定义类，然后创建一个类来接收，并且这个函数是类的成员，当然也可以用全局函数来定义，参数就需要传递两个了，这里就不举例了，如果想重载减法方法是一样的。

左移运算符重载

一般我们需要输出类中的成员需要cout<<class.a<<class.b<<endl,那么可不可以直接用类名来输出类中的成员呢，这就需要我们重载左移运算符了,这里的cout它其实是属于ostream类中的，所以在重载时，类型也需要时ostream。

格式 ：ostream & operator<<(){}

#include <iostream>
#include <string>
using namespace std;
class add{
        public:
        add(){
        }
        add(int a,int b){
                this->a=a;
                this->b=b;
        }
        int a;
        int b;
};
        ostream &operator <<(ostream &out,add &num){
        out<<"a的值是："<<num.a<<"\n"<<"b的值是"<<num.b<<endl;
          return out;
                        }
void test(){
        add d1(10,20);
        cout<<d1;
}
int main(){
        test();
        return 0;
}

虽然重载运算符是可以用全局函数和类中函数，但重载左移运算符时建议还是使用全局函数，因为如果用了类中函数就需要用两个类来操作，显然不是我们想要的

递增运算符重载

前置运算符

当重载前置运算符时不需要带参数

#include <iostream>
#include <string>
using namespace std;
class add{
        public:
        add(){
        }
        add(int a,int b){
                this->a=a;
                this->b=b;
        }
        add& operator ++(){

                this->a++;
                return *this;
        }
        int a;
        int b;
};
        ostream &operator <<(ostream &out, const add &num){
                out<<num.a;
                return out;
        }
void test(){
        add d1(10,20);
        cout<<++(++d1)<<endl;
}
int main(){
        test();
        return 0;
}

后置运算符

当重载后置运算符时需要带参数，否则会报错

#include <iostream>
#include <string>
using namespace std;
class add{
        public:
        add(){
        }
        add(int a,int b){
                this->a=a;
                this->b=b;
        }
        add operator ++(int){
                add temp=*this;
                this->a++;
                return temp;
        }
        add& operator ++(){
                this->a++;
                return *this;
        }
        int a;
        int b;
};
        ostream &operator <<(ostream &out,const add &num){
                out<<num.a;
                return out;
        }
void test(){
        add d1(10,20);
        cout<<(d1++)++<<endl;
        cout<<d1<<endl;
}
int main(){
        test();

        return 0;
}

这里的右置操作符，返回的是个常量，所以在左移运算符中需要定义常量const

赋值运算符重载

赋值两边需要是相同的类型也就是相当于拷贝，不论是已有的类型还是自定义的类型编译器都可以用赋值，但这是浅拷贝，但是如果类成员中有指针类型的成员，浅拷贝在析构函数里会造成空间的重复释放，我们可以重载赋值运算符来使程序避免浅拷贝。

#include <iostream>
#include <string>
using namespace std;
class add{
        public:
        add(){
        }
        add(int a){
                this->a=new int(a);
        }
        ~add(){
                if(a!=NULL){
                        delete a;
                        a=NULL;
                }
        }
        add &operator =(add &tem){
                if(this->a!=NULL){
                        delete this->a;
                        this->a=NULL;
                }
                this->a=new int (*tem.a);
                return *this;
        }
        int *a;
};
void test(){
        add d1(10);
        add d2(2);
        d2=d1;
        cout<<"d1的值是："<<*d1.a<<endl;
        cout<<"d2的值是："<<*d2.a<<endl;
}
int main(){
        test();

        return 0;
}

关系运算符重载

关系运算符只能判断基本变量是否相同，而自定义变量是不能判断的所以可以重载关系运算符来判断两个对象是否相同。

#include <iostream>
#include <string>
using namespace std;
class add{
        public:
        add(){
        }
        add(int age,string name){
                this->name=name;
                this->age=age;
        }
        bool operator ==(add &tem){
                if(this->name==tem.name&&this->age==tem.age){
                        return true;
                }
                        return false;
        }
        int age;
        string name;
};
void test(){
        add d1(20,"李四");
        add d2(20,"李四");
        cout<<(d1==d2)<<endl;
}
int main(){
        test();
        return 0;
}