深入理解C++的类和对象(中)

类的6个默认成员函数

构造函数

class Date
{
public:
    void Init(int year,int month,int day)
    {
        _year = year;
        _month = month;
        _day = day;
    }
private:
    int _year;
    int _month;
    int _day;
};

在之前的Date类中，可以通过Init公有方法来设置日期，但是如果每次创建对象都需要调用该方法就会闲的麻烦，且容易忘记，那能否在对象创建时，就将信息设置进去呢？

那就要请出“天选之子”——构造函数

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

 代码示例

//构造函数
class Date
{
public:
	//无参构造函数
	Date ()
	{
		_year = 2024;
		_month = 3;
		_day = 13;
	}
	//含参构造函数
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1;//无参构造函数的调用
	d1.Print();
	Date d2(2, 2, 2);//含参构造函数的调用
	d2.Print();
}

构造函数的特性 

构造函数是特殊的成员函数，需要注意的是，构造函数虽然名称叫构造，但是构造函数的主要任务并不是开空间创建对象，而是初始化对象。

• 函数名与类名相同。
• 无返回值。
• 对象实例化时编译器自动调用对应的构造函数。
• 构造函数可以重载。

 默认生成的构造函数

1. 内置类型成员不做处理。
2. 自定义类型成员，会去调用它的默认构造(不用传参数的构造)

视频演示：

自定义类型调用默认构造函数

 代码示例：

class Date
{
public:
	//无参构造函数
	Date ()
	{
		_year = 2024;
		_month = 3;
		_day = 13;
	}
	void Print()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
class Queue
{
public:
	void fun()
	{
		d1.Print();
		//...
	}
private:
	Date d1;
};
int main()
{

	Queue wq;
	wq.fun();
	
}

 

注意：C++11 中针对内置类型成员不初始化的缺陷，又打了补丁，即：内置类型成员变量在类中声明时可以给默认值。

析构函数

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

在程序结束前打上断点，程序会自动调用析构函数对对象成员的资源清理。

 析构函数的特性

• 析构函数名是在类名前加上字符 ~。
• 无参数返回类型。
• 一个类只能有一个析构函数。若未显示定义，系统会自动生成默认析构函数。注意：析构函数不能重载。
• 对象生命周期结束时，C++编译系统自动调用析构函数。

 默认生成的析构函数(与默认生成的构造函数类似)

拷贝构造函数

拷贝构造函数：只有单个形参，该形参是对本类类型对象的引用(一般常用const修饰)，在用已存在的类类型对象创建新对象时由编译器自动调用。

代码示例：

//拷贝构造函数
class Date
{
public:
	//构造函数
	Date(int year = 2024, int month = 3, int day = 13)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	//拷贝构造函数
	Date(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
	void Print()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(1,1,1);
	Date d2(d1);//拷贝构造
	d2.Print();
	return 0;
}

 这里，还有一种错误的拷贝构造写法

Date(const Date d)
    {
        _year = d._year;
        _month = d._month;
        _day = d._day;
    }

 在编译器中，语法是不支持的，但实际上如果编译器语法支持会形成一种无穷递归。这样的传参叫传值传参，而传值传参的本质是拷贝一份参数传过来，对于编译器而言内置类型是可以直接复制的，可对于自定义类型是不支持的而需要调用拷贝构造。

                

到这里便可以解释的通为什么会形成无穷递归，因为在对象实例化时会调用构造函数，而拷贝构造函数需要传值传参(错误写法)，但是这里又是自定义类型编译器会自动处理成调用拷贝构造 ，可是调用拷贝构造又需要传参数……所以这里就会形成一种无穷递归。

