【C++类与对象】构造函数、析构函数、拷贝构造函数，赋值运算符重载

---

---

此文为C++学习默认函数时笔记，如有误区和理解错误的地方还请麻烦指出哦

---

前言：

如果一个类中什么成员都没有，简称为空类。

空类中真的什么都没有吗？并不是，任何类在什么都不写时，编译器会自动生成以下6个默认成员函数。

默认成员函数：用户没有显式实现，编译器会生成的成员函数称为默认成员函数。
在C++中我们的祖师爷为我们搞好了六个默认成员函数。

class Date
{};

一、构造函数

1.1 概念

当我们在学习类与对象时我们会发现：任何一个类都是需要初识化和销毁/清理的如果清理的话可能会造成内存泄漏。
参考下面代码：

class Date
{
	public:
 	void Init(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.Init(2022, 7, 5);
 	d1.Print();
 	Date d2;
 	d2.Init(2022, 7, 6);
 	d2.Print();
 	return 0;
}

我们看上面的代码中每个对象都要手动用Init函数初始化，如果对象或者实参的数据多一些的话每次的初始化未免有点麻烦。

所以这时候我们C++的祖师爷创建了构造函数。

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

1.2 构造函数的特性。

构造函数是特殊的成员函数，需要注意的是，构造函数虽然名称叫构造，但是构造函数的主要任务并不是开空间创建对象，而是初始化对象。
其特征如下：
1. 函数名与类名相同。
2. 无返回值。
3. 对象实例化时编译器自动且必须调用对应的构造函数。（ 没有就调用默认构造函数）
4. 构造函数可以重载。（一个类可以有多个构造函数）

#include<iostream>

class Date
{
public:
1.特性演示
	Date()//无参构造函数
	{ 
		_year = 1;
	    _month = 1;
		_day = 1;
	}
	Date(int year, int month, int day)//有参构造函数（这也是构造函数可以重载特性的演示）
	{
		_year = year;
		_month = month;
		_day = day;
	}
2.改进(我们日常使用最好用一下方式也能实现上述功能)
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1;             //调用无参构造函数

	Date d2(2024, 4, 3); //调用带参构造函数
}

注意当用无参构造函数初始化对象时，后面不要带括号 ” （） “，带了括号就成了函数声明。

Date d3 ();//如果是这种格式的话就成为了函数声明，
//声明了一个返回值是Date 函数名字是d3且无参的函数。

用以上格式就会报错：warning C4930: “Date d3(void)”: 未调用原型函数(是否是有意用变量定义的?)

5.当我们没有写构造函数时，编译器初始化对象时就会调用默认构造函数。
默认构造函数要注意的点：
①. 它对内置类型成员不做处理。

②. 对于自定义类型的成员，去调用它的默认构造（调用无参构造函数）

③. 默认构造函数不仅仅是编译器自己生成，我们自己写出来的**全缺省和无参构造函数也算是默认构造函数。**不过当无参和全缺省默认构造函数都存在时，调用时会出现歧义。（语法上倒是支持两个都存在）

二、析构函数

2.1 概念

在构造函数中我们了解了对象怎么初始化，但是对象又是怎么没的呢，这是我们在C++中就要用到析构函数。

析构函数的功能跟构造函数的功能相反，析构函数没有对对象本身的销毁，局部对象的销毁工作是由编译器自己完成的跟析构函数没有关系，析构函数是对象在销毁时会自动调用，完成对象中资源的清理工作。类似与free

2.2 特性

析构函数也是特殊的成员函数。
析构函数特征：

1. 析构函数名是在类名前加上字符 ~。(跟构造函数类似)

class Date
{
	~Date()
	{}
};

2. 没有参数也没有返回类型。
3. 一个类只能有一个析构函数。要是我们自己不主动写析构函数的话，系统会自动生成默认的析构函数。注意：析构函数不能重载
4. 对象生命周期结束时，C++编译系统自动调用析构函数。

三、 拷贝构造

3.1 概念

在构造完成一个对象d1，且在它身上做了一些修改时，比如我们想对d1进行一个备份或者时复制，用以完成保留数据的工作。我们能否像赋值内置类型i = j 一样复制我们的对象呢？

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

3.2 特性

拷贝构造的格式就由上述图片里那样定义（后面会有修改，先这样理解）

但是这样的话我们的编译器会报错，提示我们不能让Date类型做函数的形参。

先提前声明在我们Date类里其实可以用这种格式。

这种传参是传值传参
1.传内置类型时，编译器会直接拷贝。
2.传自定义类型时，需要调用拷贝构造。

Date (Date d)
{}

像Date类中只存在内置类型（int _year, int _month, int _day）的类编译器会直接进行拷贝

把d2拷贝给d1我们用浅拷贝按字节依次拷贝过去（编译器只会用前拷贝）
这样来看我们好像也没什么问题

但是遇到另一种类我们就会发现有很大问题
当我们用Stack类时

class Stack
{
	int* _a;
	int _size;
	int _capacity;

};

再用默认的前拷贝方式我们就会发现size和capacity都能复制过去，但是a中存的是一个地址占了四个字节，
用前拷贝的方式只能把地址拷贝过去，这时我们就会发现 s1._a 和 s2._a 指向的是同一块空间，这就形成了互相干扰，另外这两个类结束时都会形成析构函数，会同时对这块空间进行两次析构。

所以按以上的铺垫我们就能了解为什么不能使用“ Date （Date d）”这种方式。
这时会形成无限的递归。为什么呢我们往下看
1.因为我们编写“ Date d3 (d1)”时就要先实例化我们的对象，实例化的时候就要去找到它对应的构造函数

第一轮：找到了上图这个构造函数（也是类中的拷贝构造函数），
找到之后我们就要传值传参我们的对象d1，但是传值传参时我们需要调用拷贝构造（上述有写到），这时就又需要调用上图这个拷贝构造。
第二轮：又要把d1传值传参传过去，但是传值传参需要用到拷贝构造，所以又需要调用拷贝构造
第三轮：又又要把d1传值传参传过去，又但是传值传参需要用到拷贝构造，又需要调用拷贝构造
第四轮。。。。
所以这里会无限的递归下去

所以在拷贝构造函数里我们要用到传引用传参。
传引用传参的过程中不会对对象进行复制的操作。

补充：

1. 一般为了防止自己在编代码过程中脑子突然糊涂，建议在参数前加上const

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

2.这种也算拷贝构造

