一、拷贝构造

拷贝构造函数的特征：

1、拷贝构造函数是构造函数的一个重载形式；

2、拷贝构造函数的参数只有一个且必须是同类类型对象的引用，使用传值方式编译器直接报错，因为会引发无穷递归调用。

在c++中自定义类型传值传参的时候要调用拷贝构造函数。

3、若未显式定义，编译器会生成默认的拷贝构造函数。默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。

默认拷贝构造对内置类型进行值拷贝（浅拷贝），对自定义类型调用它的拷贝构造。

class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1)
		:_year(year)
		,_month(month)
		,_day(day)
	{}
	//拷贝构造
	Date(const Date& d)
	{
		_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(2023, 7, 27);
	Date d2(d1);//拷贝构造
	d1.Print();
	d2.Print();

	return 0;
}

运行结果：

对于上述Date类，拷贝构造是直接赋值给另一个对象，但是对于Stack类，如果也是直接赋值拷贝，那么将会导致问题。

所以：类中如果没有涉及资源申请时，拷贝构造函数是否写都可以；一旦涉及到资源申请
时，则拷贝构造函数是一定要写的，否则就是浅拷贝。

拷贝构造函数调用场景：

使用已存在对象创建新对象；
函数参数类型为类类型对象；
函数返回值类型为类类型对象；

二、赋值运算符重载

C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其
返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。
函数名字为：关键字operator后面接需要重载的运算符符号。
函数原型：返回值类型 operator操作符(参数列表)

注意事项：

不能通过连接其他符号来创建新的操作符：比如operator@
重载操作符必须有一个类类型参数
用于内置类型的运算符，其含义不能改变，例如：内置的整型+，不能改变其含义
作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐
藏的this
这 .* sizeof :: ?: . 5个运算符不能重载
不能改变操作符的操作数的个数

class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1)
		:_year(year)
		,_month(month)
		,_day(day)
	{}
	
	void Print()
	{
		cout << _year << "/" << _month << "/" << _day << endl;

	}

	Date& operator=(const Date& d)
	{
		if (this != &d)
		{
			_year = d._year;
			_month = d._month;
			_day = d._day;
		}
		return *this;
	}

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

int main()
{
	Date d1(2023, 7, 27);

	Date d3;
	d3 = d1;//赋值
	d3.Print();

	return 0;
}

1、赋值运算符重载格式：

参数类型：const T&，传递引用可以提高传参效率
返回值类型：T&，返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值
检测是否自己给自己赋值
返回*this ：要复合连续赋值的含义

2、赋值运算符只能重载成类的成员函数不能重载成全局函数，原因是赋值运算符如果不显式现，编译器会生成一个默认的。此时用户再在类外自己实现一个全局的赋值运算符重载，就和编译器在类中生成的默认赋值运算符重载冲突了，故赋值运算符重载只能是类的成员函数。

3、用户没有显式实现时，编译器会生成一个默认赋值运算符重载，以值的方式逐字节拷贝。注意：内置类型成员变量是直接赋值的，而自定义类型成员变量需要调用对应类的赋值运算符重载完成赋值。

注意：如果类中未涉及到资源管理，赋值运算符是否实现都可以；一旦涉及到资源管理则必须要实现。

三、const成员

四、取地址及const取地址操作符重载

//这两个默认成员函数一般不用重新定义，编译器会自动生成
class Date
{
public :
    Date* operator&()
    {
        return this ;
    }

    const Date* operator&()const
    {
        return this ;
    }
private :
    int _year ;
    int _month ;
    int _day ; 
};

五、初始化列表

构造函数初始化两种方式：1、函数体内赋值 2、初始化列表

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

class Date
{
public:
	//初始化列表
	Date(int year = 1, int month = 1, int day = 1)
		:_year(year)
		,_month(month)
		,_day(day)
	{}
private:
	int _year; 
	int _month; 
	int _day; 
};

注意：

1、每个成员变量在初始化列表中最多只能出现一次；

2、类中包含引用成员变量、const成员变量、自定义类型成员(且没有默认构造函数)时，必须放在初始化列表位置进行初始化；

