类和对象（中）-CSDN博客

1.C++的默认成员函数

默认成员函数就是用户没有显式实现，编译器会自动生成的成员函数称为默认成员函数。一个类，我们不写的情况下编译器会默认生成以下6个默认成员函数，需要注意的是这6个中最重要的是前4个，最后两个取地址重载不重要，我们稍微了解⼀下即可。其次就是C++11以后还会增加两个默认成员函数，移动构造和移动赋值，这个我们后面再讲解。默认成员函数很重要，也比较复杂，我们要从两个方面去学习：

第一：我们不写时，编译器默认生成的函数行为是什么，是否满足我们的需求。
第二：编译器默认生成的函数不满足我们的需求，我们需要自己实现，那么如何自己实现？

2. 构造函数

构造函数是特殊的成员函数，需要注意的是，构造函数虽然名称叫构造，但是构造函数的主要任务并不是开空间创建对象(我们常使用的局部对象是栈帧创建时，空间就开好了)，而是对象实例化时初始化对象。构造函数的本质是要替代我们以前Stack和Date类中写的Init函数的功能，构造函数自动调用的特点就完美的替代的了Init。

构造函数的特点：

①函数名与类名相同。
②无返回值。(返回值啥都不需要给，也不需要写void，不要纠结，C++规定如此)
③对象实例化时系统会自动调用对应的构造函数。
④构造函数可以重载。
⑤如果类中没有显式定义构造函数，则C++编译器会自动生成⼀个无参的默认构造函数，一旦用户显式定义编译器将不再生成。
⑥无参构造函数、全缺省构造函数、我们不写构造时编译器默认生成的构造函数，都叫做默认构造函数。但是这三个函数有且只有⼀个存在，不能同时存在。无参构造函数和全缺省构造函数虽然构成函数重载，但是调用时会存在歧义。要注意很多同学会认为默认构造函数是编译器默认生成那个叫默认构造，实际上无参构造函数、全缺省构造函数也是默认构造，总结⼀下就是不传实参就可以调用的构造就叫默认构造。
⑦我们不写，编译器默认生成的构造，对内置类型成员变量的初始化没有要求，也就是说是是否初始化是不确定的，看编译器。对于自定义类型成员变量，要求调用这个成员变量的默认构造函数初始化。如果这个成员变量，没有默认构造函数，那么就会报错，我们要初始化这个成员变量，需要用初始化列表才能解决，初始化列表，我们下个章节再细细讲解。

说明：C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语言提供的原生数据类型，如：int/char/double/指针等，自定义类型就是我们使用class/struct等关键字自己定义的类型。

这里调用无参构造，当对象实例化之后，就会自动调用构造函数完成初始化，注意如果通过无参构造函数创建对象时，对象后面不用跟括号，否则编译器无法区分这里是函数声明还是实例化对象。

这里调用了带参构造，调用的方式如上图所示。

这里使用了全缺省构造，注意，无论是全缺省构造还是无参构造，当不传参数的时候都不使用括号，因为使用括号但不传参数，会与函数声明混淆。

这里使用了系统自己生成的默认构造函数，编译器默认生成的构造，对内置类型成员变量的初始化没有要求，也就是说是是否初始化是不确定的，看编译器。可以看到上图中成员变量并没有做处理。

对于第七点，上图可以很好地解释，对于MyQueue这个类，我们没有写他的构造函数，则系统会自己生成，而系统自己生成的默认构造函数，对于自定义类型，要求调用这个成员变量的默认构造函数初始化，所以就调用了Stack的默认构造，而Stack里面我们写了一个全缺省构造函数，那么mq就被成功初始化了，pushst和popst也都被初始化了。

3.析构函数

析构函数与构造函数功能相反，析构函数不是完成对对象本身的销毁，比如局部对象是存在栈帧的，函数结束栈帧销毁，他就释放了，不需要我们管，C++规定对象在销毁时会自动调用析构函数，完成对象中资源的清理释放工作。析构函数的功能类比我们之前Stack实现的Destroy功能，而像Date没有Destroy，其实就是没有资源需要释放，所以严格说Date是不需要析构函数的。

