目录
一、类的默认成员函数
构造函数：完成对象的初始化
析构函数：完成对象内容的清理
拷贝构造函数：使用已存在的同类对象初始化另外一个对象
赋值运算符重载函数：把一个已存在对象赋值给另外一个同类的已存在对象
取地址运算符重载：主要是普通对象和const对象取地址
二、构造函数
构造函数是特殊的成员函数，需要注意的是，构造函数虽然名称叫构造，但是构造函数的主要任务并不是开空间创建对象(我们常使⽤的局部对象在栈帧创建时空间就开好了)，⽽是对象实例化时初始化对象。构造函数的本质是要替代我们以前写的Init函数的功能，构造函数具有⾃动调⽤的特点，就不需要再手动调用Init函数了
2.1构造函数的特点
1.函数名与类名相同
2. ⽆返回值 (返回值不需要给，也不需要写void)
3. 对象实例化时系统会⾃动调用对应的构造函数
4. 构造函数可以重载
5. 如果类中没有显式定义构造函数，则C++编译器会⾃动⽣成⼀个⽆参的默认构造函数，一旦用户显式定义编译器将不再⽣成
6.参构造函数、全缺省构造函数、不写构造时编译器默认⽣成的构造函数，都叫做默认构造函数。某人构造函数有且只有⼀个存在，不能同时存在。⽆参构造函数和全缺省构造函数虽然构成函数重载，但是调⽤时会存在歧义，不能同时存在。不传实参就可以调用的构造就叫默认构造。
7. 我们不写，编译器默认⽣成的构造，对内置类型成员变量的初始化不做处理，也就是说是是否初始化是不确定的，看编译器。对于⾃定义类型成员变量，要求调用这个成员变量内部的默认构造函数初始化。如果这个成员变量，没有默认构造函数，那么就会报错，我们要初始化这个成员变量需要⽤初始化列表才能解决。
C++把类型分为内置类型：原生数据类型如int/double/float，和自定义类型：我们使用关键字如class/struct自己定义的类型
2.2代码分析
需要注意的是，在初始化对象时，我们可以传参也可以不传参，无参调用不能显示（），因为这样编译器无法区分它是函数声明还是函数调用
2.3析构函数场景分析
1.当我们在实现日期类（只含内置类型）或者不含自定义类型的成员变量，可以不写构造函数，但前提是编译器自动生成的默认构造函数符合我们的需求。由于编译器自动生成的默认构造函数对内置类型不做处理，C++11对此进行了完善，即可以给内置类型的成员变量一个缺省值，编译器在自动生成默认构造函数时就会按照这个缺省值给成员变量初始化。
2.当我们用stack来实现队列的时候，成员变量只有内置类型，此时就不需要我们自己写构造函数，编译器自动调用自定义类型里的默认构造函数（默认构造函数存在）
3.当我们实现stack，就需要自己写默认构造函数
三、析构函数
析构函数不是完成对对象本⾝的销毁，比如局部对象是存在栈帧的，函数结束栈帧销毁，他就释放了，不需要我们管，C++规定对象在销毁时会⾃动调⽤析构函数，完成对象中资源的清理释放⼯作。析构函数的功能类比Stack实现的Destroy功能，像Date没有Destroy，其实就是没有资源需要释放，所以严格说Date是不需要析构函数的。总而言之，如果需要动态申请资源的就要写析构函数。
3.1析构函数的特点
1. 析构函数名是在类名前加上字符 ~
2. ⽆参数⽆返回值 (这⾥跟构造类似，也不需要加void)
3. ⼀个类只能有⼀个析构函数。若未显式定义，系统会⾃动⽣成默认的析构函数
4. 对象⽣命周期结束时，系统会⾃动调⽤析构函数
5. 跟构造函数类似，我们不写编译器⾃动⽣成的析构函数，对内置类型成员不做处理，⾃定类型成员会调⽤他的析构函数
6. 需要注意的是我们显示写析构函数，对于⾃定义类型成员也会调⽤他的析构，也就是说⾃定义类型成员⽆论什么情况都会⾃动调用析构函数
7. 如果类中没有申请资源时，析构函数可以不写，直接使⽤编译器⽣成的默认析构函数，如Date；如果默认⽣成的析构就可以⽤，也就不需要显示写析构，如MyQueue；但是有资源申请时，⼀定要自己写析构，否则会造成资源泄漏，如Stack
8. ⼀个局部域的多个对象，C++规定后定义的先析构
3.2代码分析
3.3析构函数场景分析
1.如果我们没有写析构函数，编译器会自动调用默认析构函数，默认析构函数对内置类型是不做处理的，对自定义类型会自动调用它的析构函数，就像myqueue在对象生命周期结束时会自动去调用stack的析构函数
2.如果我们写了析构函数，内置类型就会按照我们写的析构函数去清理资源，而自定义类型一样会去调用它的析构函数，也就是说，无论我们写不写析构函数，自定义类型都会去调用它的析构函数，就好比myqueue只要在对象生命周期结束时就会去调用stack的析构函数
3.当我们的内置类型去动态申请了资源，就一定要写析构函数，如果没有动态申请资源，实际上当对象生命周期结束后它就会自动销毁了，就好比Date类其实是不需要写析构函数的
4.如果成员变量只有自定义类型，也是不需要写析构函数的，编译器会默认调用
四、拷贝构造函数
如果⼀个构造函数的第⼀个参数是⾃⾝类类型的引⽤，且任何额外的参数都有默认值，则此构造函数也叫做拷⻉构造函数，也就是说拷⻉构造是⼀个特殊的构造函数。拷贝构造函数就是用一个已存在的对象去初始化一个正在定义的对象
4.1拷贝构造函数的特点
1. 拷⻉构造函数是构造函数的⼀个重载
2. 拷⻉构造函数的参数只有⼀个且必须是类类型对象的引用，使⽤传值方式编译器直接报错，因为语法逻辑上会引发⽆穷递归调用
3. C++规定⾃定义类型对象进⾏拷贝行为必须调⽤拷贝构造，所以这⾥⾃定义类型传值传参（形参实参需要拷贝）和传值返回（需要拷贝给一块临时变量）都会调用拷贝构造完成
4. 若未显式定义拷贝构造，编译器会⽣成⾃动⽣成拷贝构造函数。⾃动⽣成的拷贝构造对内置类型成员变量会完成值拷贝/浅拷贝(⼀个字节⼀个字节的拷贝)，对⾃定义类型成员变量会调⽤他的拷贝构造
5. 像Date这样的类成员变量全是内置类型且没有指向什么资源，编译器⾃动⽣成的拷贝构造就可以完成需要的拷贝，所以不需要我们显⽰实现拷贝构造
像Stack这样的类，虽然也都是内置类型，但是_a指向了资源，编译器⾃动⽣成的拷贝构造完成的值拷贝/浅拷贝不符合我们的需求（指向同一块空间，会进行两次析构，改变一个变量会影响另外一个变量），所以需要我们自己实现深拷贝(对指向的资源也进⾏拷贝)
像MyQueue这样的类型内部主要是⾃定义类型Stack成员，编译器⾃动⽣成的拷贝构造会调⽤Stack的拷贝构造，也不需要我们显⽰实现MyQueue的拷贝构造。如果⼀个类显示实现了析构并释放资源，那么他就需要显示写构造，否则就不需要
6. 传值返回会产生一个临时变量要进行拷贝构造，传值引用返回，返回的是返回对象的别名(引⽤)，没有产⽣拷贝。但是如果返回对象是⼀个当前函数局部域的局部对象，函数结束就销毁了，那么使⽤引用返回是有问题的，这时的引用相当于⼀个野引用，类似⼀个野指针⼀样。传引用返回可以减少拷贝，但是⼀定要确保返回对象，在当前函数结束后还在，才能⽤引用返回。
4.2代码分析
为什么需要使用const +传值引用？
如果不使用传值引用，Date stk会引发无穷递归
使用const的好处是，在传值引用时可以传普通对象，也可以传const修饰的对象，或者可以这么认为，const修饰的d是被拷贝方，该对象是不变的
4.3拷贝构造函数的场景分析
拷贝构造必须传同类型的对象，而不是指针
stack的拷贝构造必须自己写，不能调用编译器自动生成的默认拷贝构造，因为stack需要进行动态申请资源，进行浅拷贝会使两个变量指向同一块空间，析构两次程序崩溃，改变其中一个变量会影响另外一个变量
myqueue可以不写拷贝构造函数，会自动调用stack里的拷贝构造函数，只要stack显示写了拷贝构造函数，myqueue自动调用默认拷贝函数就没有问题
需不需要使用引用返回？如果函数调用结束后，返回的对象没有被销毁（如static修饰的变量存储在静态区，this指针），就可以使用引用返回，如果函数调用结束后，返回的对象被销毁了（如创建的临时对象temp），就不能使用引用返回，此时的引用就类似野引用。传引用返回可以减少拷贝，但是有前提。
五、运算符重载函数&&赋值运算符重载函数
5.1运算符重载函数
1.运算符重载函数是为了让类类型对象能像内置类型一样直接使用运算符。类型对象使⽤运算符时，必须转换成调⽤对应运算符重载，若没有对应的运算符重载，则会编译报错。
2.运算符重载函数的函数名为operator+运算符，它和普通函数一样具有返回值，参数，函数体
3.值得注意的是，如果一个运算符重载函数是成员函数，运算符重载函数的第一个参数默认为this指针指向的左操作数，因此我们实际看到的运算符重载函数的参数是运算符操作数-1
4..* :: sizeof ? : . 注意以上5个运算符不能重载
5.重载++运算符时，有前置++和后置++，运算符重载函数名都是operator++，⽆法很好的区分。C++规定，后置++重载时，增加⼀个int形参，跟前置++构成函数重载，⽅便区分
6.重载<<和>>时，需要重载为全局函数，因为重载为成员函数，this指针默认抢占了第⼀个形参位置，第⼀个形参位置是左侧运算对象，调⽤时就变成了 对象<<cout，不符合使⽤习惯和可读性。重载为全局函数把ostream/istream放到第⼀个形参位置就可以了，第⼆个形参位置当类类型对象
1.代码分析：
2.运算符重载函数场景分析
（1）函数体内无法访问对象的成员变量，有以下几种方案：①成员放公有②Date提供get函数获取成员变量③友元函数⑤重载为成员函数
（2）在重载前置++和后置++时，后置++增加一个形参以便和前置++构成重载来区分。前置++可以使用引用返回，因为它返回的是*this++后的结果，直接返回*this就行；后置++不可以使用引用返回，因为它需要一个临时对象来存储*this，*this++后再返回该临时对象。后置++需要调用两次拷贝构造函数，前置++则不需要，一般情况下使用前置++
5.2赋值运算符重载函数和拷贝构造函数
赋值运算符重载是把一个已存在的对象赋值给另外一个同类的已存在的对象，两个对象都是经过初始化的，而拷贝构造函数是用一个已存在的对象去初始化一个同类的正在定义的对象
1.代码分析
赋值运算符重载是⼀个运算符重载，规定必须重载为成员函数。赋值运算重载的参数建议写const 当前类类型引用，否则传值传参会有拷贝，const修饰使引用权限缩小，传值引用的实体可以是普通对象也可以是const修饰的对象
返回值建议写成当前类类型引⽤，引⽤返回可以提⾼效率，有返回值目的是为了⽀持连续赋值场景
2.赋值运算符重载函数场景分析
没有显式写赋值运算符重载函数时，编译器会自动⽣成⼀个默认赋值运算符重载，默认赋值运算符重载⾏为跟默认构造函数类似，对内置类型成员变量会完成值拷贝/浅拷贝(⼀个字节⼀个字节的拷⻉)，对⾃定义类型成员变量会调⽤他的赋值运算符重载函数。
像Date这样的类成员变量全是内置类型且没有指向什么资源，编译器自动生成的赋值运算符重载就可以完成需要的拷贝，所以不需要我们显⽰实现赋值运算符重载
像Stack这样的类，虽然也都是内置类型，但是_a指向了资源，编译器自动生成的赋值运算符重载完成的值拷贝/浅拷贝不符合我们的需求，需要显示写运算符重载函数对指向的资源也进⾏拷贝
像MyQueue这样的类型内部主要是自定义类型Stack成员，编译器自动⽣成的赋值运算符重载会调用Stack的赋值运算符重载，也不需要我们显⽰实现MyQueue的赋值运算符重载
六、Date类实现
结合以上的几种成员函数的使用场景，我们就可以构造出日期类及其功能
#include "Date.h"
//Date::Date(Date* const this int year, int month, int day)
Date::Date(int year, int month, int day)
{
if (month > 0 && month <= 12 && day > 0 && day <= GetMonthday(year, month))
{
_year = year;
_month = month;
_day = day;
}
else
{
cout << "非法日期" << endl;
}
}
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;
}
else
return false;
}
bool Date::operator==(const Date& d) const
{
return _year == d._year && _month == d._month && _day == d._day;
}
bool Date::operator<=(const Date& d) const
{
return (*this < d) || (*this == d);
}
bool Date::operator>=(const Date& d) const
{
return !(*this < d);
}
bool Date::operator>(const Date& d) const
{
return !(*this <= d);
}
bool Date::operator!=(const Date& d) const
{
return !(*this == d);
}
int Date::GetMonthday(int year, int month)
{
static int datearray[13] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
if (month == 2 && (((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0)))
{
return 29;
}
return datearray[month];
}
//+=运算符重载实现+
Date& Date::operator+=(int day)
{
if (day < 0)
{
*this = *this -= -day;
return *this;
}
_day += day;
while (_day > GetMonthday(_year, _month))
{
_day -= GetMonthday(_year, _month);
_month++;
if (_month == 13)
{
_year++;
_month = 1;
}
}
return *this;
}
Date Date::operator+(int day) const
{
Date temp(*this);
temp += day;
return temp;;
}
//+运算符重载函数实现+=
//Date Date::operator+(int day)
//{
// Date temp(*this);
// //temp += day;
// temp._day += day;
// while (temp._day > GetMonth(temp._year, temp._month))
// {
// temp._day -= GetMonth(temp._year, temp._month);
// temp._month++;
// if (temp._month == 13)
// {
// temp._year++;
// temp._month = 1;
// }
// }
//
// return temp;;
//}
//Date& Date::operator+=(int day)
//{
// *this=*this + day;
// return *this;
//}
Date& Date:: operator-=(int day)
{
if (day < 0)
{
*this = *this += -day;
return *this;
}
_day -= day;
while (_day <= 0)
{
_day += GetMonthday(_year, _month);
--_month;
if (_month == 0)
{
_month = 12;
_year--;
}
}
return *this;
}
Date Date::operator-(int day) const
{
Date temp(*this);
temp -= day;
return temp;
}
//不需要额外开辟空间
Date& Date::operator++()
{
*this += 1;
return *this;
}
//需要额外开辟空间
Date Date::operator++(int)
{
Date temp = *this;
*this += 1;
return temp;
}
Date& Date::operator--()
{
*this -= 1;
return *this;
}
Date Date::operator--(int)
{
Date temp = *this;
*this -= 1;
return temp;
}
int Date::operator-(const Date& d) const
{
Date max = *this;
Date min = d;
int flag = 1;
if (*this < d)
{
max = d;
min = *this;
flag = -1;
}
int count = 0;
while (min != max)
{
++min;
count++;
}
return flag * count;
}
void Date::operator<<(ostream& out)
{
out << _year << "年" << _month << "月" << _day << "日" << endl;
}
//引用返回cout的类 实现连续输出
//cout<<内置类型是在库里面实现的 自动识别类型是由运算符重载函数构成重载实现的
ostream& operator<<(ostream& out, const Date& d)
{
out << d._year << "年" << d._month << "月" << d._day << "日" << endl;
return out;
}
istream& operator>>(istream& in, Date& d)
{
int year, month, day;
in >> year >> month >> day;
if (month > 0 && month <= 12 && day > 0 && day <= d.GetMonthday(year, month))
{
d._year = year;
d._month = month;
d._day = day;
}
else
{
cout << "非法日期" << endl;
}
return in;
}
头文件
#pragma once
#include<iostream>
using namespace std;
class Date
{
//全局+友元函数
friend ostream& operator<<(ostream& out, const Date& d);
friend istream& operator>>(istream& in, Date& d);
public:
//构造函数
Date(int year = 1, int month = 1, int day = 1);
//取地址运算符重载函数——不写编译器也会自动生成
/*Date* operator&()
{
cout << "Date* operator&()" << endl;
return this;
}
const Date* operator&() const
{
cout << "const Date* operator&() const" << endl;
return this;
}*/
//const修饰成员函数 this指针权限缩小 普通对象和const对象都能调用
//需要改变对象成员变量的函数不能用const修饰
void print() const
{
cout << _year << "-" << _month << "-" << _day << endl;
}
//拷贝构造函数
Date(const Date& d)
{
_year = d._year;
_month=d._month;
_day = d._day;
}
bool operator<(const Date& d) const;
bool operator==(const Date& d) const;
bool operator<=(const Date& d) const;
bool operator>=(const Date& d) const;
bool operator>(const Date& d) const;
bool operator!=(const Date& d) const;
int GetMonthday(int year, int month);
Date& operator+=(int day);
Date operator+(int day) const;
Date& operator-=(int day);
Date operator-(int day) const;
//前置++ 返回++后的对象
Date& operator++();
//后置++ 返回++前的对象 int是为了用来占位 和++运算符重载函数构成重载 区分前置++和后置++
Date operator++(int);
//前置--
Date& operator--();
//后置--
Date operator--(int);
int operator-(const Date & d) const;
//写成成员变量函数 Date默认为第一个参数 即左操作符 使用起来不符合我们的习惯
//d1<<cout; d1.opterator(cout);
void operator<<(ostream& out);
private:
int _year;
int _month;
int _day;
};
ostream& operator<<(ostream& out,const Date& d);
istream& operator>>(istream& in,Date& d);
这里有几个需要注意的地方：
1.在实现各种关系运算符重载函数时，我们不需要逐一实现，只要实现了<和=就可以通过逻辑运算和复用来实现其他的关系运算符重载函数
2.在实现+=和+运算符重载函数时，不推荐用+运算符重载函数来实现+=运算符重载函数，因为+运算符重载函数内部是用临时对象来实现的，+=运算符重载函数内部在调用+算符重载函数时需要进行4次拷贝（传值1次，创建对象1次，返回临时对象1次，拷贝给*this1次），如果直接实现+=算符重载函数则只需要进行1次拷贝（传this指针指向的对象）
3.对于一些不改变对象成员变量的成员函数，可以在函数末尾用const修饰。const实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进⾏修改。const 修饰Date类的print成员函数，print隐含的this指针由 Date* const this 变为 const Date* const this。const修饰成员函数后，权限缩小，普通对象和const对象都能调用该函数
七、取地址运算符重载函数
7.1取地址运算符重载函数的特点
取地址运算符重载分为普通取地址运算符重载和const取地址运算符重载，⼀般这两个函数编译器自动生成的就可以够我们用了，不需要去显示实现。
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
