C++类和对象第二弹(构造，析构和拷贝构造函数)

前言

1. 类的6个默认成员函数

2. 构造函数

2.1 概念

2.2 特性

3. 析构函数

3.1 概念

3.2 特性

4. 拷贝构造函数

4.1 概念

4.2 特征

总结

前言

本文主要讲解类中构造函数、析构函数和拷贝构造函数。关于这三个类中默认成员函数的知识点很多，有许多代码示例，干货满满！

1. 类的6个默认成员函数

如果一个类中什么成员都没有，简称为空类。
空类中真的什么都没有吗？并不是，任何类在什么都不写时，编译器会自动生成以下6个默认成员函数。默认成员函数：用户没有显式实现，编译器会生成的成员函数称为默认成员函数。

构造函数：完成初始化的工作
析构函数：完成清理资源的工作
拷贝构造：使用同类型对象初始化创建对象
赋值重载：把一个对象赋值给另外一个对象
取地址重载：主要是普通对象和const对象取地址

2. 构造函数

2.1 概念

对于以下Date类：

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(2024, 4, 12);d1.Print();Date d2;d2.Init(2024, 4, 13);d2.Print();return 0;
}

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

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

2.2 特性

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

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

class Date
{
public:Date(){}Date(int year = 1, int month = 1,int day = 1){_year = year;_month = month;_day = day;}void Print(){cout << _year << "-" << _month << "-" << _day << endl;}private:int _year;int _month;int _day;
};int main()
{Date d1;Date d2(2024, 4, 2);// 注意：如果通过无参构造函数创建对象时，对象后面不用跟括号，否则就成了函数声明// 以下代码的函数：声明了d3函数，该函数无参，返回一个日期类型的对象Date d3(); //无法跟函数声明区分开return 0;
}

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