析构函数的特点：
①析构函数名是在类名前加上字符~。
②无参数无返回值。(这里跟构造类似，也不需要加void)
③一个类只能一个析构函数。若未显式定义，系统会自动生成默认的析构函数。
④对象生命周期结束时，系统会自动调用析构函数。
⑤跟构造函数类似，我们不写编译器自动生成的析构函数对内置类型成员不做处理，自定类型成员会调用他的析构函数。
⑥还需要注意的是我们显示写析构函数，对于自定义类型成员也会调用他的析构，也就是说自定义类型成员无论什么情况都会自动调用析构函数。
⑦如果类中没有申请资源时，析构函数可以不写，直接使用编译器生成的默认析构函数，如Date；如果默认生成的析构就可以用，也就不需要显示写析构，如MyQueue；但是有资源申请时，⼀定要自己写析构，否则会造成资源泄漏，如Stack。
⑧一个局部域的多个对象，C++规定后定义的先析构。

对于Date这种日期类，因为没有资源的申请，所以我们并不需要写他的析构函数；对于Stack类，因为我们申请了空间，如果仅调用系统的析构函数，会造成内存泄露，所以这时候我们就要自己写析构函数；对于MyQueue类，因为是自定义类型，系统对其的操作时调用他自己的析构函数也就是Stack里的析构函数，所以这时用系统的析构函数就可以了，如果我们还是给MyQueue写了析构函数，却并没有对Stack类进行空间的释放，这时候并不会造成空间泄露，因为系统还是会去调用Stack类的析构函数，也就是说自定义类型成员无论什么情况都会自动调用析构函数。

4.拷贝构造函数

如果⼀个构造函数的第⼀个参数是自身类类型的引用，且任何额外的参数都有默认值，则此构造函数也叫做拷贝构造函数，也就是说拷贝构造是一个特殊的构造函数。

拷贝构造的特点：
①拷贝构造函数是构造函数的⼀个重载。
②拷贝构造函数的第⼀个参数必须是类类型对象的引用，使用传值方式编译器直接报错，因为语法逻辑上会引发无穷递归调用。拷贝构造函数也可以多个参数，但是第⼀个参数必须是类类型对象的引用，后面的参数必须有缺省值。
③C++规定自定义类型对象进行拷贝行为（如传值传参）必须调用拷贝构造，所以这里自定义类型传值传参和传值返回都会调用拷贝构造完成。
④若未显式定义拷贝构造，编译器会自动生成拷贝构造函数。自动生成的拷贝构造对内置类型成
员变量会完成值拷贝/浅拷贝(一个字节一个字节的拷贝)，对自定义类型成员变量会调用他的拷贝构
造。

⑤像Date这样的类成员变量全是内置类型且没有指向什么资源，编译器自动生成的拷贝构造就可以完成需要的拷贝，所以不需要我们显示实现拷贝构造。像Stack这样的类，虽然也都是内置类型，但是_a指向了资源，编译器自动生成的拷贝构造完成的值拷贝/浅拷贝不符合我们的需求（一个字节一个字节的拷贝，会使他们的_a指向的是同一块空间），所以需要我们自己实现深拷贝(对指向的资源也进行拷贝)。像MyQueue这样的类型内部主要是自定义类型Stack成员，编译器自动生成的拷贝构造会调用Stack的拷贝构造，也不需要我们显示实现MyQueue的拷贝构造。这里还有一个小技巧，如果一个类显示实现了析构并释放资源，那么他就需要显示写拷贝构造，否则就不需要。

⑥传值返回会产生一个临时对象调用拷贝构造，传值引用返回，返回的是返回对象的别名(引用)，没有产生拷贝。但是如果返回对象是一个当前函数局部域的局部对象，函数结束就销毁了，那么使有用引用返回是有问题的，这时的引用相当于一个野引用，类似一个野指针一样。传引用返回可以减少拷贝，但是一定要确保返回对象，在当前函数结束后还在（定义成static），才能用引用返回。

上图是正确的拷贝构造函数的写法，注意拷贝构造第一个参数必须是类类型的引用，并且拷贝构造和构造函数是重载函数，所以他们的函数名都是Date。为什么使用拷贝构造使用传值传参会引发无穷递归呢？这是因为由于C++规定自定义类型的拷贝行为都会调用拷贝构造，所以传值传参和传值返回都会调用拷贝构造，如果将拷贝构造函数里的形参部分写成传值传参，那就会无穷的调用拷贝构造。因此这里对于自定义类型我们需要用类类型的引用，那么调用拷贝构造函数时，相当于给自定义类型变量取了一个别名，然后进行拷贝就可以了，在这里，因为我们不期望我们传进去的自定义类型变量被改变，所以我们会给变量加上const。

