类的默认成员函数

我们知道，面向对象三大特性：继承、封装、多态，其中封装就是将事务的属性和方法封装到类中，对外只提供相应的接口，隐藏具体实现细节，下来我们就要讨论类中的默认成员函数，什么是默认就是在主动声明的时候，由编译器自动生成的函数；下来我们认识一下几个默认成员函数；

构造函数

构造函数的主要功能就是初始化对象，并不是开辟空间创建对象；
特性：
1、与类同名，无返回值，
2、在对象的生命周期中只调用一次
3、构造函数在对象实例化是有编译器自动调用，
4、构造函数可以重载编译器

class Date
{
public:
	Date()//无参构造函数
	{
	}
	Date(int year,int mont,int day)//带参构造函数
	{
	}
private:
	int year;
	int month;
	int day; 
};
int main()
{
	//Date d1();//调用无参构造函数不要后面跟()，这样就成立函数声明
	Date d2;//调用无参构造函数
	Date d3(2001,1,2);//调用带参构造函数
}
//注意：当我们没有向上面显示的声明构造函数时，编译器任然会自动生成一个无参默认的构造函数；
//默认的构造函数(无参或全缺省)只能有一个，编译器自动生成的和无参构造函数和全缺省构造函数都是默认的成员函数；

问题：编译器生成的默认构造函数作用？
答：C++有内置类型和自定义类型，内置类型已经定义好了，但是我使用自定义类型时，编译器生成默认的构造函数会对自定类型成员_t调用的它的默认成员函数；

析构函数

析构函数不是完成对象的销毁而是对象销毁时自动调用析构函数，完成的还能够类的一些资源清理工作；
特性：
1、与类名相同，但是前面加上~
2、无参数、无返回值
3、一个类只能有一个析构函数
4、在对象声明周期结束时，编译器调用
若是没有显示声明，编译器会自动生成一个默认析构函数，作用对于自定义类型调用其析构函数；

拷贝构造函数

在创建对象时，用一个已经存在的对象去创建一个新的一模一样的对象，调用拷贝构造函数
特性：
1、只有一个参数，该形参是类类型对象的引用一般有const修饰，
2、是构造函数的一种重载形式
3、无返回值，与类同名

class Date
{
public:
	Date()//无参构造函数
	{
	}
	Date(const Date& d)//拷贝构造函数
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day; 
};

问题1：为什么实参要用传递引用的方式而不是传值？
答：避免出现无限调用循环的情况出现，传值要将实参拷贝一份临时的传递给函数形参，这个过程会调用拷贝构造函数，致辞无限循环下去

注意：同构造函数相同，不显示定义系统自动生成一个默认构造函数；但是在进行拷贝时是按照字节序的只拷贝，我们也叫做浅拷贝；但是有时候浅拷贝不能决绝所用问题还需要深拷贝(后面详解深浅拷贝)

重载复制运算符

运算符重载：为了增强代码可读性而存在，运算符重载是具有特殊函数名的函数；
特性：
1、函数名：operator + 要重载的运算符
2、函数原型： 返回值 operator操作符(参数列表)
3、重载操作符必须有一个类类型或者枚举类型操作数
4、其第一个参数为隐藏的this指针
5、*、::、sizeof、?:、.不能重载

方式一：重载成全局的，
class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
	{
	_year = year;
	_month = month;
	_day = day;
	}
//private://注意：条件：成员变量就要是公用的(也可通过友元解决d)
	int _year;
	int _month;
	int _day;
};
bool operator==(const Date& d1, const Date& d2)
{
	return d1._year == d2._year;
	&& d1._month == d2._month
	&& d1._day == d2._day;
}

方式二：重载成成员函数
class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
	{
	_year = year;
	_month = month;
	_day = day;
	}
	bool operator==(const Date& d2)
{
	return d1._year == d2._year;
	&& d1._month == d2._month
	&& d1._day == d2._day;
}
private:
	int _year;
	int _month;
	int _day;
};

重载复制运算符：
注意：
1、参数类型
2、返回值
3、检测是否是在给自己赋值
4、返回*this
5、一个类如果没有显示定义，编译器自动生成一个，执行浅拷贝

class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
	{
	_year = year;
	_month = month;
	_day = day;
	}
	Date& operator=(const Date& d2)
{
	if(this != &d)//检测是否是在给自己赋值
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
	return *this;
}
private:
	int _year;
	int _month;
	int _day;
};

注意：深浅拷贝问题

const成员

const修饰成员函数：也叫const成员函数，其实就是修饰成员的隐藏this指针，保证调用该函数的对象该函数中不会被改变；

这内有几个问题，先看代码：

class Date
{
public:
	void testfunc1()//非const成员函数
	{
		cout<<"testfunc1<<endl;
	}
	
	void testfunc2() const//const成员函数
	{
		cout<<"testfunc2 const"<<endl;
	}

	void testfunc3()//非const成员函数
	{
		testfunc1();// 非const成员函数内调用其它的非const成员函数
		testfunc2(); //非const成员函数内调用其它的const成员函数
	}
	
	void testfunc4() const//const成员函数
	{
		testfunc1();//const成员函数内调用其它的非const成员函数--编译出错
		testfunc2();//const成员函数内调用其它的const成员函数
	}
private:
	int _year;	
};
int main()
{
	Date d1;//非const对象
	d1.testfunc1();//非const对象调用非const成员函数
	d1.testfunc2();//非const对象调用const成员函数
	
	const Date d2;//const对象
	d2.testfunc1();//const对象调用非const成员函数---编译出错
	d2.testfunc2();//const对象调用const成员函数
}

上面代码出错，我们看出来只有const对象调用非const成员函数和const成员函数内调用其它的非const成员函数出错，为什么或出现这种情况！通俗理解const修饰的对象，那么对象自身就不能被修改(可以认为就是可读不可写)，const修饰的成员函数，那么该成员函数就不能修改类中任何成员(可以认为就是可读不可写)，相反没有被const修饰的对象或函数，自身被允许修改和允许去修改类中成员(可读可写)；根据C++中的范围缩小原则，很容易就可以理解，可读不可写的cosnt对象调用可读可写的成员函数，那么对象就有可能被修改，这是不被允许的，同理可读不可写的成员函数调用可读可写的其他成员函数范围被增大，这也是不被允许的；这样就可以理解了！！！

取地址以及const取地址操作符重载

这两个默认成员函数一般不用重新定义 ，编译器默认会生成，只有特殊情况，才需要重载，比如想让别人获取到指定的内容

class Date
{
public :
	Date* operator&()//非const对象调用
	{
		return this ;
	}
	const Date* operator&()constconst对象调用
	{
		return this ;
	}
private :
	int _year ; // 年
	int _month ; // 月
	int _day ; // 日
};