       在定义拷贝构造函数时为什么要用const修饰形参，因为如果在定义时不小心代码写反了(编译器不会报错)

 

则在运行时会造成

d2原本是要拷贝d1的，这里却将d1改成了随机值。因为d是d1的别名，所以加上const后是权限的缩小，再写反时会直接编译不通过，从而起到检查错误的效果。

拷贝构造函数的特性

• 拷贝构造函数是构造函数的一个重载形式。
• 拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错，因为会引发无穷递归调用。
• 若未显式定义，编译器会生成默认的拷贝构造函数。默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。
• 注意：在编译器生成的默认拷贝构造函数中，内置类型是按照字节方式直接拷贝的，而自定义类型是调用其拷贝构造函数完成拷贝的。
• 注意：类中如果没有涉及资源申请时，拷贝构造函数是否写都可以；一旦涉及到资源申请时，则拷贝构造函数是一定要写的，否则就是浅拷贝。

 默认生成的拷贝构造

这里与构造函数和析构函数有所差别，内置类型会做处理(浅拷贝/值拷贝)，自定义类型也会做处理(调用它的拷贝构造函数)。

当一个类没有写拷贝构造函数时，进行拷贝构造会自动调用默认的拷贝构造函数，但默认的函数只是浅拷贝，当自己实现了析构函数释放空间的时候，就需要自己实现拷贝构造函数。

运算符重载 

编译器对内置类型知道如何使用运算符，但对自定义类型无法自己判断如何使用运算符，所以自定义类型在想实现+  -  ==等这些运算符的意义时，就会变的非常麻烦，所以C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。
 

函数原型：返回值类型 operator 操作符(参数列表)         

注意：

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

 当2个操作数的运算符，第一个参数对应左操作数，第二个参数对应右操作数。

运算符重载实现在类内

下面是一种在类中实现运算符重载较为便捷的写法(通用)

当实现了其中两个运算符重载后，其他的可以直接使用已经实现的运算符重载对其进行取反等操作

class Date
{
public:
	Date(int year = 2024, int month = 3, int day = 13)
	{
		_year = year;
		_month = month;
		_day = day;
	} 
	//d1 == d2
	bool operator == (const Date& d)
	{
		return _year == d._year
			&& _month == d._month
			&& _day == d._day;
	}
	//d1<d2
	bool operator<(const Date& d)
	{
		if (_year < d._year)
		{
			return true;
		}
		else if (_year == d._year && _month < d._month)
		{
			return true;
		}
		else if (_year == d._year && _month == d._month && _day < d._day)
		{
			return true;
		}
		else
		{
			return false;
		}
	}
	//d1<=d2
	bool operator<=(const Date& d)
	{
		return *this < d || *this == d;
	}
	//d1>d2
	bool operator>(const Date& d)
	{
		return !(*this <= d);
	}
	//d1!=d2
	bool operator!=(const Date& d)
	{
		return !(*this == d);
	}
	//d1>=d2
	bool operator>=(const Date& d)
	{
		return !(*this < d);
	}
private:
	int _year;
	int _month;
	int _day;
};

赋值运算符重载 

赋值运算符重载格式：

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

  

这里看似已经完成了赋值重载，通常情况下赋值操作符是可以进行连续赋值的(如，a = b = c),但是这里却无法实现连续赋值 

其实在连续赋值时，从右往左执行当前一个赋值操作完成时会进行返回值然后再赋值给左边的变量，这里的赋值重载没有返回值，所以当我们进行修改后便不再报错了。 

调用完以后*this其实还在，如果使用传值返回还要再调用拷贝构造并且开空间，所以使用传引用返回来提高效率 。 

• 检测是否自己给自己赋值

	Date&  operator=(const Date& d)
	{
		if (this != &d)
		{
			_year = d._year;
			_month = d._month;
			_day = d._day;
		}
		return *this;
	}

默认赋值重载

6个默认成员函数包含赋值重载，所以默认生成的赋值重载，

• 内置类型完成值拷贝，——按字节一个一个拷贝
• 自定义类型，去调用这个成员的赋值重载

这一节内容非常重要，到这里就先结束了~

欢迎老铁们一起学习交流