由于若未显式定义拷贝构造，编译器会自动生成拷贝构造函数。自动生成的拷贝构造对内置类型成
员变量会完成值拷贝/浅拷贝(⼀个字节⼀个字节的拷贝)，所以日期类我们并不用写拷贝构造函数，因为对于内置类型会一个字节一个字节的拷贝。看起来系统默认生成的拷贝构造函数对自定义类型和内置类型均有处理，但是在有些情况下，系统生成的拷贝构造函数并不符合我们的要求。比如对于栈类型的拷贝，如果我们用系统自己生成的拷贝构造函数，那么拷贝出来的地址也是相同的，那么在程序结束的时候，这一块空间就会被析构两次，导致程序崩溃。

所以对于有资源申请的类，我么要自己写拷贝构造，并且要用深拷贝，开的空间大小是一样的，但两块空间的地址不一样。

所以C++规定自定义类型进行传值传参的时候需要调用拷贝构造，就是因为在C语言中，自定义类型的传值传参是浅拷贝，也就是一个字节一个字节的拷贝，这就会导致形参和实参指向同一块空间，看似传值传参形参不改变实参，但这里形参的改变却会影响实参。如果调用拷贝构造进行深拷贝，形参就不会影响实参，但是这也需要开额外的空间，如果实参本身空间很大，会造成空间的浪费，这也告诉着我们对于自定义类型的传参，我们其实更喜欢传自定义类型的引用。

5.赋值运算符

（1）运算符重载

①当运算符被用于类类型的对象时，C++语言允许我们通过运算符重载的形式指定新的含义。C++规定类类型对象使用运算符时，必须转换成调用对应运算符重载，若没有对应的运算符重载，则会编译报错。
②运算符重载是具有特殊名字的函数，他的名字是由operator和后面要定义的运算符共同构成。和其他函数⼀样，它也具有其返回类型和参数列表以及函数体。
③重载运算符函数的参数个数和该运算符作用的运算对象数量一样多。一元运算符有一个参数，二元运算符有两个参数，二元运算符的左侧运算对象传给第一个参数，右侧运算对象传给第二个参数。
④如果一个重载运算符函数是成员函数，则它的第一个运算对象默认传给隐式的this指针，因此运算符重载作为成员函数时，参数比运算对象少一个。
⑤运算符重载以后，其优先级和结合性与对应的内置类型运算符保持⼀致。

⑥不能通过连接语法中没有的符号来创建新的操作符：比如operator@。
⑦ .* :: sizeof ?: . 注意以上5个运算符不能重载。(选择题里面常考，大家要记⼀下)
⑧重载操作符至少有一个类类型参数，不能通过运算符重载改变内置类型对象的含义，如： int
operator+(int x, int y)
⑨⼀个类需要重载哪些运算符，是看哪些运算符重载后有意义，比如Date类重载operator-就有意
义，但是重载operator+就没有意义。
⑩重载++运算符时，有前置++和后置++，运算符重载函数名都是operator++，无法很好的区分。
C++规定，后置++重载时，增加⼀个int形参，跟前置++构成函数重载，方便区分。
11.重载<<和>>时，需要重载为全局函数，因为重载为成员函数，this指针默认抢占了第⼀个形参位置，第⼀个形参位置是左侧运算对象，调用时就变成了对象<<cout，不符合使用习惯和可读性。重载为全局函数把ostream/istream放到第⼀个形参位置就可以了，第二个形参位置当类类型对象。

类使用运算符的时候，他的逻辑是由我们自己定义的，因此我们需要自己去写运算符的重载函数。

像这样我们就定义了一个运算符重载函数，但我们把他定义在全局域里，拿不到成员变量，这时候有三种方法：①把成员变量设为公有，但这用方法不推荐 ②在类里面写成员变量获得函数，如：

③把运算符重载函数写在类里面

我们解释一下 .*这个操作符：

（2）赋值运算符重载

赋值运算符重载是⼀个默认成员函数，用于完成两个已经存在的对象直接的拷贝赋值，这里要注意跟拷贝构造区分，拷贝构造用于一个对象拷贝初始化给另一个要创建的对象。

