C++类和对象（中）

类的默认成员函数

默认成员函数就是⽤⼾没有显式实现，编译器会⾃动⽣成的成员函数称为默认成员函数。⼀个类，我们不写的情况下编译器会默认⽣成以下6个默认成员函数这里只讨论前四个，我们从以下两个方面来讨论
第⼀：我们不写时，编译器默认⽣成的函数⾏为是什么，是否满⾜我们的需求。
• 第⼆：编译器默认⽣成的函数不满⾜我们的需求，我们需要⾃⼰实现，那么如何⾃⼰实现？

一· 构造函数

构造函数是特殊的成员函数，它的函数名与类名相同，值得注意的是它不需要返回值，而他的主要用途是用来替代Init()函数的
构造函数的特点

1. 函数名与类名相同。
2. ⽆返回值。(返回值啥都不需要给，也不需要写void，不要纠结，C++规定如此)
3. 对象实例化时系统会⾃动调⽤对应的构造函数。
4. 构造函数可以重载。
5. 如果类中没有显式定义构造函数，则C++编译器会⾃动⽣成⼀个⽆参的默认构造函数，⼀旦用户显式定义编译器将不再⽣成。
6. ⽆参构造函数、全缺省构造函数、我们不写构造时编译器默认⽣成的构造函数，都叫做默认构造函数。但是这三个函数有且只有⼀个存在，不能同时存在。⽆参构造函数和全缺省构造函数虽然构成函数重载，但是调⽤时会存在歧义。要注意很多同学会认为默认构造函数是编译器默认⽣成那个叫默认构造，实际上⽆参构造函数、全缺省构造函数也是默认构造，总结⼀下就是不传实参就可以调
   ⽤的构造就叫默认构造。

class DATA
{
public:
	DATA()
	{
		_year = 2024;
		_mounth = 8;
		_day = 30;
	}
	
private:
	int _year;
	int _mounth;
	int _day;
};

int main()
{
	DATA T;//这里我只创建了T，并没有调用DATA函数，自动调用
	return 0;
}

下面见代码调试

这里我们可以看到自定义的对象T已经初始化好了，不用我们手动去调用构造函数（这里如果我们不写DATA构造函数，编译器默认⽣成的构造，对内置类型成员变量的初始化没有要求，也就是说是是否初始化是不确定的，看编译器，VS没有要求。对于⾃定义类型成员变量，要求调⽤这个成员变量的默认构造函数初始化。如果这个成员变量，没有默认构造函数，那么就会报错）

这里我们只写了一小部分栈的代码做样例

class Stack
{
public:
	Stack(int n = 4)
	{
		_Arr = (int *)malloc(sizeof(int) * n);
		if (_Arr == nullptr)
		{
			perror("fail malloc");
			exit(1);
		}
		_size = 0;
		_capacity = n;
	}

	void push(int value)
	{
		_Arr[_size] = value;
		_size++;
	}
	
private:
	int * _Arr;
	int _size;
	int _capacity;
};

int main()
{
	Stack T;
	T.push(2);
	return 0;
}

不用我们自己写构造函数的情况

另外我们还要强调一点就是当我们定义类的对象的成员函数也是自定义对象时，不需要我们再自己去写构造函数了，他会在自己定义处调用自己的构造函数，例子如下

class Stack
{
public:
	Stack(int n = 4)
	{
		_Arr = (int *)malloc(sizeof(int) * n);
		if (_Arr == nullptr)
		{
			perror("fail malloc");
			exit(1);
		}
		_size = 0;
		_capacity = n;
	}
private:
	int * _Arr;
	int _size;
	int _capacity;
};

class QueST//这里我们不用自己构造函数
{
private:
	Stack Q1;
	Stack Q2;
};

int main()
{
	QueST T;
	return 0;
}

下面是他的调试代码

这里我们可以看到Q1和Q2都已经初始化了

二· 析构函数

析构函数与构造函数功能相反，析构函数不是完成对对象本⾝的销毁，⽐如局部对象是存在栈帧的，函数结束栈帧销毁，他就释放了，不需要我们管，C++规定对象在销毁时会⾃动调⽤析构函数，完成对象中资源的清理释放⼯作。
析构函数的特点：

1. 析构函数名是在类名前加上字符~。
2. ⽆参数⽆返回值。(这⾥跟构造类似，也不需要加void)
3. ⼀个类只能有⼀个析构函数。若未显式定义，系统会⾃动⽣成默认的析构函数。
4. 对象⽣命周期结束时，系统会⾃动调⽤析构函数。
5. 跟构造函数类似，我们不写编译器⾃动⽣成的析构函数对内置类型成员不做处理，⾃定类型成员会调⽤他的析构函数。
6. 还需要注意的是我们显⽰写析构函数，对于⾃定义类型成员也会调⽤他的析构，也就是说⾃定义类型成员⽆论什么情况都会⾃动调⽤析构函数。
7. 如果类中没有申请资源时，析构函数可以不写，直接使⽤编译器⽣成的默认析构函数，如Date；如果默认⽣成的析构就可以⽤，也就不需要显⽰写析构，如MyQueue；但是有资源申请时，⼀定要
   ⾃⼰写析构，否则会造成资源泄漏，如Stack。
