【C++】 三种默认成员函数

前言

构造函数

1.特性

以往我们在用C语言写数据结构时，都会调用初始化函数，类的构造函数是同样效果，也是用来初始化成员变量的

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

我们举个栈的例子

2.栈的例子

//构造函数：名称
class Stack
{
public:
	//构造函数可以重载
	Stack()
	{
		cout << "无参构造函数调用" << endl;
		_a = nullptr;
		_capacity = _size = 0;
	}

	Stack(int n=4)
	{
		cout << "有参构造函数调用" << endl;
		_a = (int*)malloc(sizeof(int)*n);
		if (_a == nullptr)
		{
			perror("malloc fail");
			exit(-1);
		}
		_capacity = n;
		_size = 0;
	}
	
private:
	int*_a;
	int _capacity;
	int _size;
};

int main()
{
	Stack st1;
	cout << "无参构造函数已调用" << endl;
	//不能Stack st1()，因为编译器分不清到底是要实例化对象还是写一个函数
	
	Stack st2(4);//有参构造函数
	cout << "有参构造函数已调用" << endl;
	
	return 0;
}

无参构造函数时

有参构造函数

注意：如果写了构造函数，那么系统就不会调用默认的构造函数，初始化时要传相应参数

3.缺省构造函数

在构造函数的书写时，我们还可以应用缺省参数，让构造函数的复用性更强
比如，我们创建一个Date类，并写一个打印年月日的函数
代码和效果如下：

class Date
{
public:
	Date()
	{
		cout << "无参构造" << endl;
		_year = 1;
		_month = 1;
		_day = 1;
	}

	Date(int year, int month, int day)
	{
		cout << "有参构造" << endl;
		_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(2023,2,3);//有参初始化
	d2.Print();

	return 0;
}

此时，我们可以利用缺省参数，将无参和有参构造的效果结合在一起

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

int main()
{
	Date d1;
	d1.Print();

	Date d2(2023,2,3);
	d2.Print();

	return 0;
}

4.小细节

一. 默认构造函数

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

二. 默认构造函数的调用规则

我们知道构造函数是可以系统自动调用的，当我们没有编写构造函数时，实例化对象系统就会调用默认构造函数。但一旦我们自己写了构造函数，那么编译器则不再调用默认构造函数，我们只能手动传参调用我们自己写的构造函数

三. 构造函数初始化数据

如果我们没有写构造函数，使用系统默认的构造函数，那成员变量的赋值是什么呢？0？

为什么会是随机值呢？

首先，C++中，将类内的数据分为两种
一种是内置类型，int/char/double…/任何类型指针。
一种是自定义类型，struct/class定义的类

默认构造函数的初始化原则是：对内置类型不做处理，对自定义类型调用其构造函数

我们举个队列的例子

//链表节点
class Node
{
public:
	Node()
	{
		cout << "Node构造函数" << endl;
	}

	~Node()
	{
		cout << "Node析构函数" << endl;
	}

	void Print()
	{
		cout << "val=" << val << endl;
		cout << "next=" << next << endl;
	}

private:
	int val;
	Node*next;
};

//队列
class MyQueue
{
public:

	void Print()
	{
		head.Print();
		tail.Print();
	}

private:
	//头结点和尾结点
	Node head;
	Node tail;
};


int main()
{
	MyQueue queue;
	queue.Print();

	return 0;
}

结果如下

Node自定义类型完成了初始化

析构函数

1.特性

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

析构函数是特殊的成员函数，其特征如下：
1.析构函数名是在类名前加上字符 ~.
2.无参数，无返回值类型
3.一个类只能有一个析构函数，若未显示定义，系统会自动生成默认的析构函数。析构函数不能重载
4.对象生命周期结束时，C++编译系统自动调用析构函数

class Stack
{
public:
	//构造函数可以重载
	Stack(int n=4)
	{
		cout << "有参构造函数调用" << endl;
		_a = (int*)malloc(sizeof(int)*n);
		if (_a == nullptr)
		{
			perror("malloc fail");
			exit(-1);
		}
		_capacity = n;
		_size = 0;
	}

	~Stack()
	{
	    cout << "析构函数的调用" << endl;
		free(_a);
		_a = nullptr;
		_capacity = _size = 0;
	}
	
private:
	int*_a;
	int _capacity;
	int _size;
};

int main()
{
	Stack st1(4);
	cout << "有参构造函数已调用" << endl;
	
	cout << "main函数结尾" << endl;
	return 0;
}

析构函数的调用是在实例化对象的生命周期结束时，即栈销毁时，return时调用

2.小细节

析构函数和构造函数原则基本相同

默认调用规则和只对自定义类型初始化与构造函数规则相同

拷贝构造函数

1.特性

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

特性

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

一.无穷递归调用

我们知道，函数的传值传参实际是在函数的栈帧上重新拷贝一份数据，而如果函数形参是类的话，也同样是拷贝数据，但因为是类，所以拷贝需要调用类内相应的拷贝构造函数。

我们在main函数的Func1调用打个断点，然后F11进入函数，发现其直接跳转到了Date的拷贝构造函数中

那么，我们的拷贝构造函数如果不用引用，而是直接用传值传参，则会发生无穷递归调用

为什么呢？

因为在实例化d2时，我们使用拷贝构造，但是拷贝构造函数中，d1是值传递，那我们则需要再调用拷贝构造函数，但是因为是值传递，则还需要拷贝构造函数，一直传值，一直需要拷贝。最终导致无法完成

二.解决方法 —— 引用

这时候，如果我们是利用引用，则不需要进行拷贝，就不会进入递归，就可以直接完成传递

同样在Func1打断点，按F11，就直接跳到Func1函数，没有进入类的拷贝构造函数

2.浅拷贝和深拷贝

编译器默认的拷贝构造函数时浅拷贝 —— 一个字节一个字节的，完全相同的拷贝

那么在拷贝指针，或者自定义类型时浅拷贝就会出问题
像Date那样，都是内置类型的类，并不会有所影响，但是类似Stack中的指针
如果完全拷贝，会使两个指针指向同一块空间
在析构时，一块空间会被析构两次，这显然是非法的，所以
内置类型，编译器可以直接拷贝
自定义类型的拷贝，需要调用自定义的拷贝构造函数

所以，如果一个类的析构函数需要释放开辟在堆的空间时，那么我们需要手写深拷贝，避免相同空间被重复释放

我们举栈的例子

    //深拷贝
	Stack(const Stack&st)
	{
	    //新开辟一块空间
		_a = (int*)malloc(sizeof(Stack)*st._capacity);
		if (_a == nullptr)
		{
			perror("malloc fail");
			exit(-1);
		}
        
        //拷贝数据
		memcpy(_a, st._a, sizeof(Stack)*st._size);

		_size = st._size;
		_capacity = st._capacity;
	}

3.小细节

拷贝构造函数中，参数是类类型对象的引用，一般我们还会在前方加上const，因为对引用的修改就是对本体的修改，为了数据安全，我们可以加上const，进行权限的缩小，保证传入的数据不被修改
同时，如果拷贝构造调用时，是拷贝一个加了const的对象，或者该对象有常量属性，那么我们在拷贝构造函数定义时加上const也适配，增强了代码的复用性

结束语

本章用于记笔记，如果有不对或者不足的地方，欢迎大佬们指正，补充。感谢大家的阅读，如果感觉博主写的还可以，麻烦点个赞支持一下，阿里嘎多。