①赋值运算符重载是⼀个运算符重载，规定必须重载为成员函数。赋值运算重载的参数建议写成
const当前类类型引用，否则会传值传参会有拷贝。
②有返回值，且建议写成当前类类型引用，引用返回可以提高效率，有返回值目的是为了支持连续赋值场景。
③没有显式实现时，编译器会自动生成⼀个默认赋值运算符重载，默认赋值运算符重载行为跟默认拷贝构造函数类似，对内置类型成员变量会完成值拷贝/浅拷贝(一个字节一个字节的拷贝)，对自定义类型成员变量会调用他的赋值重载函数。
④像Date这样的类成员变量全是内置类型且没有指向什么资源，编译器自动生成的赋值运算符重载就可以完成需要的拷贝，所以不需要我们显示实现赋值运算符重载。像Stack这样的类，虽然也都是内置类型，但是_a指向了资源，编译器自动生成的赋值运算符重载完成的值拷贝/浅拷贝不符合我们的需求，所以需要我们自己实现深拷贝(对指向的资源也进行拷贝)。像MyQueue这样的类型内部主要是自定义类型Stack成员，编译器自动生成的赋值运算符重载会调用Stack的赋值运算符重载，也不需要我们显示实现MyQueue的赋值运算符重载。这里还有⼀个小技巧，如果一个类显示实现了析构并释放资源，那么他就需要显示写赋值运算符重载，否则就不需要。

赋值重载函数首先可以写成上图这种形式，没有返回值。赋值重载函数建议参数写成引用，因为这样可以减少传值传参调用拷贝构造的次数。但是我们需要写成有返回值，因为我们赋值时有连续赋值的情况，那么返回值还需要是一个引用。

（3）日期类实现

首先我们创建一个日期类，由于日期类没有资源的申请，所以我么只需要写析构函数即可，析构函数、拷贝构造、赋值重载函数使用系统默认生成的即可。

class Date
{
public：

	Date(int year = 2024, int month = 9, int day = 12);
private:
	int _year;
	int _month;
	int _day;
};

并且在这里我们使用声明的定义分离，创建一个头文件Date.h声明头文件、创建日期类、声明日期类的一系列函数，还要创建一个Date.cpp用来定义、实现所有的函数，最后再创建一个测试文件test.cpp用来测试我们的函数。

我们首先先写一个函数GetMonthDay，用来获得某一年某个月的天数，由于每年有大小月，还有平闰年会影响二月的天数，我们用条件判断语句和swith语句都会显得冗余，在这里我们可以创建一个属组，将平年的每个月的天数存进去，而对于闰年我们可以单独判断。另外，我们可以把这个函数写在类里面，而类里面的函数会自动设成内联函数，这个函数我们调用频繁，使用内联函数也可以提高效率。

//获取某一年某个月的天数
//getMonthDay写在类里面就会自动变成一个内联函数，以为这个函数调用频繁，定义成内联可以提高效率
int GetMonthDay(int year, int month)const
{
	assert(month > 0 && month < 13);

	//使用静态stctic是因为这个数组会被频繁调用，定义在静态区可以提高效率
	static int monthDatArray[13] = { -1,31,28,31,30,31,30,31,31,30,31,30,31 };
	//month == 2放在最前面是为了先判断是不是2月，不是的话if直接跳过
	if (month == 2 && year % 4 == 0 && year % 100 != 0 && year % 400 == 0)
	{
		return 29;
	}
	else
		return monthDatArray[month];
}

我们再来实现一下+和+=：注意这里+和+=是日期+/+=天数，日期+/+=日期是没有意义的。对于+=的逻辑，我们可以直接将天数加在日期的天上，接着，判断天数是否大于当前月份的天数，如果大于，就用天数-去当前月份的天数，_month+1，继续再完成前面的操作，当_day<GetMonthDay时，就停止循环，注意当_month==13的时候赋值为1，_year++。

Date& Date::operator+=(int day)
{
    //如果传进来的day是负值
    if (day < 0)
    {
	    return *this -= (-day);
    }
    
	_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 tmp = *this;

	tmp += day;
	//这里tmp是一个局部变量，不能用引用返回
	return tmp;
}

现在我们实现一下-/-=：注意我们现在实现的-/-=是日期-/-=天数，日期-日期有意义，我们后面子啊进行实现。-=的逻辑是，比较_day和day的大小，如果不够，我们就将上一个月的天数GetMonthDay加在_day上，_month--，再进行比较，直到_day>day时，循环结束。注意，如果_month<1，赋值_month=12，_year--。

Date& Date::operator-=(int day)
{
    if (day < 0)
    {
	    return *this += (-day);
    }
    
	//注意这里进入循环的条件是_day<=day，如果_day=day,依然还要加一个月
	while (_day <= day)
	{
		_month--;
		if (_month == 0)
		{
			_month = 12;
			_year--;
		}
		_day += GetMonthDay(_year, _month);
	}

	_day -= day;
	return *this;

}

-的逻辑和-=的逻辑是一样的，直接复用即可：

Date Date::operator-(int day)const
{
	Date tmp = *this;
	tmp -= day;

	return tmp;
}