8. ⼀个局部域的多个对象，C++规定后定义的先析构。

总的来说需要我们自己写析构函数的情况就只有申请资源的情况

class Stack
{
public:
	Stack(int n = 4)
	{
		_Arr = (int *)malloc(sizeof(int) * n);
		if (_Arr == nullptr)
		{
			perror("fail malloc");
			exit(1);
		}
		_size = 0;
		_capacity = n;
	}
	~Stack()
	{
		free(_Arr);
		_Arr = nullptr;
	}
private:
	int * _Arr;
	int _size;
	int _capacity;
};

class QueST
{
private:
	Stack Q1;
	Stack Q2;
};

int main()
{
	QueST T;
	return 0;
}

下面是调试段

可以看见_Arr已经释放

拷贝构造函数

如果⼀个构造函数的第⼀个参数是⾃⾝类类型的引⽤，且任何额外的参数都有默认值，则此构造函数也叫做拷⻉构造函数，也就是说拷⻉构造是⼀个特殊的构造函数。
注意：在说拷贝构造之前要先声名一点，C++规定调用传值返回时要先调用拷贝构造。
拷贝构造函数的特点：

1. 拷⻉构造函数是构造函数的⼀个重载。
2. 拷⻉构造函数的参数只有⼀个且必须是类类型对象的引⽤，使⽤传值⽅式编译器直接报错，因为语法逻辑上会引发⽆穷递归调⽤。
   
3. 如果我们没有自己写拷贝构造函数，编译器会自动帮我们生成拷贝构造函数，对于内置类型，编译器会完成浅拷贝（一个字节一个字节的拷贝），而对于自定义类型会调用我们自己定义的拷贝构造函数。
4. 对于日期这样的类他的内部没有什么资源可以用编译器直接生成的拷贝构造函数，但对于栈这样的类，他的内部资源比较复杂（在堆上开了空间），就需要我们自己定义拷贝构造函数。

class DATA
{
public:
	DATA(int year,int mounth,int day)
	{
		_year = year;
		_mounth = mounth;
		_day = day;
	}
	int operator+(int value)
	{

	}
private:
	int _year;
	int _mounth;
	int _day;
};

int main()
{
	DATA T(2024,8,29);
	DATA L(T);//拷贝构造
	return 0;
}

下面是他的调试代码

可以看到T的值已经拷贝到了L里了。
我们再来观察栈的部分代码

class Stack
{
public:
	Stack(int n = 4)
	{
		_Arr = (int *)malloc(sizeof(int) * n);
		if (_Arr == nullptr)
		{
			perror("fail malloc");
			exit(1);
		}
		_size = 0;
		_capacity = n;
	}
	~Stack()
	{
		free(_Arr);
		_Arr = nullptr;
	}
private:
	int * _Arr;
	int _size;
	int _capacity;
};
int main()
{
	Stack T;
	Stack L(T);
	return 0;
}

下面是调试代码

可以看到T的_Arr和L_Arr的地址相同，那就意味着等会我们在析构函数时，同一块空间我们会析构两次也就是free两次，程序就会崩溃。
最终的调试代码也和我们预想的一样

所以对于有资源申请的函数我们得自己写拷贝构造函数。

class Stack
{
public:
	Stack(int n = 4)
	{
		_Arr = (int *)malloc(sizeof(int) * n);
		if (_Arr == nullptr)
		{
			perror("fail malloc");
			exit(1);
		}
		_size = 0;
		_capacity = n;
	}
	Stack(const Stack & ST)
	{
		_Arr = (int*)malloc(sizeof(int) * ST._capacity);//开辟和T一样大的空间
		memcpy(_Arr,ST._Arr,sizeof(int)*ST._size);
		_size = ST._size;
		_capacity = ST._capacity;
	}
	~Stack()
	{
		free(_Arr);
		_Arr = nullptr;
	}
private:
	int * _Arr;
	int _size;
	int _capacity;
};
int main()
{
	Stack T;
	Stack L(T);
	return 0;
}

这里我们就可以看到对象T和L的_Arr就不是指向同一个地址了，也就不会报错了。
还有一点要注意：当我们的值是传引用返回时，不能将函数里的局部变量返回回去，当出了函数的作用域时，函数里的局部变量就会销毁，而传引用返回是返回了它的别名（这里可以把它看成是地址），再使用就有点像野指针了。