认识C++的类中默认生成的构造函数，析构函数拷贝构造函数和赋值运算符重载

类中默认的成员函数

类的6个默认成员函数

如果一个类中什么成员都没有，简称为空类，其实它并不是空的，它会默认生成6个成员函数。

构造函数：主要完成初始化工作

析构函数：主要完成清理工作

拷贝构造：是使用同类对象初始化创建对象

赋值重载主要把一个对象赋值给另一个对象

还有两个很少自己实现，主要是普通对象和const 对象取地址。

一、构造函数

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

自定义构造函数：

1、无参构造函数

class Date
{ 
public :
 // 1.无参构造函数
 Date ()
 {}
private :
 int _year ;
 int _month ;
 int _day ;
};
void TestDate()
{
 Date d1; // 调用无参构造函数
 Date d2 (2015, 1, 1); // 调用带参的构造函数
 
 // 注意：如果通过无参构造函数创建对象时，对象后面不用跟括号，否则就成了函数声明
 // 以下代码的函数：声明了d3函数，该函数无参，返回一个日期类型的对象
 Date d3();

2、有参构造函数：

include<iostream>
using namespace std;
class Date
{
public:
    // 2.带参构造函数
 Date (int year, int month , int day )
 {
 _year = year ;
 _month = month ;
 _day = day ;
 }
private:
    int _year;
    int _month;
    int _day;   
};
//创建对象时Date d3(201.,12,45),必须传参 

3、全缺省的构造函数;

include<iostream>
using namespace std;
class Date
{
public:
    // 2.带参构造函数
 Date (int year=1900, int month =12, int day=1 )
 {
 _year = year ;
 _month = month ;
 _day = day ;
 }
private:
    int _year;
    int _month;
    int _day;   
};
//创建对象可以传参Date d3(2010,12),也可以不传参Date d3;
参考C++中的缺省参数

构造函数特性：

函数名与类名相同， 

无返回值 ，

对象实例化时编译器自动调用对应的构造函数   ，

构造函数可以重载。

如果我们在类中没有定义构造函数，默认生成无参构造函数。我们自己定义了，就不会默认生成了。

注：无参构造函数和有参构造函数时重载函数。

C++中把类型分为内置类型和自定义类型，自定义类型即使用class struct union 定义的类型，内置类型就是int char  等等。

编译器生成默认的构造函数会对自定义类型成员_t调用的它的默认成员函数。

看个代码;

#include<iostream>
using namespace std;
class Time
{
public:
	Time()
	{
		cout << "time()" << endl;
		_hour = 0;
		_minute = 0;
		int second = 0;
	}
private:
	int _hour;
	int _minute;
	int _second;
};
class Date
{
private:
	int _year;
	int _month;
	int _day;//内置类型


	Time _t;//自定义类型
};
int main()
{
	Date d;//会默认调用Time的内部成员函数
	return 0;
}

运行结果：

二、析构函数

对象在销毁时会自动调用析构函数，完成类的一些清理工作。

特性：

析构函数名实在类名加上~。

无参无返回值。

一个类有且只有一个析构函数。

对象生命周期结束时，c++编译系统会自动调用析构函数。

对字定义类型会自动调用它的析构函数。

注：一般在堆上创建的对象需要自己定义析构函数，

举个例子：

#include<iostream>
#include<string.h>
#pragma warning(disable:4996)
using namespace std;
class String
{
public:
	String(const char* str = "jack")
	{
		_str = (char*)malloc(strlen(str) + 1);
		strcpy(_str, str);
	}
	~String()
	{
		cout << "String()" << endl;
		free(_str);
	}
private:
	char* _str;
};
class Person
{
private:
	String name;//自定义类型
	int age;
};
int main()
{
	Person s;//会调用String的析构函数
	return 0;
}

运行结果：

三、拷贝构造函数

拷贝构造函数时构造函数的一个重载形式

拷贝构造函数的参数只用一个，但是必须是引用参数，

#include<iostream>
using namespace std;
class Date
{
public:
	//全缺省的构造函数
	Date(int year = 1900, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	//拷贝构造函数
	Date(const Date& d)//其实有两个参数，另一个是隐藏的this指针
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
		
	}
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(2010, 5, 11);
	Date d2(d1);//，调用了拷贝构造函数，将d1的内容拷贝给d2
	d1.Print();
	d2.Print();
	return 0;
}

这只是浅拷贝，将它的值拷贝给创建的新对象，对其初始化。

四、赋值运算符重载

赋值运算符重载是为了让自定义类型使用操作符。

函数原型：返回值类型  operator 操作符 （形参列表）

(.* )、(::)、（sizeof）、(? :)、（.）这些运算符不能重载。

举个例子：重载==

#include<iostream>
using namespace std;
class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	bool operator==(const Date& d)
	{
		return _year == d._year && 
			_month == d._month &&
			_day == d._day;
	}
	
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(2010, 5, 11);
	Date d2(2010, 8, 6);
	bool c(d1 == d2);
	cout << "d1==d2:" << c << endl;
	return 0;
}

运行结果如下：