3、尽量使用初始化列表初始化，因为不管你是否使用初始化列表，对于自定义类型成员变量，一定会先使用初始化列表初始化。

4、成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关。

六、explicit关键字

构造函数不仅可以构造与初始化对象，对于单个参数或者除第一个参数无默认值其余均有默认值
的构造函数，还具有类型转换的作用。

class A
{
public:
	//explicit修饰构造函数，将会禁止构造函数的隐式转换
	explicit A(int a)
		:_a(a)
	{}

private:
	int _a;
};

int main()
{
	A a2 = 2;//隐式类型转换，整型转换成自定义类型
	//2构造一个A的临时对象，临时对象再拷贝构造a2 ----->  优化成用2直接构造
	return 0;
}

用explicit修饰构造函数，将会禁止构造函数的隐式转换。

七、static成员

声明为static的类成员称为类的静态成员，用static修饰的成员变量，称之为静态成员变量；用
static修饰的成员函数，称之为静态成员函数。静态成员变量一定要在类外进行初始化。

计算程序中创建了多少个对象：

class A
{
public:
	A()
	{
		++_scount;
	}
	A(const A& a)
	{
		++_scount;
	}
	~A()
	{
		--_scount;
	}

	//static修饰的静态成员函数，没有this指针，指定类域和访问限定符就可以访问
	//静态的不需要对象，突破类域就可以访问
	static int GetACount()
	{
		return _scount;
	}
private:
    //静态成员变量，属于类的每个对象贡享，存储在静态区
	static int _scount;	//声明
};

//静态成员变量，必须再类外初始化
int A::_scount = 0;


int main()
{
	cout << A::GetACount() << endl;//0

	A aa1;
	A aa2;
	cout << A::GetACount() << endl;//2

	A aa3(aa1);
	cout << A::GetACount() << endl;//3

	return 0;
}

注意：

1、静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区；
2、静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明；
3、类静态成员即可用 类名::静态成员或者对象.静态成员 来访问；
4、静态成员函数没有隐藏的this指针，不能访问任何非静态成员；
5、静态成员也是类的成员，受public、protected、private 访问限定符的限制；

八、友元

现在尝试去重载operator<<，然后发现没办法将operator<<重载成成员函数。因为cout的输出流对象和隐含的this指针在抢占第一个参数的位置。this指针默认是第一个参数也就是左操作数了。但是实际使用中cout需要是第一个形参对象，才能正常使用。所以要将operator<<重载成全局函数。但又会导致类外没办法访问成员，此时就需要友元来解决。operator>>同理。

class Date
{
public:

	Date(int year = 1, int month = 1, int day = 1)
		:_year(year)
		,_month(month)
		,_day(day)
	{
	}

	friend ostream& operator<<(ostream& out, const Date& d);
	friend istream& operator>>(istream& in, Date& d);

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

ostream& operator<<(ostream& out, const Date& d)
{
	out << d._year << "/" << d._month << "/" << d._month << endl;
	return out;
}

istream& operator>>(istream& in, Date& d)
{
	in >> d._year >> d._month >> d._day;
	return in;
}

int main()
{
	Date d1;
	//cout << d1;//流插入重载
	cin >> d1;
	cout << d1;

	return 0;
}

注意：

1、友元函数可访问类的私有和保护成员，但不是类的成员函数
2、友元函数不能用const修饰
3、友元函数可以在类定义的任何地方声明，不受类访问限定符限制
4、一个函数可以是多个类的友元函数
5、友元函数的调用与普通函数的调用原理相同

九、内部类

内部类：如果一个类定义在另一个类的内部，这个内部类就叫做内部类。内部类是一个独立的类，
它不属于外部类，更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越
的访问权限。
注意：内部类就是外部类的友元类，参见友元类的定义，内部类可以通过外部类的对象参数来访
问外部类中的所有成员。但是外部类不是内部类的友元。

特性：
1. 内部类可以定义在外部类的public、protected、private都是可以的。
2. 注意内部类可以直接访问外部类中的static成员，不需要外部类的对象/类名。
3. sizeof(外部类)=外部类，和内部类没有任何关系