构造函数

特点

1.名字与类名相同
2.无返回值
3.对象实例化的时候编译器自动调用这个函数
4.构造函数可以重载（无参构造函数，拷贝构造等）
5.如果类中没有显式定义构造函数（深拷贝），则编译器会自动生成一个默认构造函数（浅拷贝/值拷贝），若显式定义了编译器就不再生成

class Date
{
public:
	Date()//无参构造函数
	{}
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
public:
	void test1()
	{
		Date d1;//无参
		Date d2(2024, 4, 14);//带参
	}
};

6.c++把类型分为内置类型和自定义类型，对于内置类型来说，编译器自动生成的默认构造函数是不会将内置类型初始化的（为了弥补这个缺陷，c++11中的内置成员变量在声明的时候是可以给默认值的），所以如果下面这个代码我们没有主动去设置构造函数，里面的三个成员变量就都是随机值，若他是自定义类型，编译器就会去调用这个类型的默认构造函数

#include<iostream>
using namespace std;
class Day
{
public:
	Day()
	{
		_day = 0;
		cout << "Day()" << endl;
	}
private:
	int _day;
};
class Date
{
private:
	int _year=2024;
	int _month=4;
	Day _day;
};
int main()
{
	Date d1;
	return 0;
}

7.无参的构造函数，全缺省的构造函数和编译器自动生成的构造函数都可以被称为默认构造函数

初始化列表

来由

调用构造函数赋值时，我们会给变量一个初始值，但是这不能称为变量的初始化，只能称为赋值，因为初始化只能初始化一次，而构造函数中可以对变量多次赋值，于是就产生了初始化列表。

用法

以一个冒号为开始，每个成员变量后面跟着一个用括号隔开的值或者表达式

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

注意：每个成员变量在初始化列表中只能初始化一次，也就是只能出现一次，当类中成员变量包含引用成员变量，const类型成员变量，没有默认构造函数的类类型成员变量时，都要放在初始化列表初始化，我们也尽量使用初始化列表初始化，因为不管你用不用初始化列表，程序都会先走初始化列表再执行构造函数里面的内容的，成员变量的声明顺序就是初始化列表的初始化顺序，与初始化列表里的顺序是无关的，所以最好不要让初始化的成员互相初始化，很容易得到随机值

explicit关键字

我们偶尔会看到如下代码

class vientiane
{
public:
	vientiane(int year,int month=1,int day=1)
	:_year(year)
	,_month(month)
	,_day(day)
	{}
private:
	int _year;
	int _month;
	int _day;
}
int main()
{
	vientiane d1(2024);
	vientiane d2=2024;
	return 0;
}

也许你会疑惑，d2是一个自定义类型，而2024是一个整形，为什么可以这样直接赋值呢？其实，c++里有一种隐式类型转换，比如说你现在有一个整形变量a=1，你想让他赋值给double类型变量b，那么在赋值过程中会产生一个double类型的临时变量，这个double类型的临时变量被赋值成1.0，然后再用这个临时变量去给b赋值，上图那段代码也一样，“2024”会先调用构造函数构造一个vientiane类型的变量，然后再用拷贝构造去初始化d2，如果你不想要有这样的类型转换，你可以在构造函数前加一个explicit关键字

class vientiane
{
public:
	explicit vientiane(int year,int month=1,int day=1)
	:_year(year)
	,_month(month)
	,_day(day)
	{}
private:
	int _year;
	int _month;
	int _day;
}
int main()
{
	vientiane d1(2024);
	vientiane d2=2024;
	return 0;
}

这样，上述代码就会报错了

析构函数

概念

析构函数不是对对象的销毁，而是完成销毁后对对象里的资源清理工作，对象的销毁是由编译器自己进行的

特点

1.析构函数名是类名前加一个~
2.析构函数没有参数也没有返回值，自然就无法构成重载
3.一个类只能有一个析构函数，若没有显式定义析构函数，则编译器会自动生成默认析构函数
4.对象生命周期结束时，编译器会自动调用析构函数