 Date d3 = d1;

四、赋值运算符重载

4.1 运算符重载

C++为了增加代码的可读性，增加了运算符重载这个功能
我们来看，如果用C语言的思想我们该怎么比较日期类的大小或是想不想等呢?

1.比较两个日期类是否相等
bool Equal( d1 , d2)
{
   	return (d1._year == d2._year;
   	&&d1._month == d2._month;
   	&&d1._day == d2._day)
}
1.1如果有些人用函数命名不规范时
bool xiangdeng( d1 , d2)
{
   	return (d1._year == d2._year;
   	&&d1._month == d2._month;
   	&&d1._day == d2._day)
}

我们会发现如果有些时候别人或者我们自己函数命名不规范时，就会发生我们的代码阅读问题。而且每次调用也不方便。

运算符重载就是为了这种情况诞生的。

4.2 运算符重载特性

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

左操作数是this指向调用函数的对象。
//bool operator==(Date this* d1, const Date& d2)
日常写的话可以省略this指针
bool operator ==(const Date& d2)
{
    return d1._year == d2._year
   && d1._month == d2._month
        && d1._day == d2._day;
}

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

• 不能通过连接其他符号来创建新的操作符：比如operator@
• 重载操作符必须有一个类类型参数
• 用于内置类型的运算符，其含义不能改变，例如：内置的整型+，不 能改变其含义
• 作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐 藏的
• this .* :: sizeof ?: .注意这5个运算符不能重载。这个经常在笔试选择题中出 现。

运算符重载练习↓

class Date
{
public:
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) && (_month < d._month))
   	{
   		return true;
   	}
   	else if ((_year == d._year) && (_month == d._month) && (_day < d._day))
   	{
   		return true;
   	}
   	return false;
   }
   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);
   }
   bool operator != (const Date& d)
   {
   	return !(*this == d);
   }
private:
   int _year;
   int _month;
   int _day;
};

参考上面代码，我们在使用这种判断类时，我们完成了其中一个或者几个的判断，之后就可以复用了，这会节省很多时间。这种方法适用与这种判断类，所以之后要常常使用这种方法。

4.3 赋值运算符重载

1.赋值运算符重载格式

class Date
{ 
public :
Date(int year = 1970, int month = 1, int day = 1)
  {
       _year = year;
       _month = month;
       _day = day;
  }

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



1.因为this出了作用域还在所以用引用返回节省空间
2.如果想要像内置类型的赋值一样连续赋值，保持运算符特性
 我们就需要这个函数要一个返回值（不用注释是因为注释之后内容有些不显）
Date& operator=(const Date& d)//也可以不加引用Date operator（const Date d）
{
   	 if(this != &d) 这里就是要判断一下是否在自己给自己赋值
      {
           _year = d._year;
           _month = d._month;
           _day = d._day;
      }
       
       return *this;

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

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

补充：当我们不写拷贝构造和赋值重载时，编译器会自动生成默认拷贝构造和赋值重载
1.对于内置类型会完成浅拷贝
2.对于自定义类型会去调用这个成员的拷贝构造/赋值重载。

2. 赋值运算符只能重载成类的成员函数不能重载成全局函数

class Date
{
public:
Date(int year = 1900, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
int _year;
int _month;
int _day;
};
// 赋值运算符重载成全局函数，注意重载成全局函数时没有this指针了，需要给两个参数
Date& operator=(Date& left, const Date& right)
{
	if (&left != &right)
{
    left._year = right._year;
	left._month = right._month;
	left._day = right._day;
}
return left;
}
这里会编译失败

原因：赋值运算符如果不显式实现，编译器会生成一个默认的。此时用户再在类外自己实现一个全局的赋值运算符重载，就和编译器在类中生成的默认赋值运算符重载冲突了，所以赋值运算符重载只能是类的成员函数

五、 前置++和后置++重载（Date类中实现）

1.前置++

//*this出作用域还在，就建议要用引用返回！！！
// d1++ -> d1.operator++() 它俩是等价的哦
Date& operator++()
{
	*this += 1;
	return *this;
}

2.后置++

注意：这里C++规定后置++重载时多增加一个int类型的参数(这里int参数仅仅只是为了占位，跟前置重载区分)，但调用函数时该参数不用传递，编译器自动传递。

//tmp出作用域销毁，不能用引用返回。
// d1++ -> d1.operator++(0)
Date operator++(int)
{
	Date tmp = *this;
	*this += 1;
	return tmp;
}

前置减减和后置减减同理。

六、const成员

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

格式：

class Goat
{   1.const修饰*this
	2.this的类型变成const Goat*
	void  func() const 
	{}
};

建议：当该函数功能不需要修改成员变量，最好加上const，const对象和普通对象都可以调用。

七、取地址及const取地址操作符重载

这两个默认成员函数一般不用重新定义 ，编译器默认会生成。

class Date
{ 
public :
Date* operator&()
{
	return this ;
}
const Date* operator&()const
{
	return this ;
}
private :
	int _year ; 
	int _month ; 
	int _day ; 
};

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

好了今天的学习就到这里了哦，下次见。