目录

类的默认成员函数介绍

构造函数

构造函数概念

构造函数特性

析构函数

析构函数概念

析构函数特性

拷贝构造

拷贝构造概念

拷贝构造特点

赋值重载

赋值重载介绍

赋值重载特性

取地址重载和const取地址重载

const成员

 取地址和const取地址重载

---

类的默认成员函数介绍

当我们定义一个空类时，类中并非什么都没有，编译器会自动生成6个成员函数，这6个用户不显示实现，编译器会自动生成的函数称为默认成员函数。

//什么也没定义的空类
//用户没有显示定义，编译器自动生成6个默认成员函数
class zxy
{
	//构造函数

	//拷贝构造

	//赋值重载
	
	//析构函数

	//取地址重载

	//const 取地址重载
};

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

●析构函数：对资源进行清理。

●拷贝构造函数：用同类型对象创建对象。

●赋值重载：把一个对象赋值给另一个对象。

●取地址重载：对普通对象取地址。

●const取地址重载：对const对象取地址。

构造函数

构造函数概念

构造函数是特殊的成员函数，创建类类型对象时由编译器自动调用，在该对象生命周期内只调用一次！---- 构造函数的任务并不是开空间创建对象，而是初始化对象。

对比以往的初始化操作（以日期为例）：

