《C++类基本知识和6个默认成员函数详细剖析》

面向对象编程–类的认识

之前我们学习了C语言知识，C语言是一种面向过程的程序设计语言，而C++语言呢是基于面向对象的一种程序设计语言，关注的是对象，即将一件事情拆分成不同的对象，靠对象间的交互完成。接下来就对C++中最重要的类进行详细的介绍。

面向对象的三个特性是：封装、继承、多态

1.类的基本认识

类简单来说就是由成员函数和成员变量构成的一个集合。类的定义和定义结构体是类似的。只不过定义类用的关键字是class。
需要留意的是：C语言中，结构体中只能定义变量，但是在C++语言中，结构体内不仅可以定义变量，也可以定义函数。这是结构体在不同语言下的差异。
类的定义：类体是由成员函数和成员变量组成。class为定义类的关键字，其后跟类名，{}中是类的主体，在括号外有一个分号：。具体定义如下：

class Date//关键字class 类名{};
{
public:
	//类的成员函数
	void setDate(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	//类的成员变量
	int _year;
	int _month;
	int _day;
};

这是类的一种定义方式，即将声明和定义全部放在类体中，需要注意的是，成员函数如果在类中定义，编译器可能会将其当成内联函数处理。
第二种类的定义方式是;将声明和定义分开写，即声明放在类的头文件.h中，定义放在类的实现文件.cpp中，具体如下所示：

在上面的代码解释中有public和private,接下来就具体说说这是什么东东。其实这是类的访问限定符，通过限定符做到某些访问权限程度的目的。
类的访问限定符有三种：public共有，private私有和protected保护。
被public修饰的成员在类外可以直接被访问，而protected和private修饰的成员在类外不能直接被访问。
class类的默认访问权限为private，而struct为public。
封装：C++实现封装的方式：用类将对象的属性和方法结合在一块，让对象更加完善，通过访问权限选择性的将其接口提供给外部的用户使用。其中类中的数据称为类的属性或者成员变量，类中的函数称为类的方法或者成员函数。
this指针： C++编译器给每个“非静态的成员函数“增加了一个隐藏的指针参数，让该指针指向当前对象(函数运行时调用该函数的对象)，在函数体中所有成员变量的操作，都是通过该指针去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。
this指针的特性
(1).this指针的类型：类类型* const
(2).只能在“成员函数”的内部使用
(3). this指针本质上其实是一个成员函数的形参，是对象调用成员函数时，将对象地址作为实参传递给this形参。所以对象中不存储this指针。
(4).this指针是成员函数第一个隐含的指针形参，一般情况由编译器通过ecx寄存器自动传递，不需要用户传递。
具体如下所示：

void setDate()
		{
			cout << _year << endl;
		}

编译器处理成员函数隐含的this指针之后如下：

void setDate(Date* this)
		{
			cout << this->_year << endl;
		}

类的实例化：用类类型创建对象的过程，称为类的实例化。特征有：
1.定义出来的类并没有分配实际的内存空间，类只是一个模型。
2.实例化出来的对象，占用实际的物理空间，存储类成员变量。

类的大小计算：

类的存储方式只保存成员变量，成员函数存放在公共的代码段。
类的大小实际就是该类中成员变量之和，也是需要内存对齐的。空类的大小是1。如下计算类的大小：

//类中有成员函数和成员变量
class A{
public:
	void fun1()
	{ }
private:
	int _a;
	double _c;
	char _b;
};
//类中仅有成员函数
class B{
public:
	void fun2()
	{ }
};
//空类
class C
{};
void test()
{
	cout << sizeof(A) << endl;//结果是24
	cout << sizeof(B) << endl;//结果是1
	cout << sizeof(C) << endl;//结果是1
}

类的作用域：类的所有成员都在类的作用域中，在类外定义成员，需要用::作用域解析符指明成员属于哪个类域。如下代码解释：

class Date{
public:
	void setDate();
private:
	int _year;
	int _month;
	int _day;
};
//这里需要制定setDate是属于Date这个类域
void Date::setDate()
{
	cout << _year << "-" << _month << "-" << _day << endl;
}

2.类的默认成员函数（6个）

1.构造函数：主要完成初始化工作。构造函数也是一种特殊的成员函数，但是构造函数虽然名叫构造，需要注意的是构造函数的主要任务不是开空间创建对象，而是初始化对象。
构造函数的特性有：
（1）首先函数名和类名相同。
（2）构造函数没有返回值。
（3）对象实例化时编译器自动调用对应的构造函数。
具体如下代码解释：

class Date{
public:
	//无参构造函数
	Date(){}
	//带参构造函数
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void setDate();
private:
	int _year;
	int _month;
	int _day;
};
void  testDate()
{
	Date d1;//调用无参构造函数
	Date d2(2021,3,10);//调用有参构造函数
}

需要注意的是：如果通过无参构造函数创建对象时，对象后面不用跟括号，否则就成了函数声明。

（4）构造函数也是可以重载的。
（5）构造函数如果在类中没有显示定义，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显示定义编译器将不再生成。
析构函数：主要完成清理工作
（6） 无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认成员函数。

2.析构函数： 完成类的一些资源清理工作。析构函数也是特殊的成员函数。
析构函数的特性有：
（1）析构函数名是在类名前面加上字符~。
（2）析构函数没有返回值。
（3）一个类有且只有一个析构函数，若没有显式定义，系统会自动生成默认的构造函数。
（4）对象生命周期结束时，C++编译器系统自动调用析构函数。

3.拷贝构造函数： 也是特殊的成员函数其特性有：
（1）拷贝构造函数是构造函数的一种重载形式。
（2）拷贝构造函数的参数只有一个且必须使用引用传参，使用传值方式会引发无穷递归调用。
（3）若为显示定义，系统生成默认的拷贝构造函数，默认的拷贝构造函数对象按内存存储，按字节序完成拷贝，此时的拷贝叫做浅拷贝，或者值拷贝。

4.赋值运算符重载函数：
运算符重载是具有特殊函数名的函数，是具有返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。函数名字为：关键字operator后面接需要重载的运算符符号。例如： operator++
完整的函数原型为：返回值类型 operator 操作符(参数列表)，例如：
bool operator==(const Date& d)。
有以下几点需要注意：
（1）重载操作符必须有一个类类型或者枚举类型的操作数。
（2）不能通过连接其他符号来创建新的操作符，例如：operator@
（3）用于内置类型的操作符，其含义不能改变。
（4）作为类成员的重载函数时，其形参看起来比操作数数目少1成员函数的操作符有一个默认的形参this，限定为第一个形参。
（5）这5个运算符是不能重载的：*、::、sizeof、？:、. 。
赋值运算符主要有四点：

1.参数类型
2.返回值
3.检测是否自己给自己赋值
4.返回*this
5.一个类如果没有显示定义赋值运算符重载，编译器也会生成一个，完成对象按字节序的值拷贝。

案例：日期类的实现

class Date{
public:
	//获取某年某月的天数
	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;
	}

