C++运算符重载

对于内置的数据类型，编译器知道如何运算。但是对于自定义数据类型，编译器不知道怎么运算。因此，才衍生出了运算符重载。

1、加号运算符重载；

　　一种方式通过成员函数重载，另一种通过全局函数重载。

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;
};
//通过全局函数重载加号
Person operator+(Person &p1, Person &p2){
    Person temp;
    temp.m_A = p1.m_A + p2.m_A;
    temp.m_B = p1.m_B + p2.m_B;
    return temp;
}
Person operator+(Person &p1, int i){
    Person temp;
    temp.m_A = p1.m_A + i;
    temp.m_B = p1.m_B + i;
    return temp;

}
void test01(){
    Person p1;
    p1.m_A = 10;
    p1.m_B = 10;
    Person p2;
    p2.m_A = 10;
    p2.m_B = 10;
    Person p3;
    p3 = p1 + p2;
    Person p4;
    //p4 = p1 + 10; 简化
    p4 = operator+(p1, 100);
    cout << p3.m_A <<" "<< p3.m_B << endl;
    cout << p4.m_A << " " << p4.m_B << endl;
}

2、左移运算符重载

　　如果想直接输出自定义对象，只能用全局函数重载左移运算符,用成员函数重载左移运算符不能实现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 <<"  " << p.m_B ;
    return cout;
}
void test01(){
    Person p1(10,20);
    cout << p1 << endl; //链式编程思想
}
int main(){
    test01();
    system("pause");
}

3、递增运算符重载

#include<iostream>
using namespace std;
class MyInteger{
    friend ostream & operator<<(ostream &out, MyInteger &p);
public:
    MyInteger(){
        m_Int = 0;
    }
    //重载前置++运算符
    MyInteger & operator++(){
        m_Int++;
        return *this;
    }
    //重载后置++运算符
    MyInteger operator++(int){//int表示占位参数，可以用于区分前置和后置
        //先记录
        MyInteger temp = *this;
        //递增
        m_Int++;
        //返回记录
        return temp;
    }

private:
    int m_Int;
};
//重载左移运算符
ostream & operator<<(ostream &out, MyInteger &p){
    cout << p.m_Int;
    return out;
}
void test01(){
    MyInteger myint;
    cout << ++(++myint) << endl;
    cout << myint << endl;
}
void test02(){
    MyInteger p1;
    cout << p1++ << endl;
    cout << p1 << endl;
}
int main(){
    /*test01();*/
    test02();
    system("pause");
}

　　后置++，返回值不能是引用，因为temp是一个局部变量，当函数执行完毕temp被释放，再对temp进行操作就是非法的。

4、赋值运算符重载。

　　编译器会给一个类至少添加四个函数：

　　a.默认的构造函数；（空实现）

　　b.默认析构函数；（空实现）

　　c.默认拷贝构造函数；（简单值拷贝）

　　d.赋值运算符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;
        }
    }
    //重载赋值运算符
    Person & operator = (const Person &p){
        //先把堆区的属性释放干净，然后再深拷贝
        if (m_Age!=NULL)
        {
            delete m_Age;
            m_Age = NULL;
        }
        //编译器提供 m_Age = p.m_Age;
        m_Age = new int(*p.m_Age);//深拷贝
        return *this;
    }
    int *m_Age;
};
void test01(){
    Person p1(18);
    Person p2(20);
    Person p3(1);
    p3=p1 = p2;//赋值  会重复释放
    cout << *p2.m_Age << endl;
    cout << *p3.m_Age << endl;

}
int main(){
    test01();
    system("pause");
}

　　以上重载赋值运算符严格来说是有问题的，假设一个特殊情况，p1=p1，自我赋值，如果一上来就执行第19行代码，m_Age所指的空间已经释放了，后面如何进行深拷贝？

　修改后的写法

Person &operator=(const Person&p)
{
   if(&p==this)    //自我赋值检查
    {
        return *this;  
    }  
   delete m_Age;
   m_Age=new int(*p.m_Age);
  return *this;
}

 

5、关系运算符重载

#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_Age == p.m_Age && this->m_name == p.m_name)
        {
            return true;
        }
        else
        {
            return false;
        }
    }
    bool operator!=(Person &p){
        if (this->m_Age != p.m_Age || this->m_name != p.m_name){
            return true;
        }
        else
        {
            return false;
        }
    }
    string m_name;
    int m_Age;
};
void test01(){
    Person p1("tom", 18);
    Person p2("tom", 18);
    if (p1==p2)
    {
        cout << "p1和p2相等" << endl;
    }
    else if (p1!=p2)
    {
        cout << "不相等" << endl;
    }

}
int main(){
    test01();
    system("pause");
}

6、重载小括号

　　又称仿函数。

#include<iostream>
#include<string>
using namespace std;
class Myprint{
public:
    void operator()(string test)
    {
        cout << test << endl;
    }
};
int main()
{
    Myprint print;
    print("hello world");
    system("pause");
}