class Date
{
public:
	void Init(int year,int month,int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << _year << "年" << _month << "月" << _day << "日" << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1;
	d1.Init(2001,10,3);

	return 0;
}

观察上述代码，Date类型的对象可以通过Init公有函数设置日期完成初始化，也就说每次创建对象都要调用Init方法。对比调用Init初始化的方式，构造函数的出现就是懒人的福音，它会在对象创建时自动调用，完成初始工作。下面会详细介绍构造函数的用法及特性！

构造函数特性

●函数名和类名相同，没有返回值。

●创建对象时，编译器自动调用构造函数。

●构造函数可以重载。

●不用传参就能调用的构造，叫做默认构造。如：无参构造，全缺省构造。

●若未显示定义构造函数，编译器会默认生成。显示定义，编译器则不在生成。

●默认生成的构造函数对内置类型（int/double/int*...）不做处理,对自定义类型调用其自身的默认构造。

●针对第7条，默认生成的构造函数不对内置类型做处理的情况，C++11中，可以将内置类型在类中声明时给缺省值，如：class zxy{int a = 10;}; 注意这不是初始化，而是给a一个缺省值。

●自定义类型作为其他类的成员变量时，要提供默认构造。

1.函数名和类名相同，没有返回值！

class Date
{
public:
	//构造函数名和类名相同
	Date()
	{}
private:
	int _year;
	int _month;
	int _day;
};

3.创建类类型对象时，编译器自动调用对应的构造函数。

class Date
{
public:
	//构造函数名和类名相同
	Date()
	{
		cout << "Date():调用构造函数" << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

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

上图示例中并没有调用任何函数，只是创建了一个Date类型的对象d1,通过测试结果可以得知，当用自定义类型创建对象时，编译器会自动调用它的构造函数。

4.构造函数可以重载。

根据不同的需求可以提供多个构造函数，无参，带参，全缺省，半缺省等。编译器会自动匹配合适的构造函数调用。

class Date
{
public:
	//无参
	Date()
	{
		//...
	}
	//带参
    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(2001, 10, 3);
	return 0;
}

需要注意的是，当构造函数不需要传参的时候，不要在对象名的后面加（），会和函数声明混淆。

错误的写法：
Date d1();

还要注意的是，如果同时提供了无参和全缺省，可能存在调用不明确的问题：在下述代码中同时提供了无参构造和全缺省构造,创建对象:Date d1; 构造函数调用不明确！！

class Date
{
public:
	//无参
	Date()
	{
		//...
	}
	//带参
    Date(int year = 2001,int month = 10,int day = 3)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};

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

5.若未显示定义构造函数，编译器会默认生成。显示定义，编译器则不在生成。

6.不用传参就能调用的构造，叫做默认构造。如：无参构造，全缺省构造，默认生成的构造。

7.默认生成的构造函数对内置类型（int/double/int*...）不做处理,对自定义类型调用其自身的默认构造。

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

class Date
{
	//没有显示定义构造，默认生成
private:
	//内置类型
	int _year;
	int _month;
	int _day;
	//自定义类型
	Time _t;
};

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

8.针对第7条，默认生成的构造函数不对内置类型做处理的情况，C++11中，可以将内置类型在类中声明时给缺省值，如：int a = 10; 注意这不是初始化，而是给a一个缺省值。

class Date
{
	//没有显示定义构造，默认生成
private:
	//内置类型
	int _year = 1;
	int _month = 1;
	int _day = 1;
	//自定义类型
	Time _t;
};

 9.自定义类型作为其他类的成员变量时，要提供默认构造。

class Time
{
public:
	Time(int hour)
	{
		cout << "Time()" << endl;
		_hour = 0;
		_minute = 0;
		_second = 0;
	}
private:
	int _hour;
	int _minute;
	int _second;
};

将Time类中的构造函数定义成上述代码中的样子，此时显示定义了构造函数，编译器不会默认生成。我们定义的又不是默认构造（默认构造的几种回看第6条）。报错：_t不具备合适的默认构造

析构函数

析构函数概念

析构函数的功能和构造函数相反。析构函数会在对象销毁时自动调用（对象销毁的工作是编译器完成的，如函数中的局部对象，出了函数作用域就销毁），完成对象中资源的清理工作！

析构函数特性

●析构函数名在类名前加上字符~，没有参数，没有返回值类型。

●一个类只能有一个析构函数，未显示定义会默认生成，显示定义则不在生成！析构函数不能重载。

●对象生命周期结束时，编译器自动调用析构函数。

●编译器自动生成的析构函数，会对自定义类型成员调用它的析构函数。

●内置类型成员，销毁时不用资源清理，最后由系统将内存回收即可。

●如果类中没有申请资源时，析构函数可以不写，如：Date类。当涉及资源的申请时，要显示的定义析构函数，避免内存泄露，如statck,queue。

●析构的顺序：先创建的对象后销毁，后创建的对象先销毁。

1.析构函数名在类名前加上字符~。没有参数，没有返回值类型。

~Stack(){}

2.一个类只能有一个析构函数，未显示定义会默认生成，显示定义则不在生成！析构函数不能重载

5.对象生命周期结束时，编译器自动调用析构函数。(以Stack为例)

class Stack
{
public:
	//构造函数
	Stack(size_t capacity = 10)
	{
		_array = (int*)malloc(sizeof(int) * capacity);
		if (_array == nullptr)
		{
			perror("malloc申请空间失败!!");
			exit(1);
		}
		_capacity = capacity;
		_size = 0;

		cout << "Stack()构造" << endl;
	}
	//析构函数
	~Stack()
	{
		free(_array);
		_size = 0;
		_capacity = 0;

		cout << "~stack()析构" << endl;
	}
private:
	int* _array;
	size_t _size;
	size_t _capacity;
};

int main()
{
	Stack s1;

	return 0;
}

6.编译器自动生成的析构函数，会对自定义类型成员调用它的析构函数。内置类型成员，销毁时不用资源清理，最后由系统将内存回收即可。

class Stack
{
public:
	Stack(size_t capacity = 10)
	{
		_array = (int*)malloc(sizeof(int)*capacity);
		if (_array == nullptr)
		{
			perror("malloc申请空间失败!!");
			exit(1);
		}
		_capacity = capacity;
		_size = 0;

		cout << "Stack()构造" << endl;
	}

	//析构，涉及资源清理，显示定义析构
	//析构的顺序和构造的顺序相反
	~Stack()
	{
		free(_array);
		_size = 0;
		_capacity = 0;

		cout << "~stack()析构" << endl;
	}
private:
	int* _array;
	size_t _size;
	size_t _capacity;
};

class MyQueue
{
	//没有显示定义构造函数，自定义类型调用其自身的默认构造

	//析构函数没有显示的定义，自定义类型调用其自身的析构函数
private:
	Stack s1;
	Stack s2;
};

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

 8.如果类中没有申请资源时，析构函数可以不写，如：Date类。当涉及资源的申请时，要显示的定义析构函数，避免内存泄露，如statck,queue。

拷贝构造

拷贝构造概念

用已存在的类类型对象创建新对象时，编译器自动调用拷贝构造函数。如：传值调用，传值返回。

拷贝构造特点

●拷贝构造是构造函数的重载。

●拷贝构造的参数必须为类类型的引用，且只有一个形参。

●拷贝构造如果使用传值的方式编译器会直接报错，因为会引发无穷递归，传值调用要发生拷贝，自定义类型对象调用自身的拷贝构造。

●拷贝构造若未显示定义，编译器会默认生成，默认生成的拷贝构造对内置类型按照字节拷贝，自定义类型去调用其自身的拷贝构造。（浅拷贝）

●在涉及资源的申请和释放场景中，拷贝构造需要显示的定义（要写析构，就要写拷贝构造）

1.拷贝构造是构造函数的重载。

拷贝构造函数名和类型相同，也没有返回值，参数为必须为类类型的引用，且只有一个形参，是构造函数的重载。

例：Stack (const Stack& st){}

加const的原因是为了防止在拷贝的过程中，将拷贝和被拷贝写反：如_A = st._A 写成 st._A = _A。

2.函数参数为类类型对象，形参是实参的一份临时拷贝，自动调用拷贝构造。

class Stack
{
public:
	//无参默认构造
	Stack()
	{
	}
	//拷贝构造
	Stack(const Stack& st)
	{
		cout << "拷贝构造调用" << endl;
	}
};

void Fun(Stack st)
{
	//...
}
int main()
{
	Stack st;
	Fun(st);
	return 0;
}

如上述代码，只是调用了Fun函数，该函数的参数类型是Stack类型的，在传值传参的过程中，发生了拷贝，自动调用该类类型的拷贝构造。

2.如果使用传值的方式编译器会直接报错，因为会引发无穷递归，传值调用要发生拷贝，自定义类型对象调用自身的拷贝构造，调用拷贝构造本身就要传参。所以拷贝构造的参数是类类型的引用。

 4.拷贝构造若未显示定义，编译器会默认生成，默认生成的拷贝构造对内置类型按照字节拷贝，自定义类型去调用其自身的拷贝构造。

class B
{
public:
	~B()
	{
		cout << "~B():调用析构" << endl;
	}
private:
	int _b;
};

class A
{
private:
	int _a1;
	int _a2;
	B _b1;
};

int main()
{
	A a;
	return 0;
}

A类没有显示的定义拷贝构造，编译器自动生成，自定义类型调用其自己的拷贝构造，内置类型逐自己拷贝。

 为了避免干扰，只打印了自定义类型调用析构的效果。

浅拷贝问题：

class Stack
{
public:
	//构造
	Stack(size_t capacity = 10)
	{
		_array = (int*)malloc(sizeof(int)*capacity);
		_size = 0;
		_capacity = capacity;
	}

	//没有显示定义拷贝构造，编译器默认生成
	//内置类型按字节拷贝
	
	//析构
	~Stack()
	{
		free(_array);
		_size = _capacity = 0;
	}
private:
	int* _array;
	size_t _size;
	size_t _capacity;
};

int main()
{
	Stack st1;
	Stack st2(st1);
	return 0;
}

 解决：显示的定义拷贝构造，改用深拷贝

	Stack(const Stack& st)
	{
		_array = (int*)malloc(sizeof(int)*st._capacity);
		memcpy(_array,st._array,sizeof(int)*st._capacity);

		_size = st._size;
		_capacity = st._capacity;

		cout << "深拷贝" << endl;
	}

 如上图所示，st2对st1进行了深拷贝，各自有独立的空间，插入数据互相也不会影响。

5.在涉及资源的申请和释放场景中，拷贝构造需要显示的定义（要写析构，就要写拷贝构造）。

6.拷贝构造的调用场景：

• 使用已经存在的对象创建新对象。

class A
{
public:
	A() {}
	A(const A& a)
	{
		cout << "拷贝构造调用" << endl;
	}
};

int main()
{
	A a1;
	A a2(a1);
	return 0;
}

• 函数参数为类类型对象，形参是实参的一份临时拷贝，自动调用拷贝构造。

void Fun(A a)
{
	//...
}

int main()
{
	A a1;
	Fun(a1);
	return 0;
}

• 当函数返回值为类类型对象，传值返回的过程中要产生临时变量，先存在寄存器或者上层栈帧中，这个期间的拷贝调用拷贝构造。

A Fun()
{
	A aa;
	return aa;
}

int main()
{
	A a1;
	Fun();
	return 0;
}

赋值重载

赋值重载介绍

赋值重载的主要功能就是将一个对象赋值给另一个对象，注意和拷贝构造进行区分，拷贝构造是用一个已经存在的对象创建一个新对象，赋值重载是将一个对象赋值给另一已经存在的对象。谈到拷贝和赋值，有一个容易混淆的写法：

	A a1;
	A a2 = a1;

class A
{
public:
	A() {}
	A(const A& a)
	{
		cout << "拷贝构造" << endl;
	}
	A& operator=(const A& a)
	{
		cout << "赋值重载" << endl;
	}
};

int main()
{
	A a1;
	A a2 = a1;
	return 0;
}

 上述的写法实际上调用的是拷贝构造，本质上是用一个存在的对象创建另一个对象。

 接着回到正文，为了增加代码的可读性，C++引入了运算符重载，赋值重载就是运算符重载中的一种。运算符重载具有特殊的函数名（关键字operator关键字后面接需要重载的运算符号如：+、-）。

返回类型 operator操作符(){}

因为赋值重载是运算符重载的一种，所以先来谈论什么是运算符重载：以日期类为例，自定义类型的两个日期类对象，直接使用==、+、-这些运算符是不可以的：

class Date
{
public:
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}

	void Show()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}

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

int main()
{
	Date d1(2001,10,3);
	Date d2(2001, 2, 9);

	d1 += d2;
	d1 -= d2;

	return 0;
}

