C++ ——赋值运算符重载函数

---

前言

在介绍赋值运算符重载之前，我们先看一段代码：

class Complex    //定义一个复数类
{
public:
    Complex (double r = 0.0,double i = 0.0) //构造函数
    {
        _real = r;
        _imag = i;
    }
    void Show()const;
private:
    double _real,_imag;
};
int main()
{
    //声明2个对象
    Complex a(10,20);
    Complex b (20,30);
    return 0;
}

此时，如果我们需要对a和b进行加法运算该咋整？一般情况下我们自然都能想到使用" + “运算符，写出一个表达式:” a + b"，但是很遗憾，编译的时候必会报错，因为编译器不知道该怎么处理这个加法，这个时候就需要我们自己来编写作用在Complex类对象的"+"功能，这便引出了运算符重载

一、赋值运算符重载函数是什么？

赋值运算符重载是对已经有的运算符赋予多重含义，使同一个运算符作用于不同类型的数据时有着不同的含义。

函数名为：关键字operator后面加上需要重载的运算符符号

函数原型：

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

Notes：运算符重载的实质就是函数的重载：在实现的过程中，首先把指定的运算表达式转化为对运算符的调用，将运算对象转化为运算符函数的参数，然后根据参数的类型来确定需要调用的函数。

二、细谈赋值运算符重载函数

2.1 参数列表

一般情况下，赋值运算符重载函数的参数是函数所在类的const类型的引用，加const的引用原因如下：

1. 程序员不希望在函数中对已经用const修饰的值做任何修改。
2. 加上const后，对于const和非const的参数，函数就能接受；如果不加，就只能接受非const的参数。

加引用的原因:

加上引用后可以有效的避免函数调用时对实参的拷贝，提高了程序的效率。

Notes：以上的规定不是强制性规定。可以不加const，也可以没有引用，甚至参数可以不是函数所在的对象。

2.2 返回值

一般情况下，返回值是被赋值者的引用，即*this，原因如下：

1. 返回*this，避免了函数的一次拷贝，提高程序效率。
2. 返回引用还可以达到连续赋值的作用，比如"a = b = c"。如果返回类型不是引用而是返回值类型，那么在执行b = c 时候，调用赋值运算符重载函数，在函数返回的时候，会形成一个无名的临时对象，接着拷贝临时对象，然后将这个临时对象返回，但是这临时对象是一个右值，再进行a = 时候，会出错。

2.3调用时机

当为一个类对象赋值时，会由该对象调用该类的赋值运算符重载函数。

    MyStr str1;
    str1 = str2;
    MyStr str3 = str2;

比如上述例子，定义个MyStr的类。第二个语句和第三个语句在调用函数上面是有区别的。

MyStr str1；是str1的声明加定义，调用无参数的构造函数，所以str2 = str1时在str1已经存在的情况下用str2来为str1赋值，调用赋值运算符重载函数；而MyStr str3 = str2；调用的是拷贝构造函数。

二、赋值运算符重载函数练习

定义一个日期类，实现各种运算符重载:

#include 
#include 
using namespace std;

class Date
{
    friend ostream& operator<<(ostream& out,Date &d);
    friend istream& operator>>(istream& is,Date &d);
public:
    //构造
    explicit Date (int year = 1900,int month = 1,int day = 1)
    {
        //判断参数是否合法
        if ((year >= 1900) && (month >= 1) && (day >= 1))
        {
            _year = year,_month = month,_day = day;
        }else{
            cout<<"日期非法"<<endl;
            _year = 1900,_month =  1,_day = 1;
        }
    }
    //拷贝构造
    Date (const Date &d)
    {
        _year = d._year,_month = d._month,_day = d._day;
    }
    //赋值重载函数
    Date& operator=(const Date &d);
    bool operator==(const Date &d);
    bool operator!=(const Date &d);
    bool operator>(const Date &d);
    bool operator>=(const Date &d);
    bool operator<(const Date &d);
    bool operator<=(const Date &d);
    Date operator+(int day);
    Date& operator+=(int day);
    Date operator-(int day);
    int  operator-(const Date &d);
    Date& operator-=(int day);
    Date& operator++();
    Date operator++(int);
    Date& operator--();
    Date operator--(int);

