C++中类的默认成员函数（构造函数，析构函数和拷贝函数）

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

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

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

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

class Date{};

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

每次创建对象时都调用Init很麻烦，有没有办法在创建对象时就将信息设置进去呢？

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

2.2 特性

构造函数的主要任务并不是开空间创建对象，而是初始化对象。其特征如下：

1. 函数名与类名相同。

2. 无返回值。

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

4. 构造函数可以重载。

以上面的日期类为例，先写一个构造函数方便理解

class Date
{
public:
	Date()
	{
		//代码
	}
	
private:
	int _year;
	int _month;
	int _day;
};

首先其函数名为Date，和类名Date一致；其次在Date函数名的左侧没有声明void,int等返回值类型，也就是没有返回值。

接下来我们就可以在构造函数内部实现代码，初始化我们的类了。
比如我想让我的默认时间为2022年12月19日。

Data()
{
    _year = 2022;
    _month = 12;
    _day = 19;
}

2.3 重载函数

构造函数可以是无参或带参的，以重载函数的形式

class Date
{
public:
	Date(){}；

    Date(int year, int month, int day)
    {
        _year = year;
        _month = month;
        _day = day
    }

    void TestDate()
    {
        Date d1;              //调用无参构造
        Date d2(2022, 12, 19);//调用有参构造
    }
	
private:
	int _year;
	int _month;
	int _day;
};

2.4 缺省函数

利用前面学的缺省函数知识，我们也可以把构造函数写成缺省函数的形式来达到某些目的。

比如一般情况下创建的Date对象默认日期为2022年12月19日，而特殊情况下需要我们自己写日期，就可以按下面这样写代码：

Date(int year = 2022, int month = 12, int day = 19)
    {
        _year = year;
        _month = month;
        _day = day
    }

当然也可以写成半缺省的形式。

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

关于编译器生成的默认成员函数，有人会有疑惑：不实现构造函数的情况下，编译器会生成默认的构造函数。但是看起来默认构造函数又没什么用？d对象调用了编译器生成的默认构造函数，但是d对象_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 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;
}

3.析构函数

现在我们知道了一个对象是如何初始化的，那么一个对象是如何被销毁的呢？ 这就需要通过析构函数了。

C++的析构函数是一个特殊的成员函数，用于在对象被销毁时进行内部的清理工作。它的名称是在类的名称前面加上一个波浪符号~。

当一个对象的生命周期结束时，即对象不再被使用时，析构函数会自动调用。通过析构函数，可以释放对象使用的资源，如动态分配的内存、打开的文件等。析构函数的工作是清理对象所拥有的资源，以防止内存泄漏或资源泄漏。

析构函数的定义在类的声明中。它不需要任何参数，也没有返回值。通常，析构函数的定义放在类的实现文件中。 比如以下类：

class Example {
public:
	//构造函数
	Example()
	{
		a = (int*)malloc(sizeof(int) * 4);
		size = 4;
	}
    // 析构函数
    ~Example() {
        free(a);
        a = nullptr;
        size = 0;
    }
    
private:
    int* a;
    int size;
};

类中有一个成员a，指向了一块空间，在创建Example类的对象时，构造函数被调用，自动初始化了一块空间给a。如果这块空间不处理，那么当程序结束，就会造成内存泄漏。所以我们要在析构函数~Example()中释放a指向的空间。而析构函数的优点就是无需我们自己调用，当对象离开生命周期，这个函数会被自动调用。

与构造函数不同的是：一个函数只允许存在一个析构函数，不允许重载。 而与构造函数相同的是：当我们不写析构函数，编译器会默认生成一个析构函数，这也是六大默认成员函数的特性。

那么默认的析构函数会做什么事情呢？

对于默认的析构函数：如果成员变量中存在其它类的对象，调用其它类的析构函数。 这个过程是在释放其它类的对象调用的资源，而非这个对象。对象是创建在栈帧中的，会随着程序结束一起销毁，但是不能销毁的是动态内存之类的空间。所以我们如果开辟了动态内存，需要自己编写析构函数，将其free掉。如果没有，那么直接用编译器默认生成的析构函数即可。

4.拷贝构造

在创建对象时，可否创建一个与已存在对象一某一样的新对象呢？
其实我们在很多时候已经在不知不觉的拷贝对象了，比如函数传参。

我先为大家展示两段自定义类型的函数传参：

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

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

void func(Date d)
{
	//函数体
}

int main()
{
	Date d1;
	func(d1);
	return 0;
}