class Date
{
public:/*// 如果用户显式定义了构造函数，编译器将不再生成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类中构造函数屏蔽后，代码可以通过编译，因为编译器生成了一个无参的默认构造函数// 将Date类中构造函数放开，代码编译失败，因为一旦显式定义任何构造函数，编译器将不再生成// 无参构造函数，放开后报错Date d1;return 0;
}

在不实现构造函数的情况下，编译器会生成默认的构造函数。但是Date类型对象调用了编译器生成了默认构造函数，对成员变量_year，_month和_day初始化之后还是随机值，那么编译器自动生成的构造函数有什么用呢？
C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语言提供的数据类型，如：int/char...，自定义类型就是我们使用class/struct/union等自己定义的类型，看看下面的程序，就会发现编译器生成默认的构造函数会对自定类型成员_t调用的它的默认成员函数。

class Time
{
public:Time(){cout << "Time()" << endl;_hour = 0;_minute = 0;_second = 0;}
private:int _hour;int _minute;int _second;
};class Date
{
private:// 基本类型(内置类型)int _year;int _month;int _day;// 自定义类型Time _t;
};int main()
{Date d;return 0;
}

无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。
注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认构造函数。（就是不用传递参数的函数）

class Date
{
public:Date(){_year = 1900;_month = 1;_day = 1;}Date(int year = 1900, int month = 1, int day = 1){_year = year;_month = month;_day = day;}
private:int _year;int _month;int _day;
};
// 以下测试函数能通过编译吗？
void Test()
{Date d1;
}int main()
{Test();return 0;
}

上面的代码无法正常运行，因为全缺省构造函数和无参构造函数都不需要传递参数，这样子编译器无法判断要调用哪个构造函数，会发生歧义。我们一般使用保留全缺省构造函数，因为它既可以当做无参构造函数，也可以当做有参构造函数使用。

3. 析构函数

3.1 概念

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

注意：析构函数不是销毁对象，而是做清理资源的工作！

3.2 特性

析构函数是特殊的成员函数，其特征如下：

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

typedef int DataType;
class Stack
{
public:Stack(size_t capacity = 3){_array = (DataType*)malloc(sizeof(DataType) * capacity);if (NULL == _array){perror("malloc申请空间失败!!!");return;}_capacity = capacity;_size = 0;}void Push(DataType data){// CheckCapacity();_array[_size] = data;_size++;}// 其他方法...~Stack(){if (_array){cout << "~Stack()" << endl;free(_array);_array = NULL;_capacity = 0;_size = 0;}}
private:DataType* _array;int _capacity;int _size;
};void TestStack()
{Stack s;s.Push(1);s.Push(2);
}

我们可以再析构函数里面加一个打印，这样可以知道程序结束后编译器是否有自动调用析构函数。

关于编译器自动生成的析构函数，是否会完成一些事情呢？下面的程序我们会看到，编译器生成的默认析构函数，对自定类型成员调用它的析构函数。
注意：内置类型就是语言提供的数据类型，如：int/char...，自定义类型就是我们使用class/struct/union等自己定义的类型。

我在VS2022上运行这段代码，观察编译器自带的析构函数会做些什么

class Time
{
public:~Time(){cout << "~Time()" << endl;_hour = 0;_minute = 0;_second = 0;}
private:int _hour;int _minute;int _second;
};class Date
{
private:// 基本类型(内置类型)int _year = 1970;int _month = 1;int _day = 1;// 自定义类型Time _t;
};int main()
{Date d;return 0;
}

默认生成的析构函数，的确对自定义类型成员调用了它的析构函数。

我们进入监视窗口查看各个函数值的变化，当程序走到结束的时候，对象d中的年月日没有发生任何变化，自定义类型成员变量_t的小时、分钟和秒，发生了改变，变成析构函数中的赋值。

总结：

内置类型成员，销毁时不需要资源清理，最后系统直接将其内存回收即可；
而_t是Time类对象，所以在d销毁时，要将其内部包含的Time类的_t对象销毁，所以要调用Time类的析构函数。
所以一般类只含有不申请空间的内置类型成员，或者不仅含有不申请空间的内置类型成员和自定义类型，都不需要自己写析构函数。
只有那种类中包含需要申请空间的内置类型成员，才需要写析构函数，清理申请的空间。

注意：创建哪个类的对象则调用该类的析构函数，销毁那个类的对象则调用该类的析构函数

4. 拷贝构造函数

4.1 概念

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

4.2 特征

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

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

class Date
{
public:Date(int year = 1900, int month = 1, int day = 1){_year = year;_month = month;_day = day;}// Date(const Date& d)   // 正确写法Date(const Date d) //错误写法，编译报错{_year = d._year;_month = d._month;_day = d._day;}
private:int _year;int _month;int _day;
};int main()
{Date d1;Date d2(d1);return 0;
}

那为什么传类类型参数就会引发无穷递归？我们来看下面的代码，我们调用fun函数，传递的参数是A类的对象a，我们将A类的拷贝构造函数中加入打印“A(A& a)”，表明调用了拷贝构造函数。

class A
{
public:A(){}A(A& a){cout << "A(A& a)" << endl;}
};void fun(A _a)
{}int main()
{A a;fun(a);return 0;
}

运行结果如下，fun函数接受类类型对象时调用了拷贝构造。因为形参是实参的一份临时拷贝。内置类型的数据传参直接开辟一块空间进行值拷贝。自定义类型传参时，需要调用该类型的拷贝构造函数创建一个形参。

所以回到最开始的问题，为什么会引发无穷递归呢？因为d2是调用拷贝构造函数进行初始化，需要传递参数，参数是d1，而自定义类型的参数创建形参时，需要调用该类型的拷贝构造函数。
会发生初始化d2之前先要拷贝d1这个参数，此时形参调用拷贝构造函数也需要传参。参数是d1，会再次调用拷贝构造函数。这样就会造成无穷递归的情况。

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

class Time
{
public:Time(){_hour = 1;_minute = 1;_second = 1;}Time(const Time& t){_hour = t._hour;_minute = t._minute;_second = t._second;cout << "Time::Time(const Time&)" << endl;}
private:int _hour;int _minute;int _second;
};class Date
{
public:Date(int year = 1970, int month = 1, int day = 1){_year = year;_month = month;_day = day;}private:// 基本类型(内置类型)int _year = 1970;int _month = 1;int _day = 1;// 自定义类型Time _t;
};int main()
{Date d1;// 用已经存在的d1拷贝构造d2，此处会调用Date类的拷贝构造函数// 但Date类并没有显式定义拷贝构造函数，则编译器会给Date类生成一个默认的拷贝构造函数Date d2(d1);return 0;
}

运行结果如下，调用了自定义类型成员的拷贝构造函数。

观察调试时的监视窗口，会发现编译器自动生成的默认拷贝构造函数，对内置类型成员进行了值拷贝，对自定义类型成员调用了它的拷贝构造函数。

编译器生成的默认拷贝构造函数已经可以完成字节序的值拷贝了，还需要自己显式实现吗？当然像日期类这样的类是没必要的。那下面的类呢，运行一下下面的代码看看。

typedef int DataType;
class Stack
{
public:Stack(size_t capacity = 10){_array = (DataType*)malloc(capacity * sizeof(DataType));if (nullptr == _array){perror("malloc申请空间失败");return;}_size = 0;_capacity = capacity;}void Push(const DataType& data){// CheckCapacity();_array[_size] = data;_size++;}~Stack(){if (_array){free(_array);_array = nullptr;_capacity = 0;_size = 0;}}
private:DataType* _array;size_t _size;size_t _capacity;
};int main()
{Stack s1;s1.Push(1);s1.Push(2);s1.Push(3);s1.Push(4);Stack s2(s1);return 0;
}

运行结果如下，直接进行了报错，这是为什么呢？

因为默认生成的拷贝构造函数进行的是按字节拷贝，也就是值拷贝。然而Stack类里面的_array成员是一个整形指针，指向一块动态开辟的空间，默认拷贝构造函数会将s1里的_array成员存储的地址，按字节拷贝到s2的_array成员中，导致这两个指针指向同一块空间。
由于它们指向同一块空间的时候，当程序结束时，对这两个类对象进行销毁，会调用析构函数，会对同一块空间进行了两次释放操作，这就是报错的原因。

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

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

我们尝试运行下面这段代码：

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(2024, 4, 16);Test(d1);return 0;
}

运行结果如下，一开始初始化d1调用了构造函数，调用Test函数，传递自定义类型的参数，调用拷贝构造函数来拷贝出个形参，temp也进行拷贝，再次调用拷贝构造函数。