    //析构
    ~Date() = default;

public:
    //得到某年当前月的天数
    int GetDayOfMonth(int year,int month)
    {
        assert(month > 0 && month <= 12);
        int Month_arr[13] = {0,31,29,31,30,31,30,31,31,30,31,30,31};
        int day;
        //如果不是闰年并且不是2月
        if (!(IsLeapYear()) && month == 2)
            day = Month_arr[month] - 1;
        day = Month_arr[month];
        return day;
    }

    //判断是不是闰年
    bool IsLeapYear()
    {
        return (_year % 4 == 0 && _year % 100 != 0) || (_year % 400 == 0);
    }
private:
    int _year,_month,_day;
};

ostream& operator<<(ostream& out,Date &d)
{
    out<<d._year<<"-"<<d._month<<"-"<<d._day<<endl;
    return out;
}

istream& operator>>(istream& is,Date &d)
{
    cout<<"请输入日期：";
    is >>d._year;
    is >>d._month;
    is >>d._day;
    return is;

}

Date& Date::operator=(const Date &d)
{
    if (*this != d)
    {
        _year = d._year,_month = d._month,_day = d._day;
    }
    return *this;
}

bool Date::operator==(const Date &d)
{
    return (_year == d._year) && (_month == d._month) && (_day == d._day);
}

bool Date::operator!=(const Date &d)
{
    return !(*this == d);
}

bool Date::operator>(const Date &d)
{
    return (_year > d._year) || ((_year == d._year) && (_month > d._month)) || ((_year == d._year) && (_month == d._month) && (_day > d._day));
}

bool Date::operator>=(const Date &d)
{
    return (*this == d) || (*this > d);
}

bool Date::operator<(const Date &d)
{
    return (_year < d._year) || ((_year == d._year) && (_month < d._month)) || ((_year == d._year) && (_month == d._month) && (_day < d._day));
}

bool Date::operator<=(const Date &d)
{
    return (*this == d) || (*this < d);
}

Date& Date::operator++()
{
    *this = *this + 1;
    return *this;
}

Date Date::operator++(int)
{
    Date tmp = *this;
    *this += 1;
    return tmp;
}

Date& Date::operator--()
{
    *this -= 1;
    return *this;
}

Date Date::operator--(int)
{
    Date tmp = *this;
    *this -= 1;
    return tmp;
}

Date Date::operator+(int day)
{
    Date tmp = *this;
    if (day < 0)
    {
        return tmp - (-day);
    }
    tmp._day = tmp._day + day;
    while (tmp._day > GetDayOfMonth(tmp._year,tmp._month))
    {
        tmp._day = tmp._day - GetDayOfMonth(tmp._year,tmp._month);
        if (tmp._month == 12)
        {
            tmp._year++;
            tmp._month = 1;
        }else{
            tmp._month++;
        }
    }
    return tmp;
}

Date& Date::operator+=(int day)
{
    *this = *this + day;
    return *this;
}

Date Date::operator-(int day)
{
    Date tmp = *this;
    if (day < 0)
    {
        return tmp + (-day);
    }
    tmp._day = tmp._day - day;
    while (tmp._day <= 0)
    {
        if (tmp._month == 1)
        {
            tmp._year--;
            tmp._month = 12;
        }else{
            tmp._month = tmp._month - 1;
        }
        tmp._day = tmp._day + GetDayOfMonth(tmp._year,tmp._month);
    }
    return tmp;
}

Date& Date::operator-=(int day)
{
    *this = *this - day;
    return *this;
}

int Date::operator-(const Date &d)
{
    Date Max = *this;
    Date Min = d;
    int flag = 1;
    if (*this < d)
    {
        Min = *this;
        Max = d;
        flag = -1;
    }
    int day = 0;
    while (Max != Min)
    {
        --Max;
        ++day;
    }
    return flag * day;
}