【C++】构造函数、析构函数、拷贝构造与运算符重载

1.类的六个默认构造函数

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

class test
{};

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

默认成员函数：用户没有显式实现，编译器自动生成的成员函数称为默认成员函数。

2.构造函数

class Data
{
public:void Init(int year = 1, int month = 1, int day = 1){this->_year = year;this->_month = month;this->_day = day;}void Print(){cout << _year << "-" << _month << "-" << _day << endl;}private:int _year;int _month;int _day;
};int main()
{Data d1;d1.Init(2024, 5, 22);d1.Print();Data d2;d2.Init(2024, 5, 21);d2.Print();return 0;
}

对于上方的Date类，可以通过 Init 公有方法给对象设置日期，但如果每次创建对象时都调用该方法设置信息，未免有点麻烦，那能否在对象创建时，就将信息设置进去呢？

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

2.1特性

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

特性：

2.1.1 函数名与类名相同

2.1.2. 无返回值（不能写void）

2.1.3. 对象实例化时编译器自动调用对应的构造函数

2.1.4 构造函数可以重载

特别注意：在调用无参构造时，后面不能跟括号。

2.1.5编译器生成默认的构造函数

如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成。

未显示定义，编译器自动生成，可以通过编译

若显示定义了构造函数，编译器不再生成；即没有默认构造函数，编译报错。

2.1.6编译器生成的默认构造有何用？

不实现构造函数的情况下，编译器会生成默认的构造函数。但是看起来默认构造函数又没什么用？
下面代码中，d对象调用了编译器生成的默认构造函数，但是d对象_year/_month/_day，依旧是随机值。也就说在这里编译器生成的默认构造函数并没有什么用？？

存在即合理，它还是有一定的用处的。
C++把类型分成内置类型(基本类型)和自定义类型。

• 内置类型就是语言提供的数据类型，如：int/char/float/任何类型的指针…，
• 自定义类型就是我们使用class/struct/union等自己定义的类型，

对于内置类型来说，C++标准并没有规定要不要处理（可处理，可不处理，取决于编译器）

对于自定义类型来说，会调用该类型的默认构造函数

看看下面的程序，就会发现编译器生成默认的构造函数会对自定类型成员 _t 调用的它的默认成员函数。

注意：：C++11 中针对内置类型成员不初始化的缺陷，又打了补丁，即：内置类型成员变量在类中声明时可以给默认值（类中不是定义，类的实例化才是定义，易错）

2.1.7三种默认构造函数

无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。

三种默认构造函数：

• 无参构造函数
• 全缺省构造函数
• 我们没写编译器默认生成的构造函数

注意：无参构造与全缺省的构造只能存在一个，否则会存在调用歧义

总结：

• 无需传参就可以调用的构造函数就是默认构造函数。
• 一般情况下，构造函数都需要我们显示的去实现。
• 只有少数情况下可让编译器自动生成构造函数，例如成员全是自定义类型

3.析构函数

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

3.1特性

3.1.1析构函数名是在类名前加上字符 ~

3.1.2无参数无返回值类型（不能写void）

3.1.3一个类只能有一个析构函数。

一个类只能有一个析构函数若未显式定义，系统会自动生成默认的析构函数。注意：析构函数不能重载。

3.1.4对象生命周期结束时，编译系统自动调用析构函数

可以借助调试看一眼，我们并没有调用析构函数，但是在代码179行按F11会自动进入析构函数。

上面的代码我们好像没有看出来析构函数有什么用，那就看下面的代码：
下方代码我们简单的实现了一个栈，此时编译器自动调用栈所实现的析构函数，会将我们所申请的资源清理掉。

typedef int DataType;
class Stack
{
public://构造Stack(size_t capacity = 3){this->_array = (DataType*)malloc(sizeof(DataType) * capacity);if (NULL == _array){perror("malloc申请空间失败!!!");return;}this->_capacity = capacity;this->_size = 0;}void Push(DataType data){// CheckCapacity();_array[_size] = data;_size++;}//析构~Stack(){if (_array){free(_array);_array = NULL;_capacity = 0;_size = 0;}}
private:DataType* _array;int _capacity;int _size;
};
int main()
{Stack s;s.Push(1);s.Push(2);return 0;
}

3.1.5编译器生成的默认析构函数

关于编译器自动生成的析构函数，是否会完成一些事情呢？
下面的程序我们会看到，编译器生成的默认析构函数，对自定类型成员调用它的析构函数；对内置类型成员不做处理。

总结：

1. 有资源需要清理的，就需要写析构函数，否则会造成内存泄漏问题。如：栈、链表…
2. 有两种情况不需要写析构，编译器默认生成的就可以
   a.全是内置类型的成员，没有资源需要清理的。如Date类…
   b.内置类型成员无需清理，其它都是自定义类型的成员。如两个栈实现一个队列

4.拷贝构造

在创建对象时，可否创建一个与已存在对象一模一样的新对象呢？

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

