赋值运算符的重载

赋值运算符的重载

运算符重载

C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其返回值类 型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。

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

函数原型：返回值类型 operator操作符(参数列表)

注意：

不能通过连接其他符号来创建新的操作符：比如operator@

重载操作符必须有一个类类型或者枚举类型的操作数

用于内置类型的操作符，其含义不能改变，例如：内置的整型+，不 能改变其含义

作为类成员的重载函数时，其形参看起来比操作数数目少1成员函数的 操作符有一个默认的形参this，限定为第一个形参

.* 、:: 、sizeof 、?: 、. 注意以上5个运算符不能重载。这个经常在笔试选择题中出现。

// 全局的operator==
class Date
{ 
public:
 Date(int year = 1900, int month = 1, int day = 1)
 {
 _year = year;
 _month = month;
 _day = day;
 } 
//private:
 int _year;
 int _month;
 int _day;
};
// 这里会发现运算符重载成全局的就需要成员变量是共有的，那么问题来了，封装性如何保证？
// 这里其实可以用我们后面学习的友元解决，或者干脆重载成成员函数。
bool operator==(const Date& d1, const Date& d2)
{
 return d1._year == d2._year;
 && d1._month == d2._month
 && d1._day == d2._day;
}
void Test ()
{
 Date d1(2018, 9, 26);
 Date d2(2018, 9, 27);
 cout<<(d1 == d2)<<endl;
}

class Date
{ 
public:
 Date(int year = 1900, int month = 1, int day = 1)
 {
 _year = year;
 _month = month;
 _day = day;
 }
 
 // bool operator==(Date* this, const Date& d2)
 // 这里需要注意的是，左操作数是this指向的调用函数的对象
 bool operator==(const Date& d2)
 {
    return _year == d2._year;
     && _month == d2._month
     && _day == d2._day;
     }
private:
 int _year;
 int _month;
 int _day;
};
void Test ()
{
 Date d1(2018, 9, 26);
 Date d2(2018, 9, 27);
 cout<<(d1 == d2)<<endl;
}

赋值运算符重载

class Date
{ 
public :
 Date(int year = 1900, int month = 1, int day = 1)
 {
 _year = year;
 _month = month;
 _day = day;
 }
 
 Date (const Date& d)
 {
 _year = d._year;
 _month = d._month;
 _day = d._day;
 }
 
 Date& operator=(const Date& d)
 {
 if(this != &d)
 {
 _year = d._year;
 _month = d._month;
 _day = d._day;
 }
 }
private:
 int _year ;
 int _month ;
 int _day ;
};

赋值运算符主要有四点：

1. 参数类型

   2.返回值

   3.检测是否自己给自己赋值

   4.返回*this

   5. 一个类如果没有显式定义赋值运算符重载，编译器也会生成一个，完成对象按字节序的值拷贝。

class Date
{
public:
 Date(int year = 1900, int month = 1, int day = 1)
 {
 _year = year;
 _month = month;
 _day = day;
 }
private:
 int _year;
 int _month;
 int _day;
};
int main()
{
 Date d1;
 Date d2(2018，10， 1);
 
 // 这里d1调用的编译器生成operator=完成拷贝，d2和d1的值也是一样的。
 d1 = d2；
 return 0;
}

那么编译器生成的默认赋值重载函数已经可以完成字节序的值拷贝了，我们还需要自己实现吗？当然像 日期类这样的类是没必要的。那么下面的类呢？验证一下试试？

// 这里会发现下面的程序会崩溃掉？这里就需要我们以后讲的深拷贝去解决。
class String
{
public:
 String(const char* str = "")
 {
 _str = (char*)malloc(strlen(str) + 1);
 strcpy(_str, str);
 }
 ~String()
 {
 cout << "~String()" << endl;
 free(_str);
 }
    private:
 char* _str;
};
int main()
{
 String s1("hello");
 String s2("world");
 
 s1 = s2;
}

日期类的实现

class Date
{
public:
 // 获取某年某月的天数
 int GetMonthDay(int year, int month)
 {
 static int days[13] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
 int day = days[month];
 if (month == 2
 &&((year % 4 == 0 && year % 100 != 0) || (year%400 == 0)))
 {
 day += 1;
 }
 return day;
 }
 
 // 全缺省的构造函数
 Date(int year = 1900, int month = 1, int day = 1);
 // 拷贝构造函数
 // d2(d1)
 Date(const Date& d);
 
 // 赋值运算符重载
 // d2 = d3 -> d2.operator=(&d2, d3)
 Date& operator=(const Date& d);
 // 析构函数
 ~Date();
 // 日期+=天数
 Date& operator+=(int day);
 // 日期+天数
 Date operator+(int day);
 // 日期-天数
 Date operator-(int day);
// 日期-=天数
 Date& operator-=(int day);
 // 前置++
 Date& operator++();
 // 后置++
 Date operator++(int);
 // 后置--
 Date operator--(int);
 // 前置--
 Date& operator--();
 
 // >运算符重载
 bool operator>(const Date& d);
 // ==运算符重载
 bool operator==(const Date& d);
 // >=运算符重载
 inline bool operator >= (const Date& d);
 
 // <运算符重载
 bool operator < (const Date& d);
 // <=运算符重载
 bool operator <= (const Date& d);
 // !=运算符重载
 bool operator != (const Date& d);
 // 日期-日期 返回天数
 int operator-(const Date& d);
private:
 int _year;
 int _month;
 int _day;
};