类的6个默认成员函数及const成员函数

一.类的6个默认函数

空类即一个类中无任何成员。空类中并不是什么没有，它会在我们不写的情况下自动生成6个默认函数，如下：
1.构造函数
（1）概念：构造函数是一个特殊的成员函数，它的名字必须和类名相同，并且无返回值，在创建对象时由编译器自动调用
构造函数用来初始化对象

class Date {
public:
	void SetDate(int year, int month, int day) {
		_year = year;
		_month = month;
		_day = day;
	}
	void Display() {
		cout << _year << "-" << _month << "-" << _day << endl;
	}
	//1.无参数构造
	Date()
	{}
	//2.带参数构造
	Date(int year, int month, int day) {
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main() {
	Date d1;//调用无参构造函数
	Date d2(1982, 12, 20);//调用带参构造函数
	//如果通过无参构造函数创建对象时，对象后面不用跟括号，否则就成了函数声明
	Date d1, d2;
	d1.SetDate(2018, 1, 9);
	d1.Display();
	d2.SetDate(2018, 12, 20);
	d2.Display();
	return 0;
}

（2）特性：

• 函数名与类名相同
• 无返回值
• 对象实例化时编译器自动调用对应的构造函数
• 构造函数可以重载（如上代码的无参构造和带参构造）
• 若类中无构造函数，实例化对象（无参）可以被调用，一旦类中出现构造函数，无参的实例化对象就不能被调用
• 无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认成员函数

class Test{
public:
	Test(){
	cout<<"Copy Test Object:"<<this<<endl;
	data = 0;
	}
	Test(int d = 0){
	data = d;
	}
private:
	int data;
};
void main(){
	Test d;//该对象不能成功进行编译，因为构造函数中出现了两个默认构造函数，计算机不知道该调用哪个
}

（3）构造函数体的赋值

class Test {
public:
	Test(int data = 0):m_data(data)//参数列表初始化
	{
		//m_data = data;
	}
private:
	int m_data;
};

void main() {
	const Test t;
}

初始化列表：以：开始，接着是以，分隔的数据成员列表，每个"成员变量"后面跟一个放在括号中的初始值或表达式
注：

1. 每个成员变量在初始化列表中只能出现一次（初始化只能初始一次）

Test(int data =0):m_data(data),m_data(0)//该代码错误

2. 类中包含以下成员，必须放在初始化列表位置进行初始化
   a.引用成员变量

class Test{
public:
	Test(int b):m_a(0),m_b(b){}
private:
	int m_a;
	int &m_b.
};
void main(){
	int a = 10;
	Test t(a);
}

b.const成员变量

class Test{
public:
	Test(int b):m_c(0){}
private:
	const int m_c;
};

c.自定义类型成员（该类没有默认构造函数）

class A{
public:
	A(int a):_a(a){}
private:
	int _a;
};
class Test{
public:
	Test(int b):m_aa(0){}
private:
	A m_aa;
};

3. 尽量使用初始化列表初始化
4. 成员变量在类中声明次序就是其在初始化列表中的初始化顺序

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

typedef int DataType;
class Seqlist {
public:
	Seqlist(int capacity = 10) {
		_data = (DataType*)malloc(capacity * sizeof(DataType));
		assert(_data != NULL);
		_size = 0;
		_capacity = capacity;
		cout << "Creat Seqlist Object:" << this << endl;
	}
	~Seqlist() {
		free(_data);//释放堆上的空间
		_data = NULL;//将指针置为空
		_capacity = 0;
		_size = 0;
		cout << "Free Seqlist Object:" << this << endl;
	}
private:
	int *_data;
	size_t _size;
	size_t _capacity;
};

int main() {
	Seqlist();
	return 0;
}

（2）特性：

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

3.拷贝构造函数
（1）概念：只有单个形参，该形参是对本类类型对象的引用(一般常用const修饰)，在用已存在的类类型对象创建新对象时由编译器自动调用

class Date {
public:
	Date(int year = 1992, int month = 12, int day = 20) {
		_year = year;
		_month = month;
		_day = day;
		cout << "year=" << _year << ",month=" << _month << ",_day=" << _day << endl;
	}
	Date(const Date &d) {//参数传引用，防止出现无限递归
		_year = d._year;
		_month = d._month;
		_day = d._day;
		cout << "d.year=" << _year << ",d.month=" << _month << ",d._day=" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main() {
	Date d1;
	Date d2(d1);
	return 0;
}

（2）特性：
用对象初始化对象时，会触发拷贝构造函数（Date t2 = t1）

• 拷贝构造函数是构造函数的一个重载形式
• 拷贝构造函数的参数只有一个且必须使用引用传参，使用传值方式会引发无穷递归调用
• 若未显示定义，系统会生成默认的拷贝构造函数。默认的拷贝构造函数对象按照内存存储按字节序完成拷贝，这种拷贝我们叫做浅拷贝，或者值拷贝

class Date {
public:
	Date(int year = 1900, int month = 1, int day = 1) {
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main() {
	Date d1;
	Date d2(d1);//这里d2调用的默认拷贝构造完成拷贝，d1和d2的值也是一样的
	return 0;
}

（3）在以下3种情况下，会调用拷贝构造方法
a.直接对象初始化对象
b.函数的参数是以对象传递的
c.函数是以对象的值返回的，在返回时也会调用拷贝构造方法

class Test{
public:
	void SetData(int data){
		m_data = data;
	}
	int GetData(){
		return m_data;
	}
	Test fun(Test obj){
		int value = obj.GetData();
		Test tmp(value);
		return tmp;
	}
private:
	int m_data;
};
void main(){
	Test t1(100);
	fun(t1);
}

4.赋值操作符重载
（1）运算符重载
运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。
函数名字为：关键字 operator 后面接需要重载的运算符符号
函数原型：返回值类型 operator操作符（参数列表）
注意：

• 不能通过连接其他符号来创建新的操作符：比如operator@
• 重载操作符必须有一个类类型或者枚举类型的操作数
• 用于内置类型的操作符，其含义不能改变，例如：内置的整型+，不能改变其含义
• 作为类成员的重载函数时，其形参看起来比操作数数目少1成员函数的 操作符有一个默认的形参this，限定为第一个形参
• .* 、:: 、sizeof 、?: 、. 注意以上5个运算符不能重载
  （2）赋值运算符重载

class Date {
public:
	Date(int year = 1992, int month = 12, int day = 20) {
		_year = year;
		_month = month;
		_day = day;
		cout << "year=" << _year << ",month=" << _month << ",_day=" << _day << endl;
	}
	Date(const Date &d) {//参数传引用，防止出现无限递归
		_year = d._year;
		_month = d._month;
		_day = d._day;
		cout << "d.year=" << _year << ",d.month=" << _month << ",d._day=" << _day << endl;
	}
	Date &operator=(const Date &d) {
		if (this != &d) {//检查是否自己给自己赋值
			_year = d._year;
			_month = d._month;
			_day = d._day;
		}
		return *this;
		cout << "year=" << _year << ",month=" << _month << ",_day=" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main() {
	Date d1;
	Date d2(2002, 11, 26);
	d1 = d2;//赋值 d1.operator= d2;
	return 0;
}

（2）特性：

• 参数类型
• 返回值
• 检测是否自己给自己赋值
• 返回*this
• 一个类如果没有定义赋值运算符重载，编译器也会生成一个完成对象按字节序的值拷贝

5.取地址操作符（常地址符和普通地址符 ）

class Date{ 
public: 
	Date* operator&() { //普通地址符1
		return this; 
	}  
	const Date* operator&()const{//常地址符
		return this;
	}
private: 
	int _year; // 年
	int _month; // 月 
	int _day; // 日};

这两个运算符一般不需要重新定义，编译器会自动生成，一般不需要重载，使用编译器生成的默认取地址的重载即可，只有特殊情况，才需要重载，比如想让别人获取到指定的内容！

二.const成员函数

将const修饰的类成员函数称之为const成员函数，const修饰类成员函数，实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进行修改。

class Test {
public:
	void SetData(int data) {
		m_data = data;
	}
	//int GetData(const Test * const this)
	int GetData()const {//常方法
		this->Show();//常方法不能在内部调用普通方法
		return m_data;
	}
	//int GetData(Test * const this)
	int GetData(){//两个可以同时存在，原因就是两个参数不同，形成重载
		return m_data;
	}
	//Test * const this
	void Show() {
		GetData();//普通方法在内部可以调动常方法
		cout << m_data << endl;
	}
private:
	int m_data;
};
void main() {
	Test t;//普通对象可以调用int GetData()方法
	t.GetData();
	const Test t1;//常变量只能调动常方法
	cout << "t1=" << t1.GetData() << endl;
}