01 运算符重载

1、重载加法运算符

#include <iostream>
using namespace std;

class Person{
public:
    Person(int age){
        this->age=age;
    }
//    Person operator+(Person& p )
//    {
//        Person tmp(0);
//        tmp.age=this->age+p.age;
//        return  tmp;
//    }
public:
    int age;
};

//如果返回的是引用，因为p3是个对象，还是会调用到拷贝构造函数，所以这里如果返回的是Person引用，没什么效果
Person operator+(Person& p1,Person& p2){
    Person tmp(0);
    tmp.age=p1.age+p2.age;
    return tmp;
}

int main(){
    Person p1(1);
    Person p2(2);

    Person p3=p1+p2;
    cout<<p3.age<<endl;
    return 0;
}

2、重载自加运算符

#include <iostream>
using namespace std;


/**
 * 注意ostream &operator<<(ostream& cout, MyInteger myInteger);第二个参数不能是MyInteger& myInteger
 */
class MyInteger{
    friend ostream &operator<<(ostream& cout, MyInteger myInteger);
public:
    MyInteger(int num){
        this->num=num;
    }

    MyInteger& operator++(){
        num++;
        return *this;
    }

    MyInteger operator++(int)
    {
        MyInteger tmp(*this);
        num++;
        return tmp;
    }

public:
    int num;
};

ostream& operator<<(ostream& cout, MyInteger myInteger){
    cout<<myInteger.num;
    return cout;
}

int main(){
    MyInteger myInt(1);
    cout << ++(++myInt) <<endl;
    cout << myInt << endl;
    cout<<myInt++<<endl;
    cout << myInt << endl;
    return 0;
}

3、重载左移运算符

#include <iostream>
using namespace std;
/**
 * 关键点：
 * 1.返回引用:可以连续多次<<
 * 2.声明为友元函数:访问类的私有变量
 */
class Person{
    friend ostream& operator<<(ostream& cout,Person& p);
public:
    Person(int age){
        this->age=age;
    }

private:
    int age;
};

ostream& operator<<(ostream& cout,Person& p){
    cout<<p.age<<endl;
}

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

4、重载赋值运算符

#include <iostream>
using namespace std;

class Person{
public:
    Person(int age){
        this->age=new int(age);
    }

    Person(const Person& p){
        age=new int(*p.age);
    }

    ~Person(){
        if (age != nullptr)
        {
            delete age;
            age=nullptr;
        }
    }
    /**
     * 解法一
     * @param p
     * @return
     */
    //1、返回的是常量引用，以便可以使用a=b=c
    //2、传入的形参为常量引用，避免调用拷贝构造函数，提升效率
//    Person&operator=(const Person& p){
//        //3、要先判断是否是自身，否则一旦释放了自身的内存就会出现严重问题
//        if (this == &p){
//            return  *this;
//        }
//
//        //4、要释放自身已有的内存，避免内存泄漏
//        if (age != nullptr){
//            delete age;
//            age=nullptr;
//        }
//
//        age=new int(*p.age);
//
//        return *this;
//    }

    /**
     * 解法2：考虑异常安全性
     */
     Person&operator=(const Person& p)
    {
         if(this != &p){
             Person tmp(p);
             int * ptmp=tmp.age;
             tmp.age = age;
             age=ptmp;
         }
        return  *this;
    }
public:
    int *age;
};

int main() {

    Person p1(10);
    Person p2(20);
    Person p3(0);
    p3=p2=p1;
    cout<<*p1.age<<endl;
    cout<<*p2.age<<endl;
    cout<<*p3.age<<endl;
    return 0;
}

剑指offer上面的赋值运算符重载：

#include <iostream>
#include <cstring>
using namespace std;

class CMyString
{
public:
    CMyString(char* pData = nullptr);
    CMyString(const CMyString& str);
    ~CMyString(void);

    CMyString& operator = (const CMyString& str);

    void Print();

private:
    char* m_pData;
};

CMyString::CMyString(char* pData ){
    if(pData== nullptr){//容易忽略掉这步
        m_pData=new char[1];
        *m_pData=0;
    } else{
        int len=strlen(pData);
        m_pData=new char[len+1];
        strcpy(m_pData,pData);
    }

}
CMyString::CMyString(const CMyString& str){
    int len=strlen(str.m_pData);
    m_pData=new char[len+1];
    strcpy(m_pData,str.m_pData);
}
CMyString::~CMyString(void){
    if (m_pData!=nullptr){
        delete[] m_pData;
        m_pData= nullptr;
    }
}

CMyString& CMyString::operator = (const CMyString& str){
    if (this!=&str){
        CMyString tmp(str);
        char* tmp_p=tmp.m_pData;
        tmp.m_pData=m_pData;
        m_pData=tmp_p;
    }
    return *this;
}

void CMyString::Print(){
    cout<<m_pData<<endl;
}

//测试赋值运算符是否能用
void test01(){
    CMyString str1("hello");
    CMyString str2;
    str2=str1;
    str1.Print();
    str2.Print();
}

//自己赋值给自己
void test02(){
    CMyString str1("world");
    str1=str1;
    str1.Print();
}

//连续赋值
void test03(){
    CMyString str1("today");
    CMyString str2;
    CMyString str3;
    str3=str2=str1;
    str1.Print();
    str2.Print();
    str3.Print();
}

int main(){
    test01();
    test02();
    test03();
    return 0;
}