 基于上述问题，我们可以在类中定义一个成员函数来判断两个日期的大小，或者实现其它功能

bool AddFun()
{
   //...日期加法的逻辑
}

在我们有需求时，调用成员函数即可，如：d1.AddFun(d2);  这样的写法和我们熟知的+、-、==、>等运算符比较，可读性更差一些！所以引入了运算符重载，在使用上和正常的+、-操作没什么不同，下面对部分运算符进行重载，观察运行效果：

class Date
{
public:
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}

	void Show()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}
	//重载==
	bool operator==(const Date& d1)
	{
		cout << "调用重载的==" << endl;

		return _year == d1._year
			&& _month == d1._month
			&& _day == d1._day;
	}
	//重载!=
	bool operator!=(const Date& d1)
	{
		return !(*this == d1);
	}
	//重载>
	bool operator>(const Date& d1)
	{
		cout << "调用重载的>" << endl;
		if (_year > d1._year)
		{
			return true;
		}
		else if(_year == d1._year && _month > d1._month)
		{
			return true;
		}
		else if (_year == d1._year && _month == d1._month && _day > d1._day)
		{
			return true;
		}
		return false;
	}

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

int main()
{
	Date d1(2001,10,3);
	Date d2(2001, 2, 9);

	//d1>d2 等价 d1.operator>(d2)
	cout << (d1 > d2) << endl;
	//d1==d2 等价 d2.operator==(d2)
	cout << (d1 == d2) << endl;
	return 0;
}

运算符重载后，就可以按照正常的使用习惯进行操作，例如：d1 == d2,d1 > d2。但是它们的原型是d1.operator==(d2); d1.operator>(d2)。 运算符重载后，在使用上提供了便捷，在代码的可读性上更为直观。

关于运算符重载还有几点要谈：

1.不能通过operator关键字连接其他符号创建新的操作符，如：operator@。

2.重载操作符必须有一个类类型参数，也就是说不能随便重载，比如：int + int

int operator+(int a, int b)
{
	return a * 10 + b;
}

int main()
{
	int a = 10,b =5;
	int c = a + b;
	return 0;
}

3,作为类成员函数时，形参比操作数少1，因为成员函数的第一个参数为隐藏的this指针。

4.    .*     ::      sizeof    ?:     . 注意以上5个运算符不能重载。

5.前置++/--和后置++/--。（相关细节参考日期类模拟实现的文章）。

对于内置类型而言，后置++/--比前置++/--多了一次拷贝，在实现上后置的++/--的参数列表要显示的写int,这是和编译器的暗号，用来区分是前置++/--还是后置++/--。

T& operator++()
{
    //...
}

T operator++(int)
{   
    //...
}

还需要说明的是，前置++适合返回类类型的引用，减少一次拷贝。而后置++返回的是局部变量，只能传值返回。

6.流插入和流提取运算符重载。（相关细节参考日期类模拟实现的文章）。

流插入和流提取在基础篇介绍过，它们分别是istream和ostream的对象，对于自定义类型而言，流插入和流提取是无法识别的，因为库中只实现了内置类型的<<和>>重载。当我们想要自定义类型的对象像内置类型一样输出和输出时，需要重载<<和>>。

赋值重载特性

●赋值运算符重载：返回值类型  operator=(const T& )。

●参数类型const T& ，减少拷贝。返回值类型T&，支持连续赋值，d1 = d2 = d3。

●返回值返回*this，支持连续赋值。

●自己给自己赋值的情况要检查，如：d1 = d2。

●不显示定义编译器会自动生成，内置类型逐字节拷贝，自定义类型调用其自己的赋值重载。

●赋值运算符重载只能重载成类的成员函数，不能重载成全局函数。

●当有资源申请，没有显示定义赋值重载的情况，可能会出现内存泄露和重复析构。

1、赋值运算符重载单参数为const T& ，返回值为T&，支持连续赋值。（以Stack为例：）

class Stack
{
public:
	//赋值重载
	Stack& operator=(const Stack& s1)
	{
		//....
		return *this;
	}
private:
	int* _array;
	int _size;
	int _capacity;
}

2.不显示定义编译器会自动生成，内置类型逐字节拷贝，自定义类型调用其自己的赋值重载。

class A
{
public:
	A& operator=(const A& A)
	{
		_a1 = A._a1;
		_a2 = A._a2;
		cout << "A& operator=(const A& A)" << endl;
		return *this;
	}
private:
	int _a1=10;
	int _a2=20;
};

class B
{
	//没有显示的定义赋值重载，内置类型按字节拷贝，自定义类型调用其对应的
	//赋值重载
private:
	A a;
	int b;
};

int main()
{
	A a1;
	A a2;

	a2 = a1;
	return 0;
}

B类没有显示定义赋值重载，默认生成的赋值重载函数对于自定义类型会调用其自己的赋值重载，内置类型按照字节拷贝。

3.定义赋值重载函数，无论形参的类型是什么，赋值运算符重载都要定义为成员函数！！！

原因：赋值运算符在类中不显示实现，会默认的生成一个。此时如果在类外定义了一个全局的赋值重载函数，两个函数就会冲突。

class A
{
	//没有显示定义赋值重载，编译器自动生成一个
private:
	int _a;
	int _a2;
};

//定义全局的赋值重载函数
A& operator=(const A& left, const A& right)
{
	//....
}

int main()
{
	A a1;
	A a2;
	a1 = a2;
	return 0;
}

