C++ -- 类和对象（中1）

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

如果有这样一个类

class AT
{
	// ......
};

这显然是个空类，但空类中真的什么都没有吗？
其实在空类中也存在编译器自动生成的六个函数，分别是：

1. 构造函数
2. 析构函数
3. 拷贝构造函数
4. 赋值操作符重载
5. 取地址操作符重载
6. const修饰的取地址操作符重载

默认成员函数——用户没有显性实现，编译器会自动生成的函数

2. 构造函数

2.1 概念

struct Stack
{
	int* _a;
	int _top;
	int _capacity;
};

void StackInit(Stack stk)// 初始化
{
	// ......
}

void StackPush(Stack stk)// 添加元素
{
	// ......
}

来看这样一段代码，这是C语言中实现栈的方法，我曾遇到这样的问题。代码不报错但结果就是和预想的不一样，花了很长时间发现是StackInit函数忘写了，应该也有很多人遇到过同样的问题。
为了解决这个问题，C++在类中添加了构造函数这个东西。当用户没有显性写出时，编译器会自动生成。这是个特殊的函数，整个生命周期内只会调用一次。

2.2 特征

构造函数的作用不是创建对象而是初始化对象。

1. 函数名与类名相同
2. 无返回值
3. 对象实例化时编译器自动调用
4. 构造函数可以重载
5. 如果类中没有显示定义的构造函数，编译器会生成一个无参的默认构造函数
6. 无参的构造函数和全缺省的构造函数都称为默认构造函数（无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认构造函数。）
7. 内置类型不会调用其默认构造函数，自定义类型会调用
   来看这段代码理解这句话

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;
}

这段代码运行时会输出"Time()"，代表调用了Time的构造函数

可以看到内置类型为随机值，自定义类型调用了它的构造函数

我们在声明成员变量时可以给其一个缺省值

class Date
{
public:

private:
	// 给缺省值
	int _year = 1;
	int _month = 1;
	int _day = 1;
};

当缺省值存在时，构造函数会优先按照缺省值来。如果构造函数里有全缺省，则按照全缺省来

class Time
{
public:
private:
	int _hour = 1;
	int _minute;
	int _second;
};

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

	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	// 给缺省值
	int _year = 1;
	int _month = 1;
	int _day = 1;

	Time _t;
};

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

	return 0;
}

这段代码的输出值为”3-3-3“
同时，缺省值的优先级不高于传参

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

	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	// 给缺省值
	int _year = 1;
	int _month = 1;
	int _day = 1;
};

int main()
{
	Time d(2025, 4, 9);
	d.Print();

	return 0;
}

结果为”2025-4-9“
总结：不传参就可以调用的函数就是构造函数

3. 析构函数

3.1概念

析构函数的功能与构造函数的功能相反。对象在生命域结束时会自动调用析构函数，完成对象中资源的释放。

3.2特征

1. 析构函数的函数名和类名相同，但需要在前面加上 ~
2. 无参数无返回值
3. 不能重载，一个类只有一个析构函数，若未显现定义，系统会自动生成析构函数
4. 对象生命周期结束后C++编译器自动调用析构函数
5. 如果类中没有申请资源时，析构函数可以不写，直接使用编译器生成的默认析构函数；有资源申请时，一定要写，否则会造成资源泄漏。
6. 与构造函数相反的是，析构函数对内置类型不做处理，对自定义类型做处理

class Time
{
public:
	~Time()
	{
		cout << "~Time()" << endl;
	}
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;
}

总结：申请了空间就需要显现析构函数。

4.拷贝构造函数

4.1 概念

只有单个参数，且必须是对本类类型对象的引用，在用已存在的类类型对象创建新对象时由编译器自动调用。

4.2 特征

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

我们先来看一段代码体会拷贝构造函数

class Date
{
public:
	Date(int year,int month,int day)//构造函数
	{
		_year = year;
		_month = month;
		_day = day;
	}

	Date(const Date& d)//拷贝构造函数
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}

	void Print()
	{
		cout << _year << " " << _month << " " << _day << endl;
	}

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

int main()
{
	Date d1(2025, 4, 23);
	d1.Print();

	Date d2(d1);
	d2.Print();

	return 0;
}

接下来我会解释为什么用传值传参会引发无穷递归，来看下面这段代码

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

	Date(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}

	void Print()
	{
		cout << _year << " " << _month << " " << _day << endl;
	}

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

void func(Date d)
{
	d.Print();
}

int main()
{
	Date d1(2025, 4, 23);
	func(d1);

	return 0;
}

这里我将d1作为参数传给func函数，让func函数去调用Print。调用func得先传参，自定义类型传值传参要调用拷贝构造函数完成。d相当于d1的拷贝，在这个过程中又重复了自定义类型调用拷贝构造函数。于是后面就开始循环这个过程了。
再用上面的另一段代码来演示这个过程来方便理解：

可以把**“自定义类型传值调用需要调用拷贝构造函数”**这句话当成规则，验证的方法是f11上面这段代码，程序最开始不会进入func而是进入拷贝构造函数。
如果想避免这种情况发生，最好的办法就是传地址。C++中喜欢用的是引用。

class Date
{
	// ......
};

void func(const Date& d)//这里改为引用
{
	d.Print();
}

int main()
{
	Date d1(2025, 4, 23);
	func(d1);

	return 0;
}

我们再f11上面这段代码就能发现直接进入func函数而不会进入拷贝构造函数。
拷贝构造函数也可以这么写，二者是等价的

	Date d2(d1);
	Date d3 = d1;

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

总结一下：

1. 如果没有资源管理，一般不需要写拷贝构造函数，默认生成的就行。
2. 如果都是自定义类型，内置类型成员没有指向资源，也类似默认生成的拷贝构造就行。
3. 一般情况下不需要写析构函数时，也一般不需要写拷贝构造。
4. 如果内部有指针或一些值指向资源，需要显示写析构释放，通常就需要显示写拷贝构造完成深拷贝。