#include<iostream>
using namespace std;
class Date
{
public:
	Date()
	{
		_year = 2024;
		_month = 4;
		_day = 14;
	}
	~Date()
	{
		_year = 0;
		_month = 0;
		_day = 0;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1;
	return 0;
}

5.编译器生成的默认析构函数和默认构造函数一样，对于自定义类型，编译器都会自动调用对应的默认析构函数
6.如果类中没有申请资源时，析构函数可以不写，但如果有申请时，就必须写析构函数，否则就会造成内存泄露

拷贝构造

概念

只有单个形参，编译器在创建新对象的时候会自动调用，这个形参必须是和新生成对象一样的类型

特点

1.拷贝构造是构造函数的一个重载函数
2.在调用拷贝构造创建新变量的时候，必须使用引用，否则会引发无穷递归调用，因为函数在传参的时候会调用拷贝构造创建形参，所以会无穷尽递归
3.若未显式定义，编译器会生成默认拷贝函数，默认构造函数会按内存储存字节进行字节序拷贝，这种拷贝称为浅拷贝/值拷贝，这种方式有一个缺点，比如说当你初始化一个字符串s1，然后初始化一个s2，如果你执行s1=s2这个操作，那当你改变s1里元素的时候，s2里元素也会跟着改变，这还有一个问题，因为类是有析构函数的，当你程序结束的时候，这个位置会被析构两次，程序就崩了
4.编译器自动生成的默认拷贝构造函数中，内置类型是使用字节拷贝构造的，而自定义类型是调用自定义类型的拷贝构造函数进行拷贝

//拷贝构造
string(const string& str)
	:_size(strlen(str._str))
	,_str(new char[1])
{
	delete[] _str;
	_capacity = _size;
	char* tmp = new char[_capacity + 1];
	strcpy(tmp, str._str);
	_str = tmp;
}

若没有这个自定义函数，两个不同对象的_str会指向同一块空间，动其中一个对象就会影响到另外一个对象。
5.关于什么时候需要写拷贝构造：如果涉及到资源的申请就需要写拷贝构造函数进行深拷贝，否则只需要用编译器自动生成的浅拷贝即可。

应用场景

1.使用已创建对象初始化新对象

string str1;//旧对象
string str2(str1);

2.函数参数类型为类类型对象

void Func(string str);//会调用拷贝构造

3.函数返回值类型为类类型对象

string func()
{
	string str;
	return str;
}

注：为了提高传参效率，能传引用就尽量不要用传值调用。

运算符重载

特点

用法

函数名字：operator后接需要重载的运算符符号
函数原型：返回值 operator 需要重载的运算符符号（参数列表）
下图用日期类Date作为例子

ostream& operator<<(ostream& out，Date& d1)
{
	out<<d1.year<<d1.month<<d1.day<<endl;
	return out;
}

注意

1.重载操作数必须有一个类类型参数
2.内置类型的运算符不能改变其含义，比如说内置类型的加减乘除，不能通过运算符重载改变它们的含义
3.作为类类型成员重载时，参数少1，有一个参数是隐藏的this指针
4.“*”“::”“sizeof”“?:”“.”这五个运算符不能重载
5.赋值运算符必须重载为类的函数，不能放在全局变量里

Date& operator=(Date& d1,Date& d2)
{
	if(&d1!=&d2)
	{
		d1.year=d2.year;
		d1.month=d2.month;
		d1.day=d2.day;
	}
	return d1;
}

若你去测试这一行代码，你会发现vs编译器底下会报一个错： error C2801: “operator =”必须是非静态成员，原因是用户如果在类中没有显式实现一个赋值运算符重载，编译器会默认生成一个浅拷贝赋值运算符重载，这时如果用户在类外又实现一个运算符重载，就会与编译器中默认生成的函数冲突，所以赋值运算符只能是类内的函数。
6.如果没有涉及到资源拷贝，那么赋值运算符实现和不实现都可以，但一旦涉及到资源申请，就必须实现赋值运算符重载，否则会导致某一些指针指向同一块空间，这个时候当你操作其中一个对象就会影响到另外一个对象，而且有析构两次的问题（一个类里面的成员有包含别的类，没有进行深拷贝就会析构两次，造成程序崩溃）
7.前置++，–与后置++，–的问题：因为前置++和后置++运算符都一样，只是使用的位置不一样，为了区分这两种，c++规定前置++可以和平常的运算符重载一样使用，而若要实现后置++的运算符重载，就需要在参数列表里加一个int

Date operator++();//前置++
Date operator++(int)//后置++

const成员

概念

const修饰的成员函数统称为const成员函数，const修饰成员函数，实际上是修饰该成员函数的隐藏this指针，表明在该成员函数中不能对类的任何成员进行修改

class Date
{
public:
	void Print() const//等价于 void Print(const Date* this)
	{
		cout<<_year<<"-"<<_month<<"-"<<_day<<endl;
	}
private:
	int _year;
	int _month;
	int _day;
}

特点

const成员函数可以调用const成员函数，但不能调用非const成员函数（读写权限被放大），而非const成员函数可以调用const成员函数和非const成员函数
const对象不能调用非const成员函数（读写权限放大），而非const对象两种都可以调用。

取地址运算符重载

一般不自己实现，编译器会自动实现，下图是日期类的一部分

Date* operator&()
{
	return this;
}
const Date* operator&() const
{
	return this;
}