【C++】3.类和对象（中）

一、类的6个默认成员函数

二、构造函数——用以对象初始化

三、析构函数——用于对象中资源清理

四、拷贝构造函数——使用同类对象初始化创建对象

五、赋值运算符重载

5.1、运算符重载

5.2、赋值运算符的重载

5.3、前置++和后置++的重载

六、const成员

七、日期类的实现

一、类的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;
}