C++基础(3)——类与对象

 1.构造函数：

1.1 构造函数的引入：

 在关于数据结构这一部分的文章中，创建了一个新的数据结构后，通常需要编写一个初始化函数来对这个数据结构进行一次初始化。在C++的类中，如果存在函数，同样也需要对函数进行初始化，例如：

class Date
{
public:
 
	void Init(int year, int month, int date)
	{
		_year = year;
		_month = month;
		_date = date;
	}
 
	void print()
	{
		cout << _year << "-" << _month << "-" << _date << endl;
	}
	
 
private:
	int _year;
	int _month;
	int _date;
};
int main()
{
	Date d1;
	d1.Init(2023, 11, 15);
	d1.print();
	return 0;
}

        在许多情况下，由于初始化函数容易被人为遗忘，因为造成了很多的错误。即使人为避免了这种错误，但是在每次打印不同的日期时，都需要进行一次初始化，使得操作较为繁琐。为了解决上述问题，在C++中，引入了构造函数这一概念。

1.2 构造函数的定义及特性：

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

构造函数特性如下：

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

       在构造函数的特性中的第条提到，构造函数无返回值，在C语言中，无返回值的函数一般都会在函数名之前加上类型void" role="presentation" style="position: relative;">void$void$，但是在C++中，不需要加任何额外的类型。

       将文章开始给出代码中的初始化函数用构造函数进行替代，代码如下：

class Date
{
public:
 
	Date()
	{
		_year = 1;
		_month = 1;
		_date = 1;
	}
	Date(int year, int month, int date)
	{
		_year = year;
		_month = month;
		_date = date;
	}
	/*void Init(int year, int month, int date)
	{
		_year = year;
		_month = month;
		_date = date;
	}*/
 
	void print()
	{
		cout << _year << "-" << _month << "-" << _date << endl;
	}
	
 
private:
	int _year;
	int _month;
	int _date;
};

       特性4" role="presentation" style="position: relative;">4$4$中提到，构造函数可以构成重载。因此，在上述代码中给出了两个构造函数。在使用构造函数时，分为两种，即代码中所体现的有参数和无参数的两种构造函数。对于上述两种构造函数的使用方法如下：

int main()
{
	Date d1;
	d1.print();
	Date d2(2023, 11, 15);
	d2.print();
	return 0;
}

打印结果如下：

其中，是针对无参数的构造函数的调用，是针对有参数的构造函数的调用。

对于构造函数，在使用时也可以与缺省参数进行结合，例如：

class Date
{
public:
 
 
	Date(int year = 15, int month = 15, int date = 15)
	{
		_year = year;
		_month = month;
		_date = date;
	}
 
 
	void print()
	{
		cout << _year << "-" << _month << "-" << _date << endl;
	}
	
 
private:
	int _year;
	int _month;
	int _date;
};
int main()
{
 
	Date d3;
	d3.print();
    Date d4(2023, 11, 15);
	d4.print();
	return 0;
}

打印结果如下：

1.3 内置类型和自定义类型：

       在上面的代码中，构造函数都是人为进行构造的，但是，在不人为在类中创建构造函数的情况下，能否继续初始化类中的变量，需要分成两个情况，即：自定义类型和内置类型。

      对于内置类型，就是语言本身提供的数据类型，例如：,等，对于自定义类型，就是人为进行构建的类型，例如：,。在不人为创建构造函数的情况下，针对自定义类型，编译器会自动生成一个构造函数。而对于自定义类型则不作用。例如：
 

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

此时，再运行程序，中的四个变量为：

         此时，编译器会因为_的类型是自定义类型，去调用自定义类型的默认构造函数，由于，没有人 为构建，因此编译器会随机生成一个构造函数，最终将变量初始化为随机值。

在C++11中，针对内置雷系在没有构造函数的情况下不能被初始化的问题，进行了一定的优化，即：内置类型变量在声明时可以给缺省值，即：

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

此时，内置类型的变量可以通过监视窗口进行监视：

1.4 默认构造： 

       在上面的部分中，解释了构造函数的自动调用即默认生成对于不同类型的变量，有不同的效果，即针对自定义类型会进行自动调用此类型的默认构造函数。如果在自定义类型中已经存在了人为编写的构造函数，则调用该函数，否则编译器会自动生成。需要注意，存在人为定义的构造函数的情况下，编译器不会自动生成默认构造。

class Time
{
public:
	Time(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()
{
	Time d1;
	d1.Print();
	return 0;
}

       对于上述代码，在自定义类型中人为编写了一个构造函数，此时如果去运行程序，会出现下面的错误：

      在人为给出了构造函数的情况下，编译器不会自动生成构造函数，但是在对这个类进行实使用时，并没有按照规则传参进行调用，因此，编译器会显示没有合适的默认构造函数。

      造成上述问题的原因是因为默认构造这个概念，并不是只指在不人为编写构造函数的情况下，编译器自动给出的构造函数，还包括以下两个构造函数：不需要传参数就可以调用的构造函数以及全缺省的构造函数。因此，假设一个类中人为定义了多个构造函数，则编译器在调用时，会优先调用不需要传递参数的构造函数。如果不存在，则会报错。并且，针对上述三种默认构造函数，不可以同时存在。

2. 析构函数：

2.1 析构函数的概念及特性：

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

      析构函数特性如下：

1. 析构函数名是在类名前加上字符 ~。
2. 无参数无返回值类型。
3. 一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。注意：析构
函数不能重载
4. 对象生命周期结束时，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;
	}
	~Stack()
	{
			_array = nullptr;
			_capacity = 0;
			_size = 0;
	}
private:
	DataType* _array;
	int _capacity;
	int _size;
};
 
int main()
{
	Stack s;
	return 0;
}

上述代码中，析构函数即为~，运行代码时，可以通过监视窗口来观察析构函数的作用：

当代码运行完构造函数后，即：

此时类中各对象的状态如下图所示：

 

当运行析构函数后，即：

此时类中各对象如下图所示：

通过上述一系列动作过程发现，析构函数自动将类中的各对象资源的清理工作。 

析构函数针对于内置类型和自定义类型的处理方法于构造函数一样，本部分不再进行过多说明。