赋值重载

赋值重载也是默认成员函数之一，相对于其它函数，函数名比较特殊，函数名字为：关键字operator后面接赋值重载的运算符符号。

语法：返回值类型 operator操作符(参数列表)。 参数类型：const T&，传递引用可以提高传参效率。 返回值类型：T&，返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值。

#include using namespace std;class Date
{
public://构造函数Date(int year = 1900, int month = 1, int day = 1){cout << "构造函数Date()" << endl;_year = year;_month = month;_day = day;}//拷贝构造Date(const Date& d){cout << "拷贝构造Date(const Date& d)" << endl;_year = d._year;_month = d._month;_day = d._day;}//赋值重载Date& operator=(const Date& d){cout << "赋值重载" << endl;if (this != &d){_year = d._year;_month = d._month;_day = d._day;}return *this;}
private:int _year;int _month;int _day;
};
int main()
{Date d1(2001,10,3);Date d2(d1);Date d3;d3 = d2;return 0;
}

 观察上述代码效果，调用了显示定义的赋值重载，完成了对象间的赋值。那么既然赋值重载也是默认成员函数，不显示定义，编译器会自动生成。

屏蔽掉显示定义的赋值重载函数后，对象间依然完成了赋值：

 其实，当用户没有显式实现时，编译器会生成一个默认赋值运算符重载，以值的方式逐字节拷贝。注 意：内置类型直接赋值，而自定义类型调用对应类的赋值运算符重载完成赋值。

class Time
{
public:
Time()
{_hour = 1;_minute = 1;_second = 1;
}Time& operator=(const Time& t){cout << "_t赋值重载operator=" << endl;if (this != &t){_hour = t._hour;_minute = t._minute;_second = t._second;}return *this;}
private:int _hour;int _minute;int _second;
};
class Date
{
private:// 基本类型int _year = 2001;int _month = 10;int _day = 3;// 自定义类型Time _t;
};
int main()
{Date d1;Date d2;d1 = d2;return 0;
}

 

 对于上述日期类，没有涉及到资源的申请，赋值重载是否实现都可以； 一旦涉及到资源管理则必须要实现。 （代码演示以栈为例）

typedef int DataType;
class Stack
{
public:Stack(int capacity = 10){_arr = (DataType*)malloc(capacity * sizeof(DataType));if (nullptr == _arr){perror("malloc faile:");exit(-1);}_size = 0;_capacity = capacity;}void Push(const DataType& data){_arr[_size] = data;_size++;}~Stack(){if (_arr){free(_arr);_arr = nullptr;_capacity = 0;_size = 0;}}
private:DataType* _arr;int _size;int _capacity;
};
int main()
{Stack s1;s1.Push(1);s1.Push(2);Stack s2;s2 = s1;return 0;
}

 出现的错误和拷贝构造资源申请，未显示定义拷贝构造的错误类似。

当s1赋值给s2时，编译器会将s1中内容原封不动的拷贝到s2中，这样会导致两个问题：

♠s2原本的内存空间丢失，造成了内存泄露。

♠s1/s2共享同一块内存空间，最后销毁时导致同一快空间释放了两次。

显示定义： 

typedef int DataType;
class Stack
{
public:Stack(int capacity = 10){_arr = (DataType*)malloc(capacity * sizeof(DataType));if (nullptr == _arr){perror("malloc faile:");exit(-1);}_size = 0;_capacity = capacity;}Stack& operator=(const Stack& s){if (this != &s){_arr = (DataType*)malloc(10 * sizeof(DataType));for (int i = 0; i < s._size; i++){_arr[i] = s._arr[i];}_size = s._size;_capacity = s._capacity;}return *this;}void Push(const DataType& data){_arr[_size] = data;_size++;}~Stack(){if (_arr){free(_arr);_arr = nullptr;_capacity = 0;_size = 0;}}
private:DataType* _arr;int _size;int _capacity;
};
int main()
{Stack s1;s1.Push(1);s1.Push(2);Stack s2;s2 = s1;return 0;
}

● 赋值运算符只能重载成类的成员函数不能重载成全局函数 。

用户在类外实现全局的赋值运算符重载，会和编译器在类中生成的默认赋值运算符重载冲突，故赋值运算符重载只能是类的成员函数。

运算符重载

除了赋值运算符之外，像+、-、*、/等这样的运算符一直伴随着我们的学习生活，对于我们来说“见其知其意”，为了增强代码的可读性引入了运算符重载。

运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。 

以日期类为例，学习运算符重载：

 Date.h(预览日期类大概功能)

#pragma once#include using namespace std;class Date
{
public://全缺省构造Date(int year = 2020, int month = 12, int day = 28){_year = year;_month = month;_day = day;}//计算某年某月的天数int GetMonthDay(int year, int month){//平年各月的天数int LeapYear[13] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };//闰年2月29天if (month == 2 && ((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0)){return 29;}return LeapYear[month];}//赋值重载//析构函数//拷贝构造void Print(){cout << _year << "/" << _month << "/" << _day << endl;}//运算符重载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);//日期-天数Date operator-(int day);//前后置++Date& operator++();Date operator++(int);//前后置--Date& operator--();Date operator--(int);//日期-日期 返回天数int operator-(Date date);
private:int _year;int _month;int _day;
};

♥默认成员函数

日期类的实现不涉及资源的申请，拷贝构造，赋值运算符重载，析构函数使用编译器自动生成的即可。

