C++类和对象(中)

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

class Time{};

我们给一个空类，里面声明都没有吗？并不是的，并不是的，任何一个类在我们不写的情
况下，都会自动生成下面6个默认成员函数。

2. 构造函数

2.1构造函数的概念

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

2.2构造函数的特性

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

class Date
{
public:
//类名相同，没有返回值，重载
	Date()
	{
		 _year = 0;
		 _month = 1;
		 _day = 1;
	}
	void Print()
	{
		cout << _year << "/" <<_month << "/"<< _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d;	
	d.Print();
	return 0;
}

这样在对象创建出来就初始化，不用忘了写初始化函数。但是这样也不能满足我们的需求，我不想初始化成0，1，1.那接下来就可以使用重载。初始化成我想要的日期。

传参数调用有参构造，不传参数调用无参构造

2.3需要注意的细节

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

2.3.2

class A
{
public:
	A()
	{
		 _a1 = 0;
		 _a2 = 1;
		cout << "A()" << endl;
	}
private:
	int _a1;
	int _a2;
};
	void Print()
	{
		cout << _year << "/" <<_month << "/"<< _day << endl;
	}
private:
	//我们不写构造函数，编译器默认生成构造函数
	//1.内置类型不会初始化 例如：int\char\int *
	//2.自定义类型会调用它的无参构造函数 class\struct
	int _year;
	int _month;
	int _day;

	A _aa;
};

编译器对自定义类型调用他的无参构造函数来初始化，对内置类型不会初始化。在后来的C++11中打了补丁。

我们不写构造函数，就会使用这个补丁给的值。
2.3.4无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认成员函数。

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

这里编译器就不知道调用谁了，所以建议使用一个全缺省的构造函数

3. 析构函数

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

3.1析构函数的特性

析构函数是特殊的成员函数。
其特征如下：

1. 析构函数名是在类名前加上字符 ~。
2. 无参数无返回值。
3. 一个类有且只有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。
4. 对象生命周期结束时，C++编译系统系统自动调用析构函数。
   
   这里自动调用了析构函数，但是Date没有什么资源需要清理，接下来我们来看看栈

class Stack
{
public:
	Stack(int capacity = 4)
{
	_a = (int*)malloc(sizeof(int)*capacity);
	if (_a == nullptr)
	{
	  cout << "malloc fail" << endl;
	  exit(-1);
	}
	_top = 0;
	_capacity = capacity;
}
	
~Stack()
{
	// 像Stack这样的类，对象中的资源需要清理工作，就用析构函数
	free(_a);
	_a = nullptr;
	_top = _capacity = 0;
}	
private:
	int* _a;
	int _top;
	int _capacity;
};
	
int main()
{
   Stack st;
   return 0;
}

析构函数跟上面的构造函数一样，内置成员不处理，自定义类型调用它的默认析构函数清理资源。

// 两个栈实现队列
class MyQueue
{
private:
	Stack _pushST;
	Stack _popST;
};

int main()
{
	
	MyQueue mq;
	return 0;
}

这里编译器自动生成析构函数完成清理，把开辟的空间还给操作系统。

4.拷贝构造函数

那在创建对象时，可否创建一个与一个对象一某一样的新对象呢？
构造函数：只有单个形参，该形参是对本类类型对象的引用(一般常用const修饰)，在用已存在的类类型对象。创建新对象时由编译器自动调用。

4.1拷贝构造函数的特性

1. 拷贝构造函数是构造函数的一个重载形式。
2. 拷贝构造函数的参数只有一个且必须使用引用传参，使用传值方式会引发无穷递归调用。

class Date
{
public:
	Date(int year = 2021, int month = 10, int day = 24)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	Date(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1;
	Date d2(d1);
	return 0;
}

不用引用就会造成无限的递归下去。

4.1拷贝构造函数需要注意的

若未显示定义，系统生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝我们叫做浅拷贝，或者值拷贝。自定义类型会调用它的拷贝构造完成拷贝。

那么编译器生成的默认拷贝构造函数已经可以完成字节序的值拷贝了，我们还需要自己实现吗？当然像日期类这样的类是没必要的，但是有的类是需要自己写的。

class Stack
{
public:
	Stack(int capacity = 4)
	{
		_a = (int*)malloc(sizeof(int)*capacity);
		if (_a == nullptr)
		{
			cout << "malloc fail" << endl;
			exit(-1);
		}
		_top = 0;
		_capacity = capacity;
	}

	~Stack()
	{
		free(_a);
		_a = nullptr;
		_top = _capacity = 0;
	}

private:

	int* _a;
	int _top;
	int _capacity;
};


int main()
{
	Stack st1;
	Stack st2(st1);

	return 0;
}