	//全缺省的构造函数
	Date(int year = 2021, int month = 3, int day = 10)
	{
		//判断日期是否有效
		if (year <= 0 || month <= 0 || month > 12 || day <= 0 || day > GetMonthDay(year, month))
		{
			year = 1;
			month = 1;
			day = 1;
			cout << "日期无效，设为默认值为1-1-1" << endl;
		}
		else
		{
			_year = year;
			_month = month;
			_day = day;
		}
	}
	//日期运算：Date+=int,
	//左操作数+=右操作数：左操作数内容发生变化，返回的是相加之后的值 
	Date& operator+=(int day)
	{
		//判断日期是否为负数
		if (day<0)
		{
			return *this -= -day;
		}

		_day += day;//相加天数
		//判断天数是否溢出
		while (_day > GetMonthDay(_year, _month))
		{
			//减去当月的天数
			_day -= GetMonthDay(_year,_month);
			//月份进位
			++_month;
			//判断月份是否溢出
			if (_month == 13)
			{
				//下一年的1月份
				//年份进位
				++_year;
				_month = 1;
			}
		}
		//返回相加之后的结果
		return *this;
	}
	//Date+int:返回相加之后的结果，操作数不能改变
	Date operator+(int day)
	{
		Date copy(*this);
		copy += day;
		return copy;
	}

	//++Date,前置++
	Date& operator++()
	{
		return *this += 1;
	}

	//Date++,后置++,此处的int是为了区分operator函数重载
	Date operator++(int)
	{
		Date copy(*this);
		*this += 1;
		return copy;
	}

	//Date-=int
	Date& operator-=(int day)
	{
		//判断日期是否为负数
		if (day < 0)
		{
			return *this += -day;
		}

		_day -= day;//相减天数
		//判断天数是否溢出
		while (_day <= 0)
		{
			//用上一个月的天数回补
			--_month;
			//判断月份是否溢出（向下）
			if (_month == 0)
			{
				//年份退位，到上一年的12月份
				--_year;
				_month = 12;
			}
			//加上上月的天数回补
			_day += GetMonthDay(_year, _month);
		}
		//返回相减之后的结果
		return *this;
	}
	//Date-int：返回相减之后的值，day不能变的
	Date operator-(int day)
	{
		Date copy(*this);
		copy -= day;
		return copy;
	}
	//--Date,前置--
	Date& operator--()
	{
		return *this -= 1;
	}

	//Date--,后置--
	Date operator--(int)
	{
		Date copy(*this);
		*this -= 1;
		return copy;
	}

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

	//>
	bool operator>(const Date& d)
	{
		if (_year > d._year)
			return true;
		else if (_year == d._year)
		{
			if (_month > d._month)
				return true;
			else if (_month == d._month)
			{
				if (_day > d._day)
					return true;
			}
		}
		return false;
	}
	//<
	bool operator<(const Date& d)
	{
		return !(*this >= d);
	}

	//>=,即>或者=
	bool operator>=(const Date& d)
	{
		return *this>d || *this == d;
	}

	//<=,即>取反
	bool operator<=(const Date& d)
	{
		return !(*this > d);
	}

	//!=,即等于取反
	bool operator!=(const Date& d)
	{
		return !(*this==d);
	}
	//Date-Date:日期相减
	int operator-(const Date& d)
	{
		Date max = *this;
		Date min = d;
		int flag = 1;
		if (max < min)
		{
			max = d;
			min = *this;
			flag = -1;
		}
		int day = 0;
		while (min < max)
		{
			++min;
			++day;
		}
		return flag*day;
	}
	void printDate(const Date* this)
	{
		cout <<this-> _year << "-" <<this-> _month;
		cout << "-" << this->_day << endl;
	}

private:
	int _year;
	int _month;
	int _day;
};

5.const修饰类的成员函数：
将const修饰的类成员函数称之为const成员函数，const修饰类成员函数，实际修饰该成员函数隐含的this指针，在该成员函数中不能对类的任何成员进行修改。如下代码解释：

void printDate()const
	{
		cout << _year << "-" << _month;
		cout << "-" << _day << endl;
	}

编译器对const成员函数的处理之后如下：

void printDate(const Date* this)
	{
		cout <<this-> _year << "-" <<this-> _month;
		cout << "-" << this->_day << endl;
	}

特别留意：
（1）const对象不可以调用非const成员函数。
（2）const成员函数内不可以调用其他的非const成员函数。
（3）非const对象可以调用const成员函数。
（4）非const成员函数内可以调用其它的const成员函数。