C++基础12——运算符重载

加号运算符重载

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

对于内置的数据类型的表达式的运算符是不可以改变的

    class Person
    {
    public:
    	int a;
        int b;
        
        //1. 成员函数重载
        Person operator+(Person &p){//operator+是通用的
        	Person tmp;
            tmp.a=this->a+p.a;
            tmp.b=this->b+p.b;
            return tmp;
        }
    }
    
    //2. 全局函数重载+
    Person operator+(Person& p1,Person& p2){
        Person tmp;
        tmp.a=p1.a+p2.a;
        tmp.b=p1.b+p2.b;
        return tmp;
    }
    
    void test(){
    	Person p1;
        p1.a=10;
        p1.b=10;
        Person p2;
        p2.a=20;
        p2.b=20;
        
        Person p3;
        p3=p1+p2;
    }
    
    
    

左移运算符重载

class Person{
public:
	int a;
    int b;
    
    //一般不利用成员函数重载<<，因为无法实现cout在左侧
    void operator<<(cout){}
};

ostream operator<<(ostream &out,Person p)//本质运算为<<(cout,p)，简化为cout<<p
{
	out<<p.a<<" "<<p.b;
    return cout;//为了链式编程
    //也可return out;
}

int main(){
	Person p;
    cout<<p<<endl;
}

递增运算符重载

    class myInt{
    	myInt(){
        	myNum=0;
        }
        friend ostream& operator<<(ostream& out,myInt myint);
        
        //重载++运算符：前置
        //返回引用是为了一直对同一个数据进行操作
        myInt& operator++()
        {
        	myNum++;
            return *this;
        }
        
        //int表示占位参数，用于区分前置和后置递增
        myInt operator++(int)
        {
        	myInt tmp=*this;//先记录结果
        	myNum++;
            return tmp;
        }
        //后置递增返回的是值，因为tmp是局部变量，返回局部变量会出错
        
    private:
    	int myNum;
    };
    ostream& operator<<(ostream& out,myInt myint){
    	out<<myint<<endl;
        return out;
    }
    
    int main()
    {
    	myInt myint;
        cout<<++(++myint);
        cout<<myint++;
    }
    

赋值运算符重载

C++编译器会默认给类添加赋值运算符operator+，对属性进行值拷贝

	class Person{
    public:
    	Person(int age){
        	mAge=new int(age);
        }
        ~Person()
        {
        	if(mAge!=NULL){
            	delete mAge;
                mAge=NULL;
            }
        }
        
        //重载=
        Person& operator=(Person &p){
        	//先判断是否有属性在堆区，如果有先释放干净，再深拷贝
            if(mAge!=NULL){
            	delete mAge;
                mAge=NULL;
            }
            mAge=new int(*p.mAge);
            return *this;//可连=
        }
        
    	int *mAge;
    }
    
    int main(){
		Person p1(18);
        Person p2(20);
        p2=p1;
    }

关系运算符重载

class Person{
    	public:
    bool operator==(Person& p){
    	if(this->name==p.name){
        	return true;
        }
    }
}

函数调用运算符重载

即仿函数

    class myprint{
    public:
    	void operator()(string test){
        	cout<<test<<endl;
        }
    };
    
    int main(){
    	myprint p;
        p("hhhhh");
    }