 需要注意的是，全局函数的参数没有this指针，所以需要传两个参数。

对于其他运算符重载，可以定义为全局函数，在传参的时候注意要传两个参数：

class A
{
public:
	A(int a1, int a2)
	{
		_a1 = a1;
		_a2 = a2;
	}
public:
	int _a1;
	int _a2;
};

//定义全局的赋值重载函数
bool operator==(const A& left, const A& right)
{
	cout << "全局运算符重载==" << endl;
	return left._a1 == right._a1
		|| left._a2 == right._a2;
}

int main()
{
	A a1(10,20);
	A a2(20,30);

	cout << (a1 == a2) << endl;
	return 0;
}

(a1 == a2) 等价于 operator=(a1,a2) ;

但是一般情况下，将运算符重载定义为成员函数更为常见，这是因为，类的成员变量一般都会设为私有，运算符重载经常要访问成员变量。上述代码为了演示将成员变量设为了公有。

4.当有资源申请，没有显示定义赋值重载的情况，可能会出现内存泄露和重复析构。（以Stack为例）：

class Stack
{
public:
	//构造函数
	Stack(size_t capacity = 10)
	{
		_array = (int*)malloc(sizeof(int)*capacity);
		_size = 0;
		_capacity = capacity;
	}
	//析构，有资源的申请，显示定义析构
	~Stack()
	{
		free(_array);
		_array = nullptr;
		_size = _capacity = 0;
	}