♥计算某年某月的天数

重点在于区分平年和闰年的2月，闰年的2月有29天，平年的2月有28天。其余的月份是相同的。

int GetMonthDay(int year, int month){//平年各月的天数int LeapYear[13] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };//闰年2月29天if (month == 2 && ((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0)){return 29;}return LeapYear[month];}

♥运算符重载

语法：返回值类型 operator操作符(参数列表)。

形参看起来少一个，其实还有隐藏的this指针。

bool  Date::operator==(const Date& d)
{return _year == d._year&& _month == d._month&& _day == d._day;
}
bool  Date::operator> (const Date& d)
{if (_year > d._year){return true;}else if (_year == d._year && _month > d._month){return true;}else if (_year == d._year && _month == d._month && _day > d._day){return true;}return false;
}
bool  Date::operator>=(const Date& d) 
{return *this > d || *this == d;
}
bool  Date::operator<(const Date& d) 
{return !(*this >= d);
}
bool  Date::operator<=(const Date& d)
{return *this < d || *this == d;
}
bool  Date::operator!=(const Date& d)
{return !(*this == d);
}

小技巧：实现了前两个运算符重载后，后面的重载可以复用前面已经实现过的。但是一定要确保已经实现的没有错误！

♥日期+、+=、-、-=天数

这里要注意的环节就是，日期+-过程中的进位、借位问题。生活常识我们都知道，一个日期的天数、月份、年份均不能是负数，是0也不合适，例如：2020年0月0日，-1年-4月-6日，每个月的天数不能超过该年月的天数，其年份的月数也不可能超过12！还有要注意的就是，-和-=,+和+=的区别，-=和+=是改变了自身的数据，-和+是在源数据的基础上通过+、-操作获得一个数据。

//日期+=天数
Date& Date::operator+=(int day)
{_day += day;while (_day > GetMonthDay(_year, _month)){_day -= GetMonthDay(_year, _month);_month++;if (_month == 13){_month = 1;_year++;}}return *this;
}
//日期+天数
Date  Date::operator+(int day)
{Date ret(*this);ret += day;return ret;
}//日期-天数
Date& Date::operator-=(int day)
{//要减去的天数可能大于月天数_day -= day;while (_day <= 0){_month--;if (_month == 0){_year--;_month = 12;}//_day是负数_day += GetMonthDay(_year, _month);}return *this;
}
//日期-天数
Date  Date::operator-(int day)
{Date tmp(*this);tmp -= day;return tmp;
}

♥前后置++、--

为了让前置++(--)与后置++(--)形成能正确重载 。C++规定：后置++（--）重载时多增加一个int类型的参数，但调用函数时该参数不用传递，编译器 自动传递!!!

Date& Date::operator++()
{*this += 1;return *this;
}
Date  Date::operator++(int)
{Date ret(*this);*this += 1;return ret;
}
// 前置
Date& Date::operator--()
{*this -= 1;return *this;
}// 后置
Date Date::operator--(int)
{Date tmp = *this;*this -= 1;return tmp;
}

♥日期-日期

两个日期的相减可以计算出这之间的天数，首先要处理的就是大小日期的问题。当小日期-大日期的时候就说明得出的天数是我们已经度过的过去天数，大日期-小日期就是未来在过多少天才能到达大日期。这里用了一个标记变量来标记是哪一种情况。计算日期的天数，只要小日期还不等于大日期，就计数，最后得到的天数和标记就是我们要得到的综合信息。

//日期-日期 返回天数
int  Date::operator-(Date date)
{Date max = *this;Date min = date;int flag = 1;int count = 0;if ((*this) < date){max = date;min = *this;int flag = -1;}while (max != min){++min;++count;}return flag * count;
}

 const成员

const修饰的“成员函数”称之为const成员函数，const实际修饰的是该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进行修改。

例如：

class Date
{
public:Date(int year, int month, int day) {_year = year;_month = month;_day = day;}void Print() const{cout << "Print()const" << endl;_year = 2021;_month = 10;_day = 3;}
private:int _year; int _month; int _day; 
};

const修饰this指针

void Print() const  等价于 void Print(const Date* this)

♣ const对象可以调用非const成员函数吗？ 权限的放大，不可以！ ♣非const对象可以调用const成员函数吗？ 权限的缩小，可以！ ♣ 非const成员函数内可以调用其它的const成员函数

bool  Date::operator==(const Date& d) const
{return _year == d._year&& _month == d._month&& _day == d._day;
}
bool  Date::operator> (const Date& d) const
{if (_year > d._year){return true;}else if (_year == d._year && _month > d._month){return true;}else if (_year == d._year && _month == d._month && _day > d._day){return true;}return false;
}
bool  Date::operator>=(const Date& d) 
{return *this > d || *this == d;
}

可以，权限的缩小。

♣const成员函数内可以调用其它的非const成员函数吗？

bool  Date::operator> (const Date& d) 
{if (_year > d._year){return true;}else if (_year == d._year && _month > d._month){return true;}else if (_year == d._year && _month == d._month && _day > d._day){return true;}return false;
}
bool  Date::operator>=(const Date& d) const
{return *this > d || *this == d;
}

不可以，权限的放大。

取地址及const取地址操作符重载  

在开头就介绍过，这两个默认成员函数使用编译器生成的默认取地址的重载即可，很少需要自己实现，知道有这两兄弟即可。

 Date* operator&(){return this ;}const Date* operator&()const{return this ;}