除了用-复用-=，我们是否还可以用-=复用-？答案是肯定的


Date Date::operator+(int day) const
{
	Date tmp = *this;

	tmp._day += day;
	while (tmp._day > tmp.GetMonthDay(tmp._year, tmp._month))
	{
		tmp._day -= tmp.GetMonthDay(tmp._year, tmp._month);
		tmp._month++;
		if (tmp._month == 13)
		{
			tmp._year++;
			tmp._month = 1;
		}
	}

	return tmp;
}

Date& Date::operator+=(int day)
{
	*this = *this + day;
	return *this;
}

但是-复用-=好还是-=复用-好呢？我们来比较一下

我们现在来实现一下日期<:日期1<日期2的情况有三种：①年小②年相等月小③年相等月相等天小，代码如下：

bool Date::operator<(const Date& d)const
{
	if (_year < d._year)
	{
		return true;
	}
	else if(_year == d._year)
	{
		if (_month < d._month)
		{
			return true;
		}
		else if (_month == d._month && _day < d._day)
		{
			return true;
		}
	}
	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);
}

我么再来实现一下前置++和后置++，重载++运算符时，有前置++和后置++，运算符重载函数名都是operator++，无法很好的区分。C++规定，后置++重载时，增加⼀个int形参，但这个int并不接收，跟前置++构成函数重载，方便区分。并且我们复用一下+=。前置++没有拷贝，后置++有拷贝。

Date Date::operator++(int)
{
	Date tmp = *this;
	_day += 1;
	return tmp;
}

// ++d1;
// d1.operator++();
Date& Date::operator++()
{
	_day += 1;
	return *this;
}

现在我们在来实现一下日期1-日期2：

int Date::operator-(const Date& d) const
{
	int flag = 1;
	Date max = *this, min = d;
	if (*this < d)
	{
		max = d;
		min = *this;
		flag = -1;
	}
	int n = 0;
	while (min != max)
	{
		++min;
		++n;
	}

	return n * flag;
}

接着，我们来实现一下日期类的流插入和流提取，cout是osteram&类型的对象，而cin是isteram类型的对象。c++的cout和cin函数可以自动识别类型，是因为系统重载了一系列的osteram&类型的重载函数：

但是我们想支持cout输出自定义类型，需要我们自己重载函数，并且我们自定义的函数返回值与系统的一样为osteram&类型，因为<<的结合性是自左而右的，这样就可以支持连续的流插入。

ostream& operator<<(ostream& out)
{
	out << _year << "/" << _month << "/" << _day << endl;
	return out;
}

但如果我们直接将其写成成员函数，系统会报错，这是因为成员函数的第一个参数默认是this指针，而我们写的函数第一个参数却是osteram&，所以在调用函数的时候要写成d1<<cout，但是这种调用方式很不符合我们的逻辑，因此，我们只能把这个函数写在类外面的全局函数，并且传两个参数，让cout做左操作数。而写在类外面的无法访问私有变量，我们之前的解决方案有：①开放成公有②GetDay函数③友元函数，前面两种方法并不好，我们现在可以用友元函数，给全局的函数在类里面加一个友元声明，这样就可以访问私有变量了。

friend ostream& operator<<(ostream& out, const Date& d);

ostream& operator<<(ostream& out, const Date& d)
{
	out << d._year << "/" << d._month << "/" << d._day << endl;
	return out;
}

同理，流提取也是这样的，我们也是定义成友元函数，并且传两个参数，返回类型为isteram&类型，保证连续的流提取。但是流提取的时候用户可能会输入非法的日期，因此我们要对此进行检查并且再次输入，所以要使用一个循环，日期输入正确跳出循环。


istream& operator>>(istream& in, Date& d)
{
	while (1)
	{
		in >> d._year >> d._month >> d._day;
		if (!(d.CheckDate()))
		{
			cout << "输入日期非法，请重新输入！" << endl;
			cout << d << endl;
		}
		else
			break;
	}
	
	return in;
}

注意cin是绑定在cout的，cout每次流插入时，会将插入的对象存在缓冲区中，cin每次进行io操作时，就会刷新缓冲区，将缓冲区的内容刷新出来。

6. 取地址运算符重载

（1）const成员函数

①将const修饰的成员函数称之为const成员函数，const修饰成员函数放到成员函数参数列表的后
面。
②const实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进行修改。隐含的this指针的类型为Date* const const修饰Date类的Print成员函数，Print隐含的this指针由 Date* const this 变为 const Date* const this。