以上代码中，我们定义了一个日期类Date，内部有三个成员_year，_month，_day。这三个都是内置类型的成员。
随后我们实例化了一个对象d1，并调用func函数，将d1作为参数传递了进去。形参是实参的一份临时拷贝，那么此时形参d就是实参d1的一份拷贝，那么d1到d的过程就会发生一次拷贝。

下面给出一个例子：

class Stack
{
public:
	Stack(size_t capacity = 10)
	{
		_array = (int*)malloc(capacity * sizeof(int));
		if (nullptr == _array)
		{
			perror("malloc fail!");
			return;
		}

		_size = 0;
		_capacity = capacity;
	}
	
	~Stack()
	{
		if (_array)
		{
			free(_array);
			_array = nullptr;
			_capacity = 0;
			_size = 0;
		}
	}
	
private:
	int* _array;
	size_t _size;
	size_t _capacity;
};

void func(Date s)
{
	//函数体
}

int main()
{
	Stack s1;
	func(s1);
	return 0;
}

在这个代码中，我们有一个栈类stack，在实例化时，会调用构造函数，malloc一段动态内存。此时我们调用函数func，将对象s1作为参数传入函数中，此时s就是s1的一份拷贝。
但是，如果按照直接拷贝，那么形参s的成员_array会与实例s1的成员_array值一样，此时形参和实参就指向了同一块空间了。

我们希望形参改变不要影响实参，但是此时两个对象指向同一块空间，就会互相影响了。甚至由于我们存在一个析构函数~Stack，析构函数会free掉_array指向的空间，而s和s1离开生命周期时，都会调用一次析构函数，此时_array指向的空间会被释放两次，这是不允许的。

可见，如果我们让编译器直接进行拷贝，是有可能会发生错误的。所以类中设立了一个拷贝函数，每当对象需要进行拷贝操作时，都会调用这个拷贝函数。

也就是说，我们每次把对象作为函数形参传递时，都会调用拷贝函数来进行拷贝。

拷贝函数是构造函数的一种重载，所以称为拷贝构造函数，简称拷贝构造。既然拷贝构造是构造函数的重载，那么其函数名也就是类名，与构造函数一致。结构如下：

ClassName(const ClassName& obj)
{
    // 拷贝构造函数的实现逻辑
}

拷贝构造有要求：必须只有一个参数，且参数类型必须是ClassName&，也就是对这个类的引用。为什么呢？

还记得刚刚的话吗：我们每次把对象作为函数形参传递时，都会调用拷贝函数来进行拷贝。

如果我们此处的参数类型是ClassName，那么就会发生无限递归。

比如：我们调用了func函数，需要传入一个类的拷贝，此时调用这个类的拷贝构造，由于拷贝构造需要传入类的拷贝，于是又要调用第二个拷贝构造，而第二个拷贝构造又要调用这个类的拷贝，此时调用第三个拷贝构造…
以此类推，永远递归下去。程序必然会崩溃。

所以我们的拷贝构造必须传递引用来调用，防止无限递归。而一般而言，传入的被拷贝对象，我们是不希望其被修改的，所以还会加一个const修饰。最后我们的第一个参数就写为了const ClassName&。

要如何调用拷贝构造？
首先就是函数传参，表达式中等的隐式调用，会在底层偷偷调用拷贝构造函数。
另一种就是我们主动调用：
由于是构造函数的重构，所以可以在创建对象时用该构造函数的语法：

Stack s1;
Stack s2(s1);

即用一个小括号传参，把被拷贝的对象传入。

另一种则是在创建对象时用赋值语句：

Stack s1;
Stack s2 = s1;

拷贝构造是六大默认函数之一，所以如果没有显式地定义拷贝构造函数，C++编译器会默认生成一个默认的拷贝构造。默认的拷贝构造对于内置类型，会直接拷贝，对于自定义类型，则会调用相应的拷贝构造。

也就是说，默认的拷贝构造是无法解决我们刚刚两个指针指向同一块空间的问题的，所以我们要自己写一个拷贝构造函数，才可以让被拷贝出来的对象与原对象独立。

Stack(const Stack& other)
{
    _array = (int*)malloc(other._capacity * sizeof(int));
    if (nullptr == _array)
    {
        perror("malloc fail!");
        return;
    }
    
    memcpy(_array, other._array, other._size * sizeof(int));
    
    _size = other._size;
    _capacity = other._capacity;
}

上述拷贝构造函数将创建一个新的堆栈对象，其容量与参数中的堆栈对象容量相同。然后，它将使用memcpy函数数将参数中的堆栈对象数组的内容复制到新的数组中。最后，它将设置新对象的大小和容量与参数对象相同。

这样拷贝出来的对象与原对象就独立了。