【C++】03.类的默认成员函数

卡戎-caryon

已于 2024-08-05 14:34:45 修改

阅读量764

点赞数 8

分类专栏： C++ 文章标签： c++ 笔记

于 2024-04-15 18:16:09 首次发布

本文链接：https://blog.csdn.net/2301_80258336/article/details/137788277

版权

C++ 专栏收录该内容

14 篇文章 0 订阅

订阅专栏

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

在上一篇博客中，我们计算了空类的大小为 1 。那么空类中真的什么东西都没有吗？其实不是的，当一个类在什么都不写的时候就会自动生成6个默认的成员函数（用户没有写，但是编译器自动生成的成员函数）

接下来我们就将围绕上图展开本篇博客……

二、构造函数

2.1 构造函数的概念

构造函数是一个特殊的成员函数，名字与类名相同,创建类类型对象时由编译器自动调用，以保证每个数据成员都有一个合适的初始值，并且在对象整个生命周期内只调用一次

2.2 构造函数的特征

函数名与类名相同
无返回值（不需要写void）
实例化对象时由编译器自动调用
构造函数可以重载（一般建议写一个全缺省的构造）
若类中没有显示定义构造函数，则C++编译器会自动生成一个无参的默认构造函数。但是，一旦用户显示定义了构造函数，编译器就不会自动生成了
内置类型成员变量在类中声明时可以给默认值
无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。 注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认构造函数

关于编译器生成的默认成员函数，可能读者会有疑惑：不实现构造函数的情况下，编译器会生成默认的构造函数。但是看起来默认构造函数又没什么用？

C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语言提供的数据类型，如：int / char...，自定义类型就是我们使用class/struct/union等自己定义的类型。在C++中编译器生成默认的构造函数会对自定类型成员调用的它的默认成员函数，对内置类型不做处理。

三、析构函数

3.1 析构函数的概念

析构函数与构造函数功能相反，析构函数不是完成对对象本身的销毁，局部对象销毁工作是由编译器完成的。而对象在销毁时会自动调用析构函数，完成对象中资源的清理工作

3.2 析构函数的特征

函数名为在类名前加~
无参无返回值
一个类有且仅有一个析构函数（不支持函数重载），若未显示定义，则由系统自动生成默认的析构函数
对象生命周期结束时，由C++编译器自动调用析构函数
编译器生成的默认析构函数，对自定类型成员调用它的析构函数，对内置类型不处理
如果类中没有申请资源时，析构函数可以不写，直接使用编译器生成的默认析构函数

四、拷贝构造

4.1 拷贝构造函数的概念

使用一个已经存在的对象去构造一个新的对象的函数就叫做拷贝构造函数

4.2 拷贝构造函数的特征

拷贝构造函数也是构造函数的一个重载形式
若未显式定义，编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对对象的内置类型成员按内存存储按字节序完成拷贝，对对象的自定义类型成员调用它的拷贝构造进行拷贝
构造函数的参数有且仅有一个，且必须是类类型对象的引用。传值的话编译器会直接报错。因为会引发无限递归

引发无限递归的原因分析：

在传值调用过程中，需要对形参进行拷贝构造，但是并无拷贝构造函数，会引发无限递归，直到程序崩溃

注意：类中如果没有涉及资源申请时，拷贝构造函数是否写都可以；一旦涉及到资源申请时，则拷贝构造函数是一定要写的，否则就是浅拷贝

4.3 拷贝构造函数的使用场景

使用已存在对象创建新对象
函数参数类型为类类型对象
函数返回值类型为类类型对象

为了减少拷贝构造的次数以及时间的消耗，我们是能够使用引用传参就使用引用传参

我们接下来要讲的三个默认成员函数都涉及到了运算符重载的内容，因此在讲解剩余三个之前，我们先来介绍一下运算符重载……

五、运算符重载

C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似

函数的名字为：关键字operator后面接需要重载的运算符符号

函数原型为： 返回值类型 operator操作符（参数列表）

需要注意的是：

不能通过连接其他符号来创建新的操作符：比如operator@
重载操作符必须有一个类类型参数
用于内置类型的运算符，其含义不能改变（避免引发歧义）
作为类成员函数重载时，其形参看起来比操作数数目少1，这是因为成员函数的第一个参数是隐藏的this
.* :: sizeof ?: . 注意以上5个运算符不能重

运算符重载函数既可以是全局函数也可以是类的成员函数

六、赋值重载

6.1 赋值重载格式

参数类型：const T&，传递引用可以提高传参效率
返回值类型：T&，返回引用可以提高返回的效率，为了支持连续赋值
检测是否自己给自己赋值
返回*this ：要复合连续赋值的含义

//重载为成员函数
Date& operator=(const Date& d)
{
     if(this != &d)
     {
         _year = d._year;
         _month = d._month;
         _day = d._day;
     }
        
     return *this;
}

6.2 赋值重载函数

赋值运算符只能重载成类的成员函数不能重载成全局函数的原因：

赋值运算符如果不显式定义，编译器会生成默认的。而用户在类外实现了赋值运算符的重载，就会和编译器自动生成的冲突，因此赋值运算符只能是类的成员函数

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

在解决最后一个的取地址重载之前我们需要介绍一下const成员

七、const成员函数

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

八、取地址重载

通常情况下来说，这两个默认成员函数一般不用重新定义，编译器默认会生成

class Date
{
public:
	Date* operator&()
	{
		return this; 
	}

	const Date* operator&()const
	{
		return this;
	}
private:
	int _year; // 年
	int _month; // 月
	int _day; // 日
};

这两个运算符一般不需要重载，使用编译器生成的默认取地址的重载即可，只有特殊情况，才需要重载，比如想让别人获取到指定的内容！

九、日期类的实现

这里只有一点最为关键：就是 ++ 和 -- 的运算符重载问题，前置和后置操作符本质上并不会构成函数重载，因此在重载后置操作符手动的加上一个参数让他们达到重载关系，具体的实例见下面实现

#pragma once
//Data.h
#include<iostream>
using namespace std;

//日期类
class Data
{
	//下一篇文章将会介绍友元函数的内容
	friend ostream& operator<<(ostream& out, const Data& d);
	friend istream& operator>>(istream& in, Data& d);
public:
	//打印
	void Print() const
	{
		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& operator=(const Data& d);
	//析构函数
	~Data();

	//接下来是赋值运算符的重载
	Data operator+(int day)const;
	Data& operator+=(int day);
	Data operator-(int day)const;
	Data& operator-=(int day);

	//日期类的自增自减的实现
	Data operator++(int);//后置++
	Data& operator++();//前置++
	Data operator--(int);//后置--
	Data& operator--();//前置--

	//逻辑运算符重载
	bool operator==(const Data& d)const;
	bool operator<=(const Data& d)const;
	bool operator<(const Data& d)const;
	bool operator>=(const Data& d)const;
	bool operator>(const Data& d)const;
	bool operator!=(const Data& d)const;
	int operator-(const Data& d)const;

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) const
{
	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)const
{
	Data temp = *this;
	temp -= day;
	return temp;
}

//==
bool Data::operator==(const Data& d)const
{
	return _day == d._day && _month == d._month && _year == d._year;
}

//！=
bool Data::operator!=(const Data& d)const
{
	return !(*this == d);
}

//<
bool Data::operator<(const Data& d)const
{
	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)const
{
	return *this < d || *this == d;
}

//>
bool Data::operator>(const Data& d)const
{
	return !(*this <= d);
}

//>=
bool Data::operator>=(const Data& d)const
{
	return !(*this < d);
}

//差多少天
int Data::operator-(const Data& d)const
{
	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;
}