目录
一、类的6个默认成员函数
在上一篇博客中，我们计算了空类的大小为 1 。那么空类中真的什么东西都没有吗？其实不是的，当一个类在什么都不写的时候就会自动生成6个默认的成员函数（用户没有写，但是编译器自动生成的成员函数）。
接下来我们就将围绕上图展开本篇博客……
二、构造函数——用以对象初始化
构造函数是一个特殊的成员函数，名字与类名相同,创建类类型对象时由编译器自动调用，以保证 每个数据成员都有 一个合适的初始值，并且在对象整个生命周期内只调用一次。
特征：
1）函数名与类名相同
2）无返回值（不需要写void）
3）实例化对象时由编译器自动调用
4）可以重载（一般建议写一个全缺省的构造）
5）若类中没有显示定义构造函数，则C++编译器会自动生成一个无参的默认构造函数。
但是，一旦用户显示定义了构造函数，编译器就不会自动生成了
6）内置类型成员变量在类中声明时可以给默认值
7）无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。 注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为 是默认构造函数
三、析构函数——用于对象中资源清理
特性：
1）函数名为在类名前加~
2）无参无返回值
3）一个类有且仅有一个析构函数（不支持函数重载），若未显示定义，则由系统自动生成默认的析构函数
4）对象生命周期结束时，由编译器自动调用析构函数
5） 如果类中没有申请资源时，析构函数可以不写，直接使用编译器生成的默认析构函数，比如 Date类；有资源申请时，一定要写，否则会造成资源泄漏，比如Stack类。
那么，什么时候需要我们显示定义构造函数，什么时候又不需要我们显示定义析构函数呢？
需要显示定义情况：有资源需要显示清理时我们需要写析构函数
不需要显式定义情况：a）没有资源需要清理
b）内置类型成员没有资源需要清理，剩下的都是自定义类型成员，自定义类型调用自己的析构函数
四、拷贝构造函数——使用同类对象初始化创建对象
拷贝构造函数：只有单个形参，该形参是对本类类型对象的引用(一般常用const修饰)，在用已存 在的类类型对象创建新对象时由编译器自动调用。
特征：
1）拷贝构造函数也是构造函数的重载形式
2）构造函数的参数有且仅有一个，且必须是类类型对象的引用。传值的话编译器会直接报错。因为会引发无限递归
引发无限递归的原因分析：在传值调用过程中，需要对形参进行拷贝构造，但是并无拷贝构造函数，会引发无限递归，直到程序崩溃
3）若未显式定义，编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。浅拷贝不能对资源进行管理，如栈中的数组就没法浅拷贝，必须深拷贝才能完成
总结：
1）如果没有管理资源，一般情况下，不需要写拷贝构造，使用编译器默认生成的即可
2）如果是自定义类型，内置类型成员没有指向资源，默认生成的浅拷贝构造也可以
3）一般情况下，不需要写析构函数就不需要写拷贝构造函数
4）如果内部有指针之类的指向资源，需要显示写析构函数，通常也就需要显示写拷贝构造函数完成深拷贝
使用场景：
1）使用已存在对象创建新对象
2）函数参数类型为类类型对象
3）函数返回值类型为类类型对象
五、赋值运算符重载
再讲赋值运算符重载之前，不可避免的需要谈一谈运算符重载。
5.1、运算符重载
C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其 返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。
函数原型为： 返回值类型 operator操作符（参数列表）
特性：
1）不能通过连接其他符号来创建新的操作符：比如operator@
2）重载操作符必须有一个类类型参数 用于内置类型的运算符，其含义不能改变
3)作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数隐藏的this
4) .* :: sizeof ?: . 注意以上5个运算符不能重载。
5.2、赋值运算符的重载
赋值运算符重载格式：
1）参数类型：const T&，传递引用可以提高传参效率
2） 返回值类型：T&，返回引用可以提高返回的效率，为了支持连续赋值
3）检测是否自己给自己赋值
4）返回*this ：要复合连续赋值的含义
赋值运算符只能重载成类的成员函数不能重载成全局函数
原因：赋值运算符如果不显式定义，编译器会生成默认的。而用户在全局实现了复制运算符的重载，就会和编译器自动生成的冲突，因此赋值运算符只能是类的成员函数
当涉及到资源管理的时候，必须要手动写赋值运算符函数
5.3、前置++和后置++的重载
前置++需要返回的是++之后的值，并且本身加一，后置++则是返回++之前的值，然后本身加一。具体的我们在下面的日期类中实现
// 前置++和后置++都是一元运算符，为了让前置++与后置++形成能正确重载
// C++规定：后置++重载时多增加一个int类型的参数，但调用函数时该参数不用传递，编译器
自动传递
// 注意：后置++是先使用后+1，因此需要返回+1之前的旧值，故需在实现时需要先将this保存
一份，然后给this+1六、const成员
将const修饰的“成员函数”称之为const成员函数，const修饰类成员函数，实际修饰该成员函数 隐含的this指针，表明在该成员函数中不能对类的任何成员进行修改。
七、日期类的实现
最容易被忘记的是，在实现前置++后置++运算符重载时，后置++需要加上int。
//Data.h
#include<iostream>
using namespace std;
//日期类
class Data
{
//这个实现的时候，我将private屏蔽了（变成公有），这样可以直接使用年月日，而不需要再构建函数,或者使用友元函数
friend ostream& operator<<(ostream& out,const Data& d);
friend istream& operator>>(istream& in, Data& d);
public:
//打印
void Print()
{
cout<<_year<<"年"<<_month<<"月"<<_day<<"日"<<endl;
}
//获取每月天数
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;
}
//检查日期合法
bool check()
{
if (_month < 0 || _month>12 || _day<0 || _day>GetMonthDay(_year, _month))
{
return false;
}
return true;
}
//默认缺省构造函数
Data(int year=2024, int month=1, int day=1);
//拷贝构造函数
Data(const Data& d);
//析构函数
~Data();
//接下来时赋值运算符的重载
Data& operator=(const Data& d);
Data operator+(int day);
Data& operator+=(int day);
Data operator-(int day);
Data& operator-=(int day);
//日期类的自增自减的实现
Data operator++(int);
Data& operator++();
Data operator--(int);
Data& operator--();
//逻辑运算符重载
bool operator==(const Data& d);
bool operator<=(const Data& d);
bool operator<(const Data& d);
bool operator>=(const Data& d);
bool operator>(const Data& d);
bool operator!=(const Data& d);
int operator-(const Data& d);
private:
int _year;
int _month;
int _day;
};
#include"Data.h"
//构造函数
Data::Data(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
if (!check())
{
cout << "输入错误！！！";
}
}
//拷贝构造函数
Data::Data(const Data& d)
{
_year = d._year;
_month = d._month;
_day = d._day;
}
//赋值运算符重载函数
Data& Data::operator=(const Data& d)
{
_year = d._year;
_month = d._month;
_day = d._day;
return *this;
}
//析构函数，因为没有资源需要清理，所以使用默认的析构函数也可以
Data::~Data()
{
_year = 0;
_month = 0;
_day = 0;
}
//+=
Data& Data::operator+=(int day)
{
if (day < 0)
{
return *this -= -day;
}
_day += day;
while (_day > GetMonthDay(_year, _month))
{
_day -= GetMonthDay(_year, _month);
_month++;
if (_month == 13)
{
_month = 1;
_year++;
}
}
return *this;
}
//+
Data Data::operator+(int day)
{
Data temp = *this;
temp += day;
return temp;
}
//-=
Data& Data::operator-=(int day)
{
if (day < 0)
{
return *this += -day;
}
_day -= day;
while (_day <= 0)
{
_month--;
if (_month == 0)
{
_month = 12;
--_year;
}
_day += GetMonthDay(_year, _month);
}
return *this;
}
//-
Data Data::operator-(int day)
{
Data temp = *this;
temp -= day;
return temp;
}
//==
bool Data::operator==(const Data& d)
{
return _day == d._day && _month == d._month && _year == d._year;
}
//！=
bool Data::operator!=(const Data& d)
{
return !(*this == d);
}
//<
bool Data::operator<(const Data& d)
{
if (_year < d._year)
{
return true;
}
else if (_year == d._year)
{
if (_month < d._month)
{
return true;
}
else if (_month == d._month)
{
return _day < d._day;
}
}
return false;
}
//<=
bool Data::operator<=(const Data& d)
{
return *this < d || *this == d;
}
//>
bool Data::operator>(const Data& d)
{
return !(*this <= d);
}
//>=
bool Data::operator>=(const Data& d)
{
return !(*this < d);
}
//差多少天
int Data::operator-(const Data& d)
{
Data max = *this;
Data min = d;
int flag = 1;
if (max < min)
{
Data temp = min;
min = max;
max = temp;
flag = -1;
}
int n = 0;
while (min < max)
{
n++;
min += 1;
}
return n * flag;
}
//后置加int，前置不加
//d1++
Data Data::operator++(int)
{
Data temp = *this;
*this += 1;
return temp;
}
//++d1
Data& Data::operator++()
{
*this += 1;
return *this;
}
//d1--
Data Data::operator--(int)
{
Data temp = *this;
*this -= 1;
return temp;
}
//--d1
Data& Data::operator--()
{
*this -= 1;
return *this;
}
//输入输出
ostream& operator<<(ostream& out,const Data& d)
{
out << d._year << "年" << d._month << "月" << d._day << "日" << endl;
return out;
}
istream& operator>>(istream& in, Data& d)
{
in >> d._year >> d._month >> d._day;
if (!d.check()
{
cout << "输入错误！！！";
}
return in;
}