4.1特征

拷贝构造函数也是特殊的成员函数，其特征如下：

4.1.1拷贝构造函数是构造函数的一个重载形式

没有返回值

class Date
{
public://构造函数Date(int year, int month, int day){this->_year = year;this->_month = month;this->_day = day;}//拷贝构造Date(const Date& d){this->_year = d._year;this->_month = d._month;this->_day = d._day;}private:int _year;int _month;int _day;
};int main()
{Date d1(2024,5,24);//拷贝构造//以下两种方式等价Date d2(d1);Date d3 = d1;return 0;
}

4.1.2拷贝构造函数的参数

拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错，因为会引发无穷递归调用。

为什么会引起无穷递归呢？

首先我们要知道，自定义类型传值传参要调用拷贝构造（可以看成一种规定）

下面的代码调试可以发现，当我们第一次按F11进入fun函数时，它是先进入到了Date类中的拷贝构造函数，第二次按F11才会进入fun函数。

如果这样，不写引用的话就会引发无穷的递归。

本来是只想调用拷贝构造，但是调用前要传参数，传递参数又要发生拷贝构造；那么还是要传递参数，此时就会形成没有尽头的递归，

4.1.3编译器生成默认的拷贝构造函数(浅拷贝)

若未显式定义，编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。

我们发现，对于所有成员确实都拷贝过去了，可是对于数组元素来说，它们两个数组的地址是相同的，也就是二者数组的同一块空间，这就有点不好了。

注意：
在编译器生成的默认拷贝构造函数中，内置类型是按照字节方式直接拷贝的；而自定义类型是调用其拷贝构造函数完成拷贝的。

4.1.4拷贝构造函数典型调用场景：

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

class Date{public:Date(int year, int minute, int day){cout << "Date(int,int,int):" << this << endl;}Date(const Date& d){cout << "Date(const Date& d):" << this << endl;}~Date(){cout << "~Date():" << this << endl;}private:int _year;int _month;int _day;};Date Test(Date d){Date temp(d);return temp;}int main(){Date d1(2022,1,13);Test(d1);return 0;}

总结：

• 如果没有管理资源，一般不需要写拷贝构造，默认生成的拷贝构造就可以。如Data
• 如果都是自定义类型的成员，内置类型成员也没有指向资源，也类似默认生成的拷贝构造就可以。如两个栈实现队列
• 一般情况下，不需要显示的写析构函数，就不需要显示的写拷贝构造
• 如果内部有指针或一些值指向资源，需要写析构释放，通常就需要显示写构造完成深拷贝。如：Stack、List等。

5.赋值运算符重载

我们写了这么多的日期类，好像都没怎么操作过，下面写个日期的比较吧：
比如我们写个函数比较两个日期哪个小，那么我们就得这样写：

bool CompareLess(Date& d1, Date& d2)
{if (d1._year < d2._year){return true;}else if(d1._year == d2._year){if (d1._month < d2._month){return true;}else if (d1._month == d2._month){return d1._day < d2._day;}}return false;
}

如果比较两个日期哪个大呢？是不是又得写一份类似的代码，而且调用的时候可读性又不好，如下：

bool CompareLarger(Date& d1, Date& d2)
{if (d1._year > d2._year){return true;}else if (d1._year == d2._year){if (d1._month > d2._month){return true;}else if (d1._month == d2._month){return d1._day > d2._day;}}return false;
}
int main()
{Date d1(2024, 6, 25);Date d2(2024, 6, 1);Date d3(2025, 6, 1);cout << CompareLess(d1, d2) << endl;cout << CompareLess(d2, d3) << endl;return 0;
}

那能不能像内置类型那样直接用> < 这样比呢？那样多得劲。但是很遗憾，C++不支持这样写

但是祖师爷发明了运算符重载来支持这样写。

5.1运算符重载

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

函数名字为：关键字operator 后面接需要重载的运算符符号。
函数原型：返回值类型 operator操作符(参数列表)

//全局的两个函数
//bool CompareLess(Date& d1, Date& d2)
bool operator<(Date& d1, Date& d2)//操作符重载
{if (d1._year < d2._year){return true;}else if(d1._year == d2._year){if (d1._month < d2._month){return true;}else if (d1._month == d2._month){return d1._day < d2._day;}}return false;
}//bool CompareLarger(Date& d1, Date& d2)
bool operator>(Date& d1, Date& d2)//操作符重载
{if (d1._year > d2._year){return true;}else if (d1._year == d2._year){if (d1._month > d2._month){return true;}else if (d1._month == d2._month){return d1._day > d2._day;}}return false;
}int main()
{Date d1(2024, 6, 25);Date d2(2024, 6, 1);Date d3(2025, 6, 1);//显示调用cout << operator>(d1, d2) << endl;//隐式调用cout << (d1 < d2) << endl;cout << (d2 > d3) << endl;return 0;
}

注意：

