类和对象2

一，构造函数

特性：

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

class Date
{
public:
	// 构造函数 ->在对象构造时调用的函数，这个函数完成初始化工作
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}

	Date()
	{
		_year = 0;
		_month = 1;
		_day = 1;
	}

	void Init(int year, int month, int day) // void Init(Date* this, int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}

	void Print()  // void Print(Date* this) 
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	// 对象实例化时自动调用
	Date d1(2020, 4, 8);
	d1.Print();

	Date d2;  // Date d2();不能加括号
	d2.Print();

	return 0;
}

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

class Time
{
public:
	Time()
	{
		_hour = 0;
		_minute = 0;
		_second = 0;

		cout << "Time()" << endl;
	}
private:
	int _hour;
	int _minute;
	int _second;

};

class Date
{
public:
	// 我们没有显式定义构造函数，这里编译器生成无参默认构造函数
	// 默认生成无参构造函数（语法坑：双标狗）
	// 1、针对内置类型的成员变量没有做处理
	// 2、针对自定义类型的成员变量，调用它的构造函数初始化

	// 一旦用户显式定义编译器将不再生成。
	/*Date(int year, int month, int day)
	{
	_year = year;
	_month = month;
	_day = day;
	}*/

	void Print()  // void Print(Date* this) 
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;

	Time _t;
};

int main()
{
	Date d1;  // 调用编译器生成构造函数
	d1.Print();

	//Date d2(2020, 3, 8); 
	//d1.Print();

	return 0;
}

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

默认构造函数
class Date
{
public:
	// 一旦用户显式定义编译器将不再生成。
	/*Date()
	{
	_year = 0;
	_month = 1;
	_day = 1;
	}
	*/
	
	Date(int year, int month, int day)
	{
	_year = year;
	_month = month;
	_day = day;
	}

	// 更好的方式->全缺省
	/*Date(int year = 0, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}*/

	void Print()  // void Print(Date* this) 
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1;   // 调用默认构造函数  -》1、自己实现无参的构造函数 2、自己实现的全缺省构造函数  3、我们不写，编译自动生成的
	                                   // 特点：不用传参数
	d1.Print();

	//Date d2(2020, 3, 8);
	//d2.Print();

	return 0;
}

• 拷贝构造函数的参数只有一个且必须使用引用传参，使用传值方式会引发无穷递归调用。

二、析构函数

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

      特性：

1.  析构函数名是在类名前加上字符 ~。
2. 无参数无返回值。 
3. 一个类有且只有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。
4. 对象生命周期结束时，C++编译系统系统自动调用析构函数。

 

class Date
{
public:
	Date(int year = 0, int month = 1, int day = 1)
	{
		cout << "Date(int year = 0, int month = 1, int day = 1)" << endl;
		_year = year;
		_month = month;
		_day = day;
	}

	void Print()  // void Print(Date* this) 
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}

	~Date()
	{
		cout << "~Date()" << endl;
	}

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

class Stack
{
public:
	Stack(int n = 10)
	{
		_a = (int*)malloc(sizeof(int)*n);
		cout << "malloc:" << _a << endl;
		_size = 0;
		_capacity = n;
	}

	~Stack()
	{
		free(_a);
		cout << "free:" << _a << endl;
		_a = nullptr;
		_size = _capacity = 0;
	}

private:
	int* _a;
	int _size;
	int _capacity;
};

int main()
{
	 析构：对象声明周期到了以后，自动调用。完成对象里面的资源清理工作，不是完成d1和d2销毁
	Date d1;
	Date d2;

	Stack s1;
	Stack s2;

	 ...Push

	return 0;
}

浅拷贝：直接复制内存

深拷贝：当成员中有指向堆的指针，就必须重新给该指针分配空间，然后将目标对象指针所指空间的内容拷贝到新分配的空间。（如果不这样做，会导致两个指针指向同一片空间，从而在析构中多次释放）。

三、const成员函数

const对象可以调用其他的const函数；

非const对象可以调用非const成员函数和const成员函数；

const成员函数内可以调用其他的const成员函数；

非const成员函数内可以调用其他的const成员函数和非const成员函数。