	//拷贝构造，有资源的申请，显示定义，深拷贝
	//用已有的对象构建新对象
	Stack(const Stack& st)
	{
		_array = (int*)malloc(st._capacity*sizeof(int));
		memcpy(_array, st._array, sizeof(int) * st._size);

		_size = st._size;
		_capacity = st._capacity;
	}
    
    //赋值重载没有显示定义，用默认生成的
	//赋值重载,将已经存在的对象赋值给另一个存在的对象
	//涉及资源的申请，如果用默认生成的赋值，会造成资源泄露和多次析构的问题


	void Push(const int val)
	{
		//简单模拟，不考虑扩容问题
		_array[_size++] = val;
	}
private:
	int* _array;
	int _size;
	int _capacity;
};

 

如上图分析，当涉及资源的申请时，要显示的定义合适的赋值重载：

	Stack& operator=(const Stack& st)
	{
		//自己赋值自己直接返回即可
		if (this != &st)
		{
			//先把旧的空间释放，再去拷贝
			free(_array);

			_array = (int*)calloc(st._capacity,sizeof(int));
			if (_array == nullptr)
			{
				perror("malloc失败！");
				exit(1);
			}
			memcpy(_array, st._array, sizeof(int) * st._size);
			_size = st._size;
			_capacity = st._capacity;
		}
		return *this;
	}

在上述代码中，还有一个细节，就是对自己赋值给自己的情况直接略过不进行处理，如果忽略了这种情况，可能会出现bug，以上述代码为例：

综上所述，在赋值重载的实现中，要注意自己给自己赋值的情况。 

取地址重载和const取地址重载

const成员

在类和对象上篇谈论过，隐含的this指针类型是T* const this。 const 修饰的是指针本身，禁止this指针改变指向。基于这种情况，如果我们有const对象调用成员函数的时候，const对象调用非const成员函数，是权限的放大，这样的调用是错误的。

class Date
{
public:
	void Fun()
	{
		//...
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	const Date d1;
	d1.Fun();
	return 0;
}

上述的调用是const对象调用非const的成员函数，是权限的放大，不可以。下述代码是正确的写法：

class Date
{
public:
	Date() {}
	void Fun() const
	{
		//...
	}
private:
	int _year = 1;
	int _month = 2;
	int _day = 3;
};

int main()
{
	const Date d1;
	d1.Fun();
	return 0;
}

在函数后面加const修饰，const修饰的是this指针指向内容，表示在该成员函数中不能对类的成员变量进行修改。

 取地址和const取地址重载

这两个默认函数不写，编译器会默认生成。通常情况下，编译器默认生成的就足够满足我们的需求，它们的功能分别是对普通对象取地址和对const对象取地址。

class Date
{
public:
	Date* operator&()
	{
		return this;
	}
	const Date* operator&()const
	{
		return this;
	}
private:
	int _year = 1;
	int _month = 2;
	int _day = 3;
};

int main()
{
	const Date d1;
	Date d2;

	cout << &d1 << endl;
	cout << &d2 << endl;
	return 0;
}

 这两个默认成员函数一般不用显示的写，编译器默认生成的就足够用了。