• 不能通过连接其他符号来创建新的操作符：比如operator@

• 重载操作符 必须有一个类类型参数（即不可以重新定义内置类型已经存在的操作符的行为）

• .* (点星)、 :: (域限定符) 、sizeof 、?:（三目运算符） . (成员点)。注意以上5个运算符不能重载。这个经常在笔试选择题中出现。
• 作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的this
  我们一般将运算符重载放在类中，而不是类外。因为成员变量通常是私有的，在类外是访问不到的，所以通常将函数重载作为类的成员函数。（上面代码可以访问是因为将它放为public了）

5.2赋值运算符重载

5.2.1赋值运算符重载格式

参数类型：const T&，传递引用可以提高传参效率

5.2.2返回值类型

返回值类型：T&，返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值

假设有下面的代码，我想让d1变成d4，那会发生什么呢？

此时调用的不是拷贝构造，而是一个赋值拷贝（将一个已经存在的对象，拷贝赋值给另一个已经存在的对象）

那赋值应该怎么写呢？下面这样写就可以吗？

但是很多人都不是这样写的，别人是这样写的，有一个返回值：

这样写是因为可能存在连续的赋值

int main()
{Date d1(2024, 5, 27);//拷贝构造Date d2 = d1;Date d3(d1);Date d4(2024,5,30);d1 = d4;//此时是什么？赋值拷贝d1 = d2 = d4; //连续赋值return 0;
}

很多人也都建议使用引用返回：

那传值返回与传引用返回有什么区别呢？效率上的区别
看下面的func函数：

那有没有什么方式让它不发生拷贝构造呢？传引用返回
下面代码没有发生拷贝构造

但此时会有问题，确实减少了拷贝，但是引用实际上就是给d取了一个别名，二者都指向d，但是d都析构了，此时返回了临时变量的地址，类似于C中的野指针了。

二者地址打印出来是一样的。

总结一下：
若返回对象是一个局部对象或临时对象，出来当前函数的作用域就析构销毁了，就不能使用引用返回，用引用返回是存在风险的，引用对象在那个函数的栈帧中已经销毁了。

即：

• 出了作用域，返回对象还没有析构，那就可以传引用放回，减少拷贝
  a、返回对象声明周期到了，会析构，传值返回
  b、返回对象声明周期没到，不会析构，传引用返回

对于最开始写的日期的赋值重载，this在operator的栈帧上，但是*this在main函数的栈帧中，返回对象没有析构，因此可以使用引用返回。

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

为了防止有人自己给自己赋值，赋值前可以判断一下，提高效率，避免不必要的操作。

5.2.4注意返回值

返回*this ：要复合连续赋值的含义

5.2.5重载成类的成员函数

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

5.2.6默认赋值运算符重载

跟拷贝构造类似，用户没有显式实现时，编译器会生成一个默认赋值运算符重载，以值的方式逐字节拷贝。
注意：

• 内置类型成员变量是直接赋值的，而自定义类型成员变量需要调用对应类的赋值运算符重载完成赋值
• 如果类中未涉及到资源管理，赋值运算符是否实现都可以；一旦涉及到资源管理则必须要实现。

5.3前置++与后置++重载

我们知道，前置++与后置++重载以后，二者是一样的，没有办法区分。我们的祖师爷就给后置++强行增加了一个int类型的形参，该形参不需要写参数名，调用函数参数不需要传（编译器自动传）或者 传递任何数都可，这个参数仅仅为了跟前置区分，不会使用。

一般会这样写：

5.4运算符重载拓展

我们之前要想打印类中的成员变量，都是写了一个Print函数

那我们能不能使用C++标准库中的cout与cin输出呢？

很显然，正常情况下是不可以的。
对于内置类型我们可以直接使用是因为C++标准库中已经写好了，流插入与流提取也是函数重载。

	int i = 10;cout << i;//上面的代码本质上转换为下面的cout.operator<<(i);

cout与cin可以自动识别类型，本质上是因为这些流插入重载构成函数重载。

那自定义类型要想写，那我们就得自己写函数重载，怎么写呢？如下：

此时我们发现依然无法调用，为什么呢？

如果我们自己调用，那就应该按下面的方式写。
你是我d1的成员函数嘛

void Test1()
{Date d1(2024, 5, 26);Date d2(1982, 6, 6);//cout << d1;//cout << d2;//自己写调用d1.operator<<(cout);d2.operator<<(cout);
}

所以我们应该按下面的方式写：

这样写又非常的奇怪，那我们能不能让它的顺序颠倒一下呢？

所以，operator<<想重载为成员函数可以，但是用起来不符合正常逻辑，不建议这样做，建议重载为全局函数。

6.const成员函数

有时候我们需要把对象设置为只读的，但是这时候就会存在一些问题。

因此，我们的祖师爷就规定在函数的后面加const，看起来很怪，但确实也没有什么好的办法了

7.取地址及const取地址操作符重载

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

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

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