史上最全类和对象 ，只要你认真看完C++类和对象，分分钟钟都吊打面试官【 C++】

基础篇

面向过程和面向对象

C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。
C++是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。
比如一个创建一个外卖系统
对于面向过程来说，我们关注的是下单、接单、送餐三个过程
而对于面向对象，我们关注的是客户、商家、骑手，三个类对象之间的关系

类的引入

之前C语言，结构体中只能定义变量，但在C++中，结构体内不仅可以定义变量，还可以定义函数

struct Test
{
    //成员函数
	int Add(int x, int y)
	{
		return x + y;
	}
	//成员变量
	int a;
	double b;
	
};

但上面结构体的定义，在C++中更喜欢用class来代替。

class Test
{
    //成员函数
	int Add(int x, int y)
	{
		return x + y;
	}
	//成员变量
	int a;
	double b;
	
};

#include<iostream>
//类域
struct Queue
{
	//成员函数 
	void Init()
	{

	}
};
struct Stack
{
	//成员函数 
	void Init(int defaultcapacity =4)
	{
		a = (int * )malloc(sizeof(int)*capacity);
		if (a == nullptr)
		{
			printf("malloc fail");
			exit(-1);
		}
		capacity = defaultcapacity;
		top = 0;
	}
	void Push(int x)
	{
		a[top++] = x;
	}
	void Destory()
	{
		free(a);
		a = nullptr;
		top = capacity;
	}
	//成员变量 
	//类域是一个整体 ，写在成员函数前面或者后面都行 
	int* a;
	int top;
	int capacity;
};
int main()
{
	struct Stack st1;
	st1.Init();
	Stack st2;//cpp的类
	st2.Init();
	st2.Push(1);
	st2.Push(2);
	st2.Push(3);
	st2.Push(4);
	st2.Destory();
	return 0;
}

类的定义

class className
{
// 类体：由成员函数和成员变量组成
}; // 一定要注意后面的分号

class为定义类的关键字，ClassName为类的名字，{}中为类的主体，注意类定义结束时后面分号不能省略。类体中内容称为类的成员：类中的变量称为类的属性或成员变量; 类中的函数称为类的方法或者成员函数

类的两种定义方式：

1. 声明和定义全部放在类体中，需注意：成员函数如果在类中定义，编译器可能会将其当成内联函数处理。

class  Stack
{
public :
	//成员函数 
	//类里面定义的函数默认就是inline 
	//一般长的函数声明和定义分离，短的函数直接定义的类里面
	void Init(int defaultcapacity = 4)
	{
		a = (int*)malloc(sizeof(int) * capacity);
		if (a == nullptr)
		{
			printf("malloc fail");
			exit(-1);
		}
		capacity = defaultcapacity;
		top = 0;
	}
	void Push(int x)
	{
		a[top++] = x;
	}

	void Destory()
	{
		free(a);
		a = nullptr;
		top = capacity;
	}
private:
	//成员变量 
	//类域是一个整体 ，写在成员函数前面或者后面都行 
	int* a;
	int top;
	int capacity;


};

2. 类声明放在.h文件中，成员函数定义放在.cpp文件中，注意：成员函数名前需要加类名::

Func.h

#include<iostream>

using namespace std;

class  Stack
{

public:

	//成员函数 
	void Init(int defaultcapacity = 4);
	void Push(int x);
	void Destory();
private:
	//成员变量 
	//类域是一个整体 ，写在成员函数前面或者后面都行 
	int* a;
	int top;
	int capacity;
};

Func.cpp

#include"Func.h"

//指定类域
void Stack::Init(int defaultcapacity = 4)
{
	a = (int*)malloc(sizeof(int) * capacity);
	if (a == nullptr)
	{
		printf("malloc fail");
		exit(-1);
	}
	capacity = defaultcapacity;
	top = 0;
}

void Stack::Push(int x)
{
	a[top++] = x;
}

void Stack::Destory()
{
	free(a);
	a = nullptr;
	top = capacity;
}

一般情况下，采用第二种方式。
成员变量命名规则的建议:

class Data
{
public :
	//成员函数
	void Init(int year)
	{
		_year = year;
	}
private:
	//成员变量 
	int _year;
	int _month;
	int day;
};

类的访问限定符

C++实现封装的方式：用类将对象的属性和方法结合在一块，让对象更加完善，通过访问权限，选择性的将其接口提供给外部的用户使用

访问限定符说明：

1. public修饰的成员在类外可以直接被访问
2. protected和private修饰的成员在类外不能直接被访问(此处protected和private是类似的)
3. 访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现时为止
4. 如果后面没有访问限定符，作用域就到 } 即类结束。
5. class的默认访问权限为private，struct为public(因为struct要兼容C)

注意：访问限定符只在编译时有用，当数据映射到内存后，没有任何访问限定符上的区别

那C++中struct和class的区别是什么？

C++需要兼容C语言，所以C++中struct可以当成结构体去使用。另外C++中struct还可以用来定义类。和class是定义类是一样的，区别是struct的成员默认访问方式是public，class是的成员默认访问方式是private。

类的封装

封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互

在C++语言中实现封装，可以通过类将数据以及操作数据的方法进行有机结合，通过访问权限来隐藏对象内部实现细节，控制哪些方法可以在类外部直接被使用,也就是说我们使用类将数据和方法都封装起来。不想对外开放的就用 protected/private 封装起来，用 public 封装的成员允许外界对其进行合理的访问。所以封装本质上是一种管理

类的作用域

类定义了一个新的作用域，类的所有成员都在类的作用域中。在类体外定义成员时，需要使用 :: 作用域操作符指明成员属于哪个类域

局部域和全局域会影响生命周期 ，类域和命名空间域不会影响生命周期

类的实例化

用类类型创建对象的过程，称为类的实例化

1 类是对对象进行描述的,类只是一个模型一样的东西，限定了类有哪些成员，定义出一个类并没有分配实际的内存空间来存储它

就像C语言中定义了一个结构体一样，当你还未用该自定义类型创建变量时，定义结构体类型这个过程并没有分配实际的内存空间来存储它。

2 一个类可以实例化出多个对象，实例化出的对象 占用实际的物理空间，存储类成员变量

就像C语言中定义了一个结构体，然后用该自定义类型创建了一个变量，那么这个变量将占用实际的物理空间来存储其成员变量

3 类实例化出对象就像现实中使用建筑设计图建造出房子，类就像是设计图，只设计出需要什么东西，但是并没有实体的建筑存在，同样类也只是一个设计，实例化出的对象才能实际存储数据，占用物理空间

类对象模型

如何计算类对象的大小

class A
{
public:
	void PrintA()
	{
		cout << _a << endl;
	}
private:
	char _a;
};

类中既可以有成员变量，又可以有成员函数，那么一个类的对象中包含了什么？如何计算一个类的大小？

class Person
{
public:
	//显示基本信息
	void ShowInfo()
	{
		cout << _name << "-" << _sex << "-" << _age << endl;
	}
public:
	char* _name;  //姓名
	char* _sex;   //性别
	int _age;     //年龄
};

类对象的存储方式猜测

对象中包含类的各个成员

缺陷：每个对象中成员变量是不同的，但是调用同一份函数，如果按照此种方式存储，当一个类创建多个对象时，每个对象中都会保存一份代码，相同代码保存多次，浪费空间。那么如何解决呢？

代码只保存一份，在对象中保存存放代码的地址

只保存成员变量，成员函数存放在公共的代码段

对于上述几种存储方式，计算机是按照哪种方式来存储的，我们可以通过对下面的不同对象分别获取大小来进行分析：

我们再通过对下面的不同对象分别获取大小来分析看下

// 类中既有成员变量，又有成员函数
class A1 
{
public:
	//成员函数
	void f1() 
	{

	}
private:
	//成员变量 
	int _a;
};
// 类中仅有成员函数
class A2 
{
public:
	//成员函数 
	void f2() 
	{

	}
};
// 类中什么都没有---空类
//没有成员变量的类对象 ，需要1byte，是为了占位，表示对象存在 
//但是不存储有效数据
class A3
{

};
int main()
{
//对象中只存储了成员变量，没有存储成员函数 
	cout << sizeof(A1) << endl;//4
	cout << sizeof(A2) << endl;//1
	cout << sizeof(A3) << endl;//1

	return 0;
}

通过单目操作符sizeof来获取这三个对象的大小，结果A1的大小为4个字节，A2的大小为1个字节，A3的大小也为1个字节

结论：一个类的大小，实际就是该类中”成员变量”之和，当然要注意内存对齐
注意空类的大小，空类比较特殊，编译器给了空类一个字节来唯一标识这个类的对象

如果不清楚结构体内存对齐的请点击这里

this指针

#include<iostream>
using namespace std;
class Date
{
public:
	void Init(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
	//编译器对成员函数的处理 
	//void Print(Date* const this )
	//{
	//	cout << this->_year << "-" << this->_month << "-" << this->_day << endl;
	//}
private:
	int _year; // 年 声明 
	int _month; // 月
	int _day; // 日
	int a;
};
int main()
{
	Date d1, d2;
	d1.Init(2023, 5, 11);
	d2.Init(2023, 5, 11);
	d1.Print();
	//编译器的处理 
	//d1.Print(&d1);
	//d2.Print(&d2);

	d2.Print();
	return 0;
}

Date类中有 Init 与 Print 两个成员函数，函数体中没有关于不同对象的区分，那当d1调用 Init 函数时，该函数是如何知道应该设置d1对象，而不是设置d2对象呢？
C++中通过引入this指针解决该问题，即：C++编译器给每个“非静态的成员函数“增加了一个隐藏的指针参数，让该指针指向当前对象(函数运行时调用该函数的对象)，在函数体中所有“成员变量”的操作，都是通过该指针去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成

this不能在形参和实参显示传递，但是可以在函数内部显示使用

using namespace std;
class Date
{
public:
	void Init(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << this << endl;
		cout << this->_year << "-" << _month << "-" << _day << endl;
	}
	//编译器对成员函数的处理 
	//void Print(Date* const this )
	//{
	//	cout << this->_year << "-" << this->_month << "-" << this->_day << endl;
	//}
private:
	int _year; // 年  声明
	int _month; // 月
	int _day; // 日
	int a;
};
int main()
{
	Date d1, d2;
	d1.Init(2022, 1, 11);
	d2.Init(2022, 1, 12);
	d1.Print();
	//编译器的处理 
	//d1.Print(&d1);
	//d2.Print(&d2);

	d2.Print();
	return 0;
}

this指针的特性

1. this指针的类型：类的类型* const，即成员函数中，不能给this指针赋值。

2. 只能在“成员函数”的内部使用

3. this指针本质上是“成员函数”的形参，当对象调用成员函数时，将对象地址作为实参传递给this形参。所以对象中不存储this指针。

那this指针存在哪里?

this是形参，所以this指针是跟普通参数一样存在函数调用的栈帧里面。

5. this指针是“成员函数”第一个隐含的指针形参，一般情况由编译器通过ecx寄存器自动传递，不需要用户传递

vS下面对this指针传递，进行优化，对象地址是放在ecx，ecx存储this指针的值

this指针可以为空吗?

通过下面这段代码更深入的理解this指针

class A
{
public:

	void Print()//this指针是空的，但是函数内没有对this指针解引用
	{
		cout << "Print()" << endl;
	}
	//编译器对成员函数的处理 
	//	void Print(A * const this)//this指针是空的，但是函数内没有对this指针解引用
	//{
	//	cout << "Print()" << endl;
	//}
private:

	int _a;
};

int main()
{
	A* p = nullptr;
	p->Print();//并且p调用Print，不会发生解引用，因为Print的地址不在对象中，Print的地址在公共代码段。但是p会作为实参传递给this指针，p是一个nullptr ，传递一个nullptr并不会报错
	return 0;
}

this指针是空的，但是函数内没有对this指针解引用
并且p调用Print，不会发生解引用，因为Print的地址不在对象中，Print的地址在公共代码段。但是p会作为实参传递给this指针，p是一个nullptr ，传递一个nullptr并不会报错 。

class A
{
public:
	void PrintA()
	{
		cout << _a << endl;//this指针是空的，但是函数内访问_a，本质是this->_a
	}
	//编译器对成员函数的处理 
	//	void PrintA(A * const this )
	//{
	//	cout << this->_a << endl;//this指针是空的，但是函数内访问_a，本质是this->_a
	//}
private:
	int _a;
};
int main()
{
	A* p = nullptr;
	p->PrintA();
	return 0;
}

this指针是空的，但是函数内访问_a，本质是this->_a
并且p调用Print，不会发生解引用，因为Print的地址不在对象中。p会作为实参传递给this指针。

提高篇

类的6个默认成员函数

如果一个类中什么成员都没有，我们简称其为空类。但是空类中真的什么都没有吗？其实不然，任何一个类，即使我们什么都不写，类中也会自动生成6个默认成员函数。

class Date 
{

}; //空类

构造函数

构造函数：名字与类名相同,创建类类型对象时由编译器自动调用，保证每个数据成员都有 一个合适的初始值，并且在对象的生命周期内只调用一次。

例如，以下日期类中的成员函数Date就是一个构造函数。当你用该日期类创建一个对象时，编译器会自动调用该构造函数对新创建的变量进行初始化

特性

构造函数是特殊的成员函数，需要注意的是，构造函数虽然名称叫构造，但是构造函数的主要任务并不是开空间创建对象，而是初始化对象

其特征如下：

1. 构造函数函数名与类名相同。

2. 构造函数无返回值。
   无返回值并不是返回值是void ，是函数没有返回值

3. 对象实例化时编译器自动调用对应的构造函数。

class Stack
{
public:
	//构造函数 ：初始化 
	Stack(  int capacity =4 )
	{
		printf("Stack(  int capacity =4 )");
		_array = (int*)malloc(sizeof(int) * capacity);
		if (_array == NULL)
		{
			printf("malloc fail");
			exit(-1);
		}
		_capacity = capacity;
		_size = 0;

	}
	void Push(int x)
	{
		_array[_size++] = x;
	}
	//析构函数 ： 完成对象中资源的清理工作
	~Stack( )
	{
		printf("~Stack( )");
		if (_array)
		{
			free(_array);
			_array = nullptr;
			_size = 0;
			_capacity = 0;
		}
   }

private:
	int* _array;
	int _capacity;
	int _size;

};
int main()
{
	Stack s;
	s.Push(1);
	s.Push(2);
	s.Push(3);

	return 0;
}

4. 构造函数可以重载

构造函数支持函数重载

class Stack
{
public:
	//函数重载 
	Stack(int* a, int n)
	{
		cout << "Stack(int* a, int n)" << endl;
		_array = (int*)malloc(sizeof(int) * n);
		if (_array == NULL)
		{
			printf("malloc fail");
			exit(-1);
		}
		memcpy(_array, a, sizeof(int) * n);
		_capacity = n;
		_size = n;

	}
	//构造函数 ：初始化 
	Stack(int capacity = 4)
	{
		printf("Stack(  int capacity =4 )");
		_array = (int*)malloc(sizeof(int) * capacity);
		if (_array == NULL)
		{
			printf("malloc fail");
			exit(-1);
		}
		_capacity = capacity;
		_size = 0;

	}
	void Push(int x)
	{
		_array[_size++] = x;
	}
	//析构函数 ： 完成对象中资源的清理工作
	~Stack()
	{
		printf("~Stack( )");
		if (_array)
		{
			free(_array);
			_array = nullptr;
			_size = 0;
			_capacity = 0;
		}
	}

private:
	int* _array;
	int _capacity;
	int _size;

};
int main()
{
	Stack s;
	s.Push(1);
	s.Push(2);
	s.Push(3);

	return 0;
}

5 关于编译器自动生成的析构函数，是否会完成一些事情呢？下面的程序我们会看到，编译器生成的默认析构函数，对自定类型成员调用它的析构函数

class Date
{
public:
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1;
	Date d2;
	d1.Print();
	return 0;
}

补充：内置类型/基本类型 （语言本身定义的基础类型 ）
比如 int/char /double /任何类型的指针等
自定义类型 ，用struct /class 等等定义的类型

如果我们不写构造函数 ，编译器会默认生成构造函数 ，内置类型不做处理（有些编译器会处理，那是编译器的个性化行为，c++并没有处理 ） ，自定义类型会去调用他的默认构造函数

一般情况下 ，有内置类型成员的 ，就需要自己写构造函数，不能用编译器自己写的，因为绝大多数编译器对内置类型不做处理

如果全部都是自定义类型成员，可以考虑让编译器自己生成

C++11的标准发布的时候，打了个补丁，在成员声明的可以给缺省值

class Stack
{

};
class Date
{
public:
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	//内置类型
	//c++11支持 ，这里不是初始化 ，这里是声明，并没有开空间 
	//这里是给的默认缺省值，是给编译器生成的默认构造函数用的
	int _year = 1;
	int _month = 1;
	int _day = 1;
	//自定义类型 
	//Stack _st;
};
int main()
{
	Date d1;
	Date d2;
	d1.Print();
	return 0;
}

6. 如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成

编译器自动生成的构造函数机制：
 1、编译器自动生成的构造函数对内置类型不做处理。
 2、对于自定义类型，编译器会再去调用它们自己的默认构造函数。

虽然在我们不写的情况下，编译器会自动生成构造函数，但是编译器自动生成的构造函数可能达不到我们想要的效果，所以大多数情况下都需要我们自己写构造函数

构造函数的调用

class Date
{
public:
	//构造函数支持函数重载 
	Date()
	{
		_year = 1;
	   _month = 1;
	   _day = 1;
	}
	 Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	//内置类型
	//c++11支持 ，这里不是初始化 ，这里是声明，并没有开空间 
	//这里是给的默认缺省值，是给编译器生成的默认构造函数用的
	int _year = 1;
	int _month = 1;
	int _day = 1;
	//自定义类型 
	//Stack _st;
};


int main()
{

	//构造函数的调用跟普通函数也不一样
	Date d1;
	//Date d1(); ,是错的
	Date d2(2023,5,12);
	Date d3(2023);
	d2.Print();
	d3.Print();

	return 0;
}

默认构造函数

以下3种都叫做默认构造函数：
1、我们不写，编译器自动生成的构造函数。
 2、我们自己写的无参的构造函数。
 3、我们自己写的全缺省的构造函数。
总而言之，无需传参就可以调用的构造函数就是默认构造函数

无参的构造函数和全缺省的构造函数，我们没写编译器默认生成的构造函数，都可以认为是默认构造函数，但是这三个有且只能出现一个
也就是说不传参就可以调用的就是默认构造函数

如果无参构造函数和全缺省构造函数同时存在 ，会发生什么？

构造函数给全缺省值 ，和构造函数不传参 ，放在一起，虽然满足函数重载，但是无参调用会有歧义 ，一般选择使用构造函数给全缺省值

析构函数

与构造函数功能相反，析构函数负责完成对象的销毁，对象在销毁时会自动调用析构函数，完成类的一些资源清理工作

析构函数的特性

1析构函数的函数名是在类名前加上字符‘~’

class Date
{
public:
	Date()// 构造函数
	{
	
	}
	~Date()// 析构函数
	{
	
	}
private:
	int _year;
	int _month;
	int _day;
};

2析构函数无参数，无返回值

无返回值并不是返回值是void ，是函数没有返回值

3一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。注意：析构函数不能重载

编译器自动生成的析构函数机制:

1、编译器自动生成的析构函数对内置类型不做处理。
2、对于自定义类型，编译器会再去调用它们自己的默认析构函数。

4对象生命周期结束时，C++编译器会自动调用析构函数

以前C语言销毁经常忘记，会导致内存泄露 ，现在有了析构函数就大大降低了C语言中空间忘记释放问题的发生
5一个类有且只有一个析构函数。若未显示定义系统会自动生成默认的析构函数

6、先构造的后析构，后构造的先析构

对象是定义在函数中的，函数调用会建立栈帧，栈帧中的对象构造和析构也要符合先进后出的原则

**总结：
1、一般情况下，有动态申请资源，就需要显示写析构函数释放资源

2、没有动态申请的资源，不需要写析构

3、需要释放资源的成员都是自定义类型，不需要写析构

拷贝构造函数

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

拷贝构造函数的特性

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

因为拷贝构造函数的函数名也与类名相同。

2、拷贝构造函数的参数只有一个且必须使用引用传参，使用传值方式会引发无穷递归调用

先看一段代码：

#include<iostream>
using namespace std;

class Date
{
public:
	//构造函数 
	Date(int year = 2023 ,int month = 5,int day =12)
	 {
		_year = year;
		_month = month;
		_day = day;
	 }
	//拷贝构造函数
    Date ( Date d)//err
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;

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

};

int main()
{
	Date d1;
	Date d2(d1);//用已存在的对象d1创建对象d2

	return 0;
}

要调用拷贝构造函数就需要先传参，若传参使用传值传参，那么在传参过程中又需要进行对象的拷贝构造，如此循环往复，最终引发无穷递归调用。

C++规定:
内置类型直接拷贝
自定义类型必须调用拷贝构造完成拷贝

要调用拷贝构造函数就需要先传参，若传参使用传值传参，那么在传参过程中又需要进行对象的拷贝构造，如此循环往复，最终引发无穷递归调用。

为了解决上述问题， 我们采用引用的形式 ，引用从语法的角度上不开辟空间 ，d就是d1的别名

#include<iostream>
using namespace std;

class Date
{
public:
	//构造函数 
	Date(int year = 2023 ,int month = 5,int day =12)
	 {
		_year = year;
		_month = month;
		_day = day;
	 }
	//拷贝构造函数
    Date ( const Date & d)//引用
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;

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

};

int main()
{
	Date d1;
	Date d2(d1);//用已存在的对象d1创建对象d2

	return 0;
}

内置类型拷贝和自定义类型拷贝

内置类型拷贝

void func(int i)
{

}
void func(Date d)
{

}
int main()
{
	func(10);//C++内置类型直接拷贝
	func(d1);//C++内置类型直接拷贝
	return 0;
}

自定义类型调用拷贝构造完成拷贝

#include<iostream>
using namespace std;

class Date
{
public:
	//构造函数 
	Date(int year = 2023 ,int month = 5,int day =12)
	 {
		_year = year;
		_month = month;
		_day = day;
	 }
	//拷贝构造函数
    Date (const Date &d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;

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

};

int main()
{
	Date d1;
	Date d2(d1);//用已存在的对象d1创建对象d2

	return 0;
}

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

编译器自动生成的拷贝构造函数机制：
 1、编译器自动生成的拷贝构造函数对内置类型会完成浅拷贝（值拷贝）
 2、对于自定义类型，编译器会再去调用它们自己的默认拷贝构造函数

#include<iostream>
using namespace std;

class Date
{
public:
	//构造函数 
	Date(int year = 2023 ,int month = 5,int day =12)
	 {
		_year = year;
		_month = month;
		_day = day;
	 }
private:
	int _year;
	int _month;
	int _day;

};

int main()
{
	Date d1(2023,5,12);
	Date d2(d1);//用已存在的对象d1创建对象d2，我们不写，编译器会生成默认的拷贝构造函数
	return 0;
}

上述代码中，我们自己并没有写拷贝构造函数，但是编译器自动生成的拷贝构造函数还是完成了对象的拷贝构造

那么这里就会出现一个问题？
是不是所有的我们都可以不写拷贝构造函数，用编译器自动生成的拷贝构造函数
请看下面的代码

class Stack
{
public:
   //构造函数 
	Stack(int capacity = 4)
	{
		cout << "Stack()" << endl;

		_a = (int*)malloc(sizeof(int) * capacity);
		if (nullptr == _a)
		{
			perror("malloc申请空间失败");
			return;
		}

		_capacity = capacity;
		_top = 0;
	}

	// st2(st1) ,拷贝构造函数 
	Stack(const Stack& st)
	{
		_a = (int*)malloc(sizeof(int) * st._capacity);
		if (nullptr == _a)
		{
			perror("malloc申请空间失败");
			return;
		}

		memcpy(_a, st._a, sizeof(int) * st._top);
		_top = st._top;
		_capacity = st._capacity;
	}
	//析构函数 
	~Stack()
	{
		cout << "~Stack()" << endl;
		free(_a);
		_a = nullptr;
		_capacity = _top = 0;
	}

private:
	int* _a = nullptr;
	int _top = 0;
	int _capacity;
};

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

	Date(const Date& d)
	{
		cout << "Date(Date& d)" << endl;
		this->_year = d._year;
		_month = d._month;
		_day = d._day;
	
	}
private:
	int _year;
	int _month;
	int _day;
};

class MyQueue
{
private:
    //自定义类型
	Stack _pushst;
	Stack _popst;
};
int main()
{


	// 可以不写，默认生成的拷贝构造就可以用
	Date d1(2023, 5, 12);
	Date d2(d1);


	// 必须自己实现，实现深拷贝
	Stack st1;
	Stack st2(st1);

	return 0;
}

上述代码的问题就是没写拷贝构造函数，用编译器自动生成的拷贝构造函数 ,上图中的st1的_a 和st2的_a指向同一块空间 ，编译器调用了析构函数，并且调用了2次 ，第一次调用析构函数就已经将_a所指向的空间进行销毁了，第二次调用析构函数 ，就造成了内存的非法访问

总结：

Date 函数不需要写拷贝构造函数 ，是因为编译器自动生成的拷贝构造函数对内置类型会完成浅拷贝（值拷贝）
MyQueue函数不需要写拷贝构造函数，是因为对于自定义类型，编译器会再去调用它们自己的默认拷贝构造函数
像Stack这样的类，浅拷贝会导致析构两次、程序崩溃等问题，需要我们自己写对应的拷贝构造函数

4、编译器自动生成的拷贝构造函数不能实现深拷贝

赋值运算符重载

C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，其目的就是让自定义类型可以像内置类型一样可以直接使用运算符进行操作。

函数名字为：关键字operator后面接需要重载的运算符符号。

函数原型：返回值类型 operator操作符(参数列表)

注意：

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

5、.* :: sizeof ?: . 注意以上5个运算符不能重载。这个经常在笔试选择题中出现

举个例子：

class Date
{
public :
	//构造函数 
	Date(int year =2023,int month =5,int day =13)
	{
		this->_year = year;
		this->_month = month;
		this->_day = day;
	}

	//拷贝构造 
	//用已存在的对象d1创建对象d2 
	Date( const Date & d)
	{
		this->_year = d._year;
		this->_month = d._month;
		this->_day = d._day;
	}
//private:
	int _year;
	int _month;
	int _day;
};
bool operator< (const Date & x1, const Date & x2)
{
	if (x1._year < x2._year)
	{
		return true;
	}
	else if (x1._year == x2._year && x1._month < x2._month)
	{
		return true;
	}
	else if (x1._year == x2._year && x1._month == x2._month && x1._month < x2._day)
	{
		return true;
	}
	else
	{
		return false;
	}
}
int main()
{
	Date d1(2023, 5, 12);
	Date d2(2023, 2, 12);
	cout << (d1 < d2) << endl;
	cout << ( operator< (d1,d2)) << endl;
	return 0;
}

我们将该运算符重载函数放在类外面，但是此时会出现一个问题：外部无法访问类中的成员变量，所以我们将类中的成员变量从private设置为public，这样外部就可以访问该类的成员变量了
并且在类外没有this指针，所以此时函数的形参必须显示的设置两个。

class Date
{
public:
	//构造函数 
	Date(int year = 2023, int month = 5, int day = 13)
	{
		this->_year = year;
		this->_month = month;
		this->_day = day;
	}

	//拷贝构造 
	//用已存在的对象d1创建对象d2 
	Date(const Date& d)
	{
		this->_year = d._year;
		this->_month = d._month;
		this->_day = d._day;
	}
	bool operator< (const Date& x)
	{
		if (_year < x._year)
		{
			return true;
		}
		else if (_year == x._year && _month < x._month)
		{
			return true;
		}
		else if (_year == x._year && _month == x._month && _month < x._day)
		{
			return true;
		}
		else
		{
			return false;
		}
	}
//	bool operator< (Date* const  this ，const Date& x)
//此时该函数的第一个形参默认为this指针。
	//{
	//	if (this->_year < x._year)
	//	{
	//		return true;
	//	}
	//	else if (this->_year == x._year && this->_month < x._month)
	//	{
	//		return true;
	//	}
	//	else if (this->_year == x._year && this->_month == x._month && this->_month < x._day)
	//	{
	//		return true;
	//	}
	//	else
	//	{
	//		return false;
	//	}
	//}
	private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1(2023, 5, 12);
	Date d2(2023, 2, 12);//是否要重载运算符，取决于运算符对这个类是否有意义
	d1 < d2;	//转换成d1.operator<(d2);

	return 0;
}

从汇编的角度看 d1 < d2和d1.operator<(d2)是一样的，但是我们平常写的是d1<d2

我们将该运算符重载函数作为类的一个成员函数，此时函数的形参还是设置两个,只不过该函数的第一个形参默认为this指针。

总结：

操作符是几个操作数，重载函数就有几个参数

运算符重载

运算符重载函数也具有自己的返回值类型，函数名字以及参数列表。其返回值类型和参数列表与普通函数类似。 运算符重载函数名为：关键字operator后面接需要重载的操作符符号

总结：
是否要重载运算符，取决于运算符对这个类是否有意义

赋值运算符重载

这里以重载 = 运算符作为例子：

class Date
{
public:
	//构造函数 
	Date(int year = 2021, int month = 1, int day = 4)
	{
		this->_year = year;
		this->_month = month;
		this->_day = day;
	}

	//拷贝构造 
	//用已存在的对象d1创建对象d2 
	Date(const Date& d)
	{
		cout<< "	Date(const Date& d)" << endl;
		this->_year = d._year;
		this->_month = d._month;
		this->_day = d._day;
	}
	//赋值运算符重载
	//d4 = d1
	// Date & operator= (Date* const this,  const Date & d ) 
   Date & operator= (const Date & d ) //出了对象this生命周期还在 
	{
		this->_year = d._year;
		this->_month = d._month;
		this->_day = d._day;

		return *this;  // 返回d4，this就是d4的地址 ，所以返回*this
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(2023, 5, 12);
	Date d2(2022, 2, 12);//是否要重载运算符，取决于运算符对这个类是否有意义
	d1 = d2;//已经存在的两个对象之间的复制拷贝 （运算符重载函数）

	/*Date d2(d1);*///用一个已经存在的对象初始化另一个对象（本质是一个构造函数 ）
	Date d5, d4;
	//d4 =d1 其实就是 d4.operator=(d1)
	d5 = d4 = d1;
	return 0;
}

一、重载赋值运算符有几点需要注意：

1、参数类型：const T&，传递引用可以提高传参效率

赋值运算符重载函数的第一个形参默认是this指针，第二个形参是我们赋值运算符的右操作数。
 由于是自定义类型传参，如果使用传值传参，会额外调用一次拷贝构造函数，所以函数的第二个参数最好使用引用传参（第一个参数是默认的this指针，我们管不了）。
 其次，第二个参数，即赋值运算符的右操作数，在函数体内不会对第二个参数进行修改，所以最好加上const

2、返回值类型：T&，返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值

实际上，我们若是只以d2 = d1这种方式使用赋值运算符，赋值运算符重载函数就没必要有返回值，因为在函数体内已经通过this指针对d2进行了修改。但是为了支持连续赋值，即d3 = d2 = d1，我们就需要为函数设置一个返回值了，而且很明显，返回值应该是赋值运算符的左操作数，即this指针指向的对象。

和使用引用传参一样，引用传参就是为了避免不必要的拷贝，如果此时出了函数作用域，this指针指向的对象并没有被销毁，此时最好使用引用返回，减少不必要的拷贝，提高效率

3、检测是否自己给自己赋值

若是出现d1 = d1，这种就不必进行赋值操作，所以在进行赋值操作前，最好先判断是否是给自己赋值

4、返回*this ：要复合连续赋值的含义

赋值操作进行完成时，我们应该返回赋值运算符的左操作数，但是在函数体内我们只能通过this指针访问到左操作数，所以要返回左操作数就只能返回*this

区分赋值运算符重载函数和拷贝构造函数

看到这里相信，你对拷贝构造函数和赋值运算符重载函数有比较清晰的了解
但是注意区分：拷贝构造函数和赋值运算符重载函数

拷贝构造函数：用一个已经存在的对象去构造初始化另一个即将创建的对象。
赋值运算符重载函数：在两个对象都已经存在的情况下，将一个对象赋值给另一个对象。

class Date
{
public:
	//构造函数 
	Date(int year = 2021, int month = 1, int day = 4)
	{
		this->_year = year;
		this->_month = month;
		this->_day = day;
	}

	//拷贝构造 
	//用已存在的对象d1创建对象d2 
	Date(const Date& d)
	{
		cout << "	Date(const Date& d)" << endl;
		this->_year = d._year;
		this->_month = d._month;
		this->_day = d._day;
	}
	//赋值运算符重载
	//d4 = d1
	Date& operator= (const Date& d) //出了对象this生命周期还在 
	{
		//d1 =d1 
		if (this != &d)
		{
			this->_year = d._year;
			this->_month = d._month;
			this->_day = d._day;
	  }
		 
		return *this;  //返回*this 这个对象的别名
	}


	//Date& operator= (Date * const  this ,const Date& d) //出了对象this生命周期还在 
	//{
	//	//d1 =d1 
	//	if (this != &d) //比较的是地址 ，&d是取地址,防止自己给自己赋值
	//	{
	//		this->_year = d._year;
	//		this->_month = d._month;
	//		this->_day = d._day;
	//	}

	//	return *this;  //返回*this 这个对象的别名
	//}
private:
	int _year;
	int _month;
	int _day;
};

	int main()	
	{
	d1 = d2;//已经存在的两个对象之间的复制拷贝 （运算符重载函数）
	Date d2(d1);//用一个已经存在的对象d1初始化另一个对象d2（本质是一个构造函数 ）
	Date d3 = d1;//调用的也是拷贝构造函数
	return 0 ;
	}	

二、赋值运算符只能重载成类的成员函数不能重载成全局函数
看下面代码 ：

class Date
 
{
 
public:
	Date(int year = 1900, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	int _year;
	int _month;
	int _day;
};
 
// 赋值运算符重载成全局函数，注意重载成全局函数时没有this指针了，需要给两个参数
 
Date& operator=(Date& left, const Date& right)
{
	if (&left != &right)
	{
		left._year = right._year;
		left._month = right._month;
		left._day = right._day;
	}
	return left;
}

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

三、用户没有显式实现时，编译器会生成一个默认赋值运算符重载，以值的方式逐字节拷贝

注意：内置类型成员变量是直接赋值的，而自定义类型成员变量需要调用对应类的赋值运算符重载完成赋值

也就是说默认生成赋值重载 跟拷贝构造行为一样:
1、编译器自动生成的 赋值重载函数 对内置类型会完成浅拷贝（值拷贝）
2、对于自定义类型，编译器会再去调用它们自己的 赋值重载函数

class Time
{
public:
	Time()
	{
		_hour = 1;
		_minute = 1;
		_second = 1;
	}
	Time& operator=(const Time& t)
	{
		if (this != &t)
		{
			_hour = t._hour;
			_minute = t._minute;
			_second = t._second;
		}
		return *this;
	}
private:
	int _hour;
	int _minute;
	int _second;
};
 
class Date
 
{
 
private:
	// 基本类型(内置类型)
 
	int _year = 1970;
	int _month = 1;
	int _day = 1;
	// 自定义类型
 
	Time _t;
};
 
int main()
{
	Date d1;
	Date d2;
	d1 = d2;
	return 0;
}

既然编译器生成的默认赋值运算符重载函数已经可以完成字节序的值拷贝了,像日期类这样的就不需要自己实现。
如果下面的类不写，去使用编译器生成的默认赋值运算符重载函数？

这里会发现下面的程序会崩溃掉，这里就需要我们以后学的深拷贝去解决。

typedef int DataType;
class Stack
{
public:
	Stack(size_t capacity = 10)
	{
		_array = (DataType*)malloc(capacity * sizeof(DataType));
		if (nullptr == _array)
		{
			perror("malloc申请空间失败");
			return;
		}
		_size = 0;
		_capacity = capacity;
	}
	void Push(const DataType& data)
	{
		// CheckCapacity();
		_array[_size] = data;
		_size++;
	}
	~Stack()
	{
		if (_array)
		{
			free(_array);
			_array = nullptr;
			_capacity = 0;
			_size = 0;
		}
	}
 
private:
	DataType *_array;
	size_t _size;
	size_t _capacity;
};
 
int main()
{
	Stack s1;
	s1.Push(1);
	s1.Push(2);
	s1.Push(3);
	s1.Push(4);
	Stack s2;
	s2 = s1;
	return 0;
}

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

总结：

Date 函数不需要写赋值重载函数 ，是因为编译器自动生成的赋值重载函数对内置类型会完成浅拷贝（值拷贝）
MyQueue函数不需要写赋值重载函数，是因为对于自定义类型，编译器会再去调用它们自己的默认赋值重载函数
像Stack这样的类，浅拷贝会导致析构两次、程序崩溃等问题，需要我们自己写对应的赋值重载函数

const成员

const修饰类的成员函数

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

例如，我们可以对类成员函数中的打印函数进行const修饰，避免在函数体内不小心修改了对象：

class Date
{
public:
	Date(int year, int month, int day)
	{
		this->_year = year;
		this->_month = month;
		this->_day = day;
	}
	void Print()
	{
		cout << "Print()" << endl;
		cout << "year:" << _year << endl;
		cout << "month:" << _month << endl;
		cout << "day:" << _day << endl << endl;
			
	}
	void Print() const
	{
		cout << "Print()const" << endl;
		cout << "year:" << _year << endl;
		cout << "month:" << _month << endl;
		cout << "day:" << _day << endl << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(2023, 5, 5);
	d1.Print(); //d1.Print(&d1)

	const Date d2(2023, 5, 5);
	d2.Print();//d2.Print(&d2)

	return 0;
}

为什么要在void Print() 后面加const ,不在括号里面加const, 因为this指针不能显示写， const就只能加在后面，加了const相当于const Date* const this ,加的const修饰的是*this

成员函数后面加const以后普通对象和const对象都可以调用 ，普通对象权限缩小 ，const对象权限平移

能不能所有成员函数都加这个const?
不是，要修改的对象成员变量的函数不能加

结论：所以只要成员函数内部不修改成员变量，都应该加const
这样const对象和普通对象都可以调用

思考下面几个问题（经典面试题）：
1.const对象可以调用非const成员函数吗？
2.非const对象可以调用const成员函数吗？
3.const成员函数内可以调用其他的非const成员函数吗？
4.非cosnt成员函数内可以调用其他的cosnt成员函数吗？

答案是：不可以、可以、不可以、可以
解释如下：
 1.非const成员函数，即成员函数的this指针没有被const所修饰，我们传入一个被const修饰的对象，用没有被const修饰的this指针进行接收，属于权限的放大，函数调用失败。
 2.const成员函数，即成员函数的this指针被const所修饰，我们传入一个没有被const修饰的对象，用被const修饰的this指针进行接收，属于权限的缩小，函数调用成功。
 3.在一个被const所修饰的成员函数中调用其他没有被const所修饰的成员函数，也就是将一个被const修饰的this指针的值赋值给一个没有被const修饰的this指针，属于权限的放大，函数调用失败。
 4.在一个没有被const所修饰的成员函数中调用其他被const所修饰的成员函数，也就是将一个没有被const修饰的this指针的值赋值给一个被const修饰的this指针，属于权限的缩小，函数调用成功。

const int a =10  ;
int b = a ;

const int a =10  ;
int& b = a ;

日期类的实现

在学习了C++的6个默认成员函数后，我们实现一个完整的日期类
 这是日期类中所包含的成员函数和成员变量：

class Date
{
public:
	// 构造函数
	Date(int year = 0, int month = 1, int day = 1);
	// 打印函数
	void Print() const;
	// 日期+=天数
	Date& operator+=(int day);
	// 日期+天数
	Date operator+(int day) const;
	// 日期-=天数
	Date& operator-=(int day);
	// 日期-天数
	Date operator-(int day) const;
	// 前置++
	Date& operator++();
	// 后置++
	Date operator++(int);
	// 前置--
	Date& operator--();
	// 后置--
	Date operator--(int);
	// 日期的大小关系比较
	bool operator>(const Date& d) const;
	bool operator>=(const Date& d) const;
	bool operator<(const Date& d) const;
	bool operator<=(const Date& d) const;
	bool operator==(const Date& d) const;
	bool operator!=(const Date& d) const;
	// 日期-日期
	int operator-(const Date& d) const;

	// 析构，拷贝构造，赋值重载可以不写，使用默认生成的即可

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

日期类的构造函数

// 获取某年某月的天数
inline int GetMonthDay(int year, int month)
{
	// 数组存储平年每个月的天数
	static int dayArray[13] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
	int day = dayArray[month];
	if (month == 2 && ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)))
	{
		//闰年2月的天数
		day = 29;
	}
	return day;
}
// 构造函数
Date::Date(int year, int month, int day)
{
	// 检查日期的合法性
	if (year >= 0
	&& month >= 1 && month <= 12
	&& day >= 1 && day <= GetMonthDay(year, month))
	{
		_year = year;
		_month = month;
		_day = day;
	}
	else
	{
		// 严格来说抛异常更好
		cout << "非法日期" << endl;
		cout << year << "年" << month << "月" << day << "日" << endl;
	}
}

GetMonthDay函数有三个点需要注意：
 1.GetMonthDay函数会被多次调用，所以设置为内联函数，不需要建立函数栈帧，提高代码效率
 2. 防止每次调用GetMonthDay函数都需要重新开辟数组，建立新的栈帧，dayArray数组用static修饰，存储在静态区
 3.判断闰年：四年一闰，百年不闰，四百年再闰

int Date::GetMonthDay(int year, int month)
{
	static int daysArr[13] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
	//是闰年 
	if  (month == 2 && (  (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0) )) 
	{
		//四年一闰，百年不闰，四百年再闰
		return 29;
	}
	else
	{
		return daysArr[month];
	}
}

日期类的打印函数

// 打印函数
void Date::Print() const
{
	cout << _year << "年" << _month << "月" << _day << "日" << endl;
}

日期类的大小关系比较

日期类的大小关系比较需要重载的运算符看起来有6个，实际上我们只用实现< 和== 就可以了，然后其他的通过复用这两个运算符可以实现。

< 运算符的重载

bool Date::operator< (const Date& x)
{
	//bool Date::operator ( Date * const this , const Date &x )
	if (this->_year < x._year)
	{
		return true;
	}
	else if (this->_year == x._year && this->_month < x._month)
	{
		return true;
	}
	else if (this->_year == x._year && this->_month == x._month && this->_day < x._day)
	{
		return true;
	}

	return false;
}

==运算符的重载

bool Date:: operator== (const Date& x)
{
	return this->_year == x._year
		&&	this->_month == x._month
		&&  this->_day == x._day;
}

>=运算符的重载

日期 += 天数

+=运算符的重载函数采用的是引用返回，因为出了函数作用域，this指针指向的对象没有被销毁

// 日期+=天数
Date& Date::operator+= (int day)
//Date Date::operator+ (Date *  const this ,int day)
{
	this->_day += day;
    
	while (   this->_day   >     GetMonthDay( this->_year,  this->_month)  )
	{
		this->_day -= GetMonthDay(this->_year, this->_month);
		this->_month++;
		if (this->_month == 13)
		{
			this->_year++;
			this->_month = 1;
		}
	}
	return *this;
}

<=运算符的重载

bool Date::operator<= (const Date& x)
{
	//复用之前的函数 
	return  *this < x  ||  *this ==x ;
}

!=运算符的重载

bool Date::operator!=  (const Date& x)
{
	return !(*this == x);
}

>运算符的重载

bool Date::operator> (const Date& x)
//bool Date::operator> ( Date *this , const Date &x )
//d1 >d2 ,d1 是*this ,d2 是x
{
	return !(*this<=x);
}
bool Date::operator>=  (const Date& x)
{
	return !(*this < x);
}
bool Date::operator!=  (const Date& x)
{
	return !(*this == x);
}

在这里插入代码片

日期 + 天数

+运算符的重载，复用之前+=运算符的重载函数。后置++返回的是加了之前的值，但是对象本身的值并没有改变。就像a = b + 1，b + 1的返回值是b + 1，但是b的值不变。+运算符的重载函数的返回值只能是传值返回，因为出了函数作用域，对象tmp就被销毁了，不能使用引用返回

Date Date::operator+ (int day)//后置++
//Date Date::operator+ (Date* const this ,int day  )
{
	Date tmp(*this);//用已存在的对象*this拷贝创建tmp 

	//tmp._day += day;

	//while (tmp._day > GetMonthDay(tmp._year, tmp._month))
	//{
	//	tmp._day -= GetMonthDay(tmp._year, tmp._month);
	//	tmp._month++;
	//	if (tmp._month == 13)
	//	{
	//		tmp._year++;
	//		tmp._month = 1;
	//	}
	//}

	//复用复用operator+=
	tmp += day;
	return tmp;
}

前置 ++
前置++和后置++都要++，前置++返回++以后的对象，后置++返回++之前的对象，对于内置类型前置++和后置++几乎没有区别，但是对于自定义类型 ，前置++和后置++区别会非常大，自定义类型优先用前置++
为了区分前置++和后置++的运算符重载，我们给后置++的运算符重载的参数加上一个int型参数，使用后置++时不需要给这个int参数传入实参，增加这个int参数不是为了具体的值 ，仅仅是占位 ，和前置++构成函数重载

//前置++
Date& Date::operator++()
{
	
	*this += 1;
	return *this;
}

日期 += 天数

Date& Date::operator+= (int day)
//Date Date::operator+ (Date *  const this ,int day)
{
	if (day < 0)
	{
		return *this -= -day;
	}
	this->_day += day;
    
	while (   this->_day   >     GetMonthDay( this->_year,  this->_month)  )
	{
		this->_day -= GetMonthDay(this->_year, this->_month);
		this->_month++;
		if (this->_month == 13)
		{
			this->_year++;
			this->_month = 1;
		}
	}
	return *this;
}

日期 -= 天数

Date Date::operator-= (int day)
//Date Date::operator( Date * const this  ,int day )
{
	this->_day -= day;
    
	while (this->_day <=0)
	{
		--this->_month;
		if (this->_month == 0)
		{
			this->_month = 12;
			--this->_year;
		}
		this->_day += GetMonthDay(this->_year ,this->_month);
	}
	return *this ;
}

日期 - 天数

和+运算符的重载类似，复用上面的 -= 运算符重载函数，并且tmp对象出了函数作用域被销毁了，所以不能使用引用返回。

// 日期-天数
Date Date::operator-(int day) const
{
	Date tmp(*this);// 拷贝构造tmp，用于返回
	// 复用operator-=
	tmp -= day;

	return tmp;
}

Date.h

#include<iostream>
using namespace std;

class Date
{
	//友元函数声明
	//friend void operator<< (ostream& out, const Date& d);
	friend ostream&  operator<< (ostream& out, const Date& d);

	friend istream& operator>> (istream& in, Date& d);


public:
	//构造函数 
	Date(int year = 1, int month = 1, int day = 1);

	//内联 
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
	//声明和定义分离 
	bool operator< (const Date& x);
	bool operator== (const Date& x);

	bool operator<= (const Date& x);
	bool operator> (const Date& x);
	bool operator>=  (const Date& x);
	bool operator!=  (const Date& x);

static	int GetMonthDay(int year ,int month);
	Date& operator+= (int day);
	Date operator+ (int day);
	Date& operator++();  //前置++
	Date  operator++(int );//后置++

  Date&	operator-= (int day);
  Date operator- (int day);
  Date& operator-- (); //前置-- ，返回--之后的值
  Date operator--(int); //后置 -- ，返回--之前的值 

 int   operator- (const Date & d); //d1 -d2 


 //流插入不能写成成员函数 
 //因为Date对象默认占了第一个参数，就做了左操作数
 // 写出来就一定是下面这样子 ，不符合使用习惯 
// d1 << cout; // d1.operator << cout

 //void operator<< (ostream& out);

 int GetYear()
 {
	 return this->_year;
	}

private:
	//内置类型
	int _year;
	int _month;
	int _day;
};

//void operator<< (ostream& out);

ostream& operator<< (ostream& out, const Date& d);

istream& operator>> (istream& in, Date& d);

Date.cpp

#include"Date.h"
//构造函数 
Date::Date(int year , int month , int day )
{
	if (month > 0 && month < 13
		&& day > 0 && day <=GetMonthDay(year, month)  )
	{

		this->_year = year;
			this->_month = month;
			this->_day = day;
	}
	else
	{
		cout << "非法日期"<<endl;
	}
}
bool Date::operator< (const Date& x)
{
	//bool Date::operator ( Date * const this , const Date &x )
	if (this->_year < x._year)
	{
		return true;
	}
	else if (this->_year == x._year && this->_month < x._month)
	{
		return true;
	}
	else if (this->_year == x._year && this->_month == x._month && this->_day < x._day)
	{
		return true;
	}

	return false;
}


bool Date:: operator== (const Date& x)
{
	return this->_year == x._year
		&&	this->_month == x._month
		&&  this->_day == x._day;
}




//bool Date::operator<= ( Date * const this, const Date& x)
//假设 d1<=d2  ,d1 是*this ,d2 是x

bool Date::operator<= (const Date& x)
{
	//复用之前的函数 
	return  *this < x  ||  *this ==x ;
}
bool Date::operator> (const Date& x)
//bool Date::operator> ( Date *this , const Date &x )
//d1 >d2 ,d1 是*this ,d2 是x
{
	return !(*this<=x);
}
bool Date::operator>=  (const Date& x)
{
	return !(*this < x);
}
bool Date::operator!=  (const Date& x)
{
	return !(*this == x);
}

int Date::GetMonthDay(int year, int month)
{
	static int daysArr[13] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
	//是闰年 
	if  (month == 2 && (  (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0) )) 
	{
		//四年一闰，百年不闰，四百年再闰
		return 29;
	}
	else
	{
		return daysArr[month];
	}
}


Date& Date::operator+= (int day)
//Date Date::operator+ (Date *  const this ,int day)
{
	if (day < 0)
	{
		return *this -= -day;
	}
	this->_day += day;
    
	while (   this->_day   >     GetMonthDay( this->_year,  this->_month)  )
	{
		this->_day -= GetMonthDay(this->_year, this->_month);
		this->_month++;
		if (this->_month == 13)
		{
			this->_year++;
			this->_month = 1;
		}
	}
	return *this;
}




Date Date::operator+ (int day)//后置++
//Date Date::operator+ (Date* const this ,int day  )
{
	Date tmp(*this);//用已存在的对象*this拷贝创建tmp 

	//tmp._day += day;

	//while (tmp._day > GetMonthDay(tmp._year, tmp._month))
	//{
	//	tmp._day -= GetMonthDay(tmp._year, tmp._month);
	//	tmp._month++;
	//	if (tmp._month == 13)
	//	{
	//		tmp._year++;
	//		tmp._month = 1;
	//	}
	//}

	//复用函数 
	tmp += day;
	return tmp;
}


//前置++
Date& Date::operator++()
//Date& Date::operator++( Date * const this )
{
	
	*this += 1;

	return *this;
}

//后置++
//增加这个int参数不是为了具体的值 ，仅仅是占位 ，和前置++构成函数重载 
Date Date::operator++(int)
{
	Date tmp = *this; //
	*this += 1;
	return tmp;  // tmp出了作用域就被销毁 ，用传值返回 
}

Date& Date::operator-= (int day)
//Date Date::operator( Date * const this  ,int day )
{

	if (day < 0)
	{
		return *this += -day;
	}


	this->_day -= day;
    
	while (this->_day <=0)
	{
		--this->_month;
		if (this->_month == 0)
		{
			this->_month = 12;
			--this->_year;
		}
		this->_day += GetMonthDay(this->_year ,this->_month);
	}
	return *this ;//出了函数作用域，this指针指向的对象没有被销毁。
}

Date Date::operator- (int day)
//Date Date::operator-(int day )
{

	Date(tmp) = *this;

	tmp-=day;

	return tmp;

}
Date& Date::operator-- () //前置--
{
 //前置-- ，返回--之后的值 
	*this -= 1;;
	return *this;

}
Date Date::operator--(int) //后置 -- ，返回--之前的值 
{
	Date tmp = *this;//拷贝构造
	*this -= 1;
	
		return tmp; 
}

int   Date::operator- (const Date& d) //d1-d2
//int   operator- (  Date * const this,const Date& d) //d1-d2
{
	//假设 *this 比 d 大
	Date max = *this;
	Date min = d;
	int flag = 1;
	if (*this < d) 
	{
		Date max = d;
		Date min = *this;
		int flag = -1;
	}
	
	int n = 0;
	while (max!=min)
	{
		
		++min;
		++n;
	 }

	return  flag * n;
}
//void Date::operator<< (ostream& out) //out 是cout 的别名 
//
void Date::operator<< (Date* const this ,stream& out) //out 是cout 的别名 
//{
//	out <<this->_year << "年" << this->_month << "月" << this->_day << "日" << endl;
//}


//void operator<< (ostream& out ,const Date &d)
//{
//	out << d._year << "年" << d._month << "月" << d._day << "日" << endl;
//
//}

ostream & operator<< (ostream& out, const Date& d)
{
	out << d._year << "年" << d._month << "月" << d._day << "日" << endl;
	return out;// out 就是cout 
}

istream& operator>> (istream& in, Date& d)

{
	
	
	int  month, year, day;
	in >> year >> month >> day;
	if (month > 0 && month < 13 && day>0 && day <=Date::GetMonthDay(year, month))
	{
		d._year = year;
		d._month = month;
		d._day = day;
	}
	return in;
}

进阶篇

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

这两个默认成员函数一般不用重新定义 ，编译器默认会生成

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

这两个运算符一般不需要重载，使用编译器生成的默认取地址的重载即可 ，除非想让别人获取到指定的内容！

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

如果需要this做返回值，那就需要const修饰取地址操作符重载，因为this前面被const修饰了，作为返回值时必须由const修饰

再谈构造函数

构造函数体赋值

在创建对象时，编译器会通过调用构造函数，给对象中的各个成员变量一个合适的初始值：

class Date
{
public:
	// 构造函数
	Date(int year = 0, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};

需要注意的是：虽然通过调用上述的构造函数后，对象中的每个成员变量都有了一个初始值，但是构造函数中的语句只能将其称作为赋初值，而不能称作为初始化。因为初始化只能初始化一次，而构造函数体内可以进行多次赋值。

class Date
{
public:
	// 构造函数
	Date(int year = 0, int month = 1, int day = 1)
	{
		_year = year;// 第一次赋值
		_year = 2022;// 第二次赋值
		//...
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};

初始化列表

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

class Date
{
public:
	// 构造函数
	Date(int year = 0, int month = 1, int day = 1)
		:_year(year)
		, _month(month)
		, _day(day)
	{}
private:
	int _year;
	int _month;
	int _day;
};

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

因为初始化只能进行一次，所以同一个成员变量在初始化列表中不能多次出现。
 
2. 类中包含以下成员，必须放在初始化列表进行初始化：
引用成员变量

class B
{
public:
	//初始化列表：对象成员定义的位置 
	B(int a, int ref)
		//初始化 
		:_ref(ref)
		,_n(1)

	{
		//赋值
		;
	}
private:
	//声明 
	//特征：必须在定义的时候初始化
	int& _ref;//引用
	const int _n; //const
};
int main()
{
	//对象整体定义
	B bb1(10, 1);
	B bb2(11, 2);
	return 0;
}

const成员变量

被const修饰的变量也必须在定义时就给其一个初始值，也必须使用初始化列表进行初始化。

class B
{
public:
	//初始化列表：对象成员定义的位置 
	B(int a, int ref)
		//初始化 
		:_ref(ref)
		,_n(1)

	{
		//赋值
		;
	}
private:
	//声明 
	//特征：必须在定义的时候初始化
	int& _ref;//引用
	const int _n; //const
};
int main()
{
	//对象整体定义
	B bb1(10, 1);
	B bb2(11, 2);
	return 0;
}

自定义类型成员（该类没有默认构造函数）
若一个类没有默认构造函数，那么我们在实例化该类对象时就需要传参对其进行初始化，所以实例化没有默认构造函数的类对象时必须使用初始化列表对其进行初始化。

class  A
{
public:
	//构造函数 
	A(int a =0) //给了缺省值 
		:_a(a)
	{
		cout << "A(int a = 0 )" << endl;
	}
private:
	int _a;

};
class B
{
public:
	//初始化列表：对象成员定义的位置 
	B(int a, int ref)
		//初始化 
		:_ref(ref)
		,_n(1)
		,_x(2)
		,_aobj(10)

	{
		//赋值
		;
	}
private:
	//声明 
	//特征：必须在定义的时候初始化
	A _aobj;  //自定义类型 ， 没有默认构造函数 
	int& _ref;//引用
	const int _n; //const
	int _x =1; //缺省值  ，这个缺省值是给初始化列表的
};
int main()
{
	//对象整体定义
	B bb1(10, 1);
	B bb2(11, 2);
	return 0;
}

总结：

自定义类型成员、const成员变量、引用成员变量，这些变量都有一个特征：必须在定义的时候初始化，在定义时就必须进行初始化的变量类型，就必须放在初始化列表进行初始化

引用： 引用也只有一次初始化机会，也是在它定义的地方。

【注意】：每个成员都要走初始化列表，因为初始化列表是成员定义的地方
就算不显示在初始化列表，也会走初始化列表
对于内置类型，有缺省值就用缺省值，没有缺省值编译器会处理成随机值；
而对于自定义类型，就去调用它的默认构造，如果没有默认构造就报错。
3.尽量使用初始化列表初始化

在实例化一个对象时，该对象的成员变量定义的地方就是初始化列表 ，不管你要不要去使用初始化列表，都会走这么一个过程（成员变量需要定义出来）。

• 如果是内置类型，使用初始化列表和 在构造函数体内进行初始化（不使用初始化列表）几乎没有差别，比如下面的代码：

// 使用初始化列表
int a = 10
// 在构造函数体内初始化（不使用初始化列表）
int a;
a = 10;

• 如果是自定义类型，使用初始化列表可以提高代码的效率

class Time
{
public:
	Time(int hour = 0)
	{
		_hour = hour;
	}
private:
	int _hour;
};
class Test
{
public:
	// 使用初始化列表
	Test(int hour)
		:_t(12)// 调用一次Time类的构造函数
	{
	}
private:
	Time _t;
};

对于以上代码，当需要实例化一个Test类的对象时，使用了初始化列表，在实例化过程中只调用了一次Time类的构造函数。
 不使用初始化列表的情况下，还想要达到想要的效果，就改成这样：

class Time
{
public:
	Time(int hour = 0)
	{
		_hour = hour;
	}
private:
	int _hour;
};
class Test
{
public:
	// 在构造函数体内初始化（不使用初始化列表）
	Test(int hour)
	{ //初始化列表调用一次Time类的构造函数（不使用初始化列表但也会走这个过程）
		Time t(hour);// 调用一次Time类的构造函数
		_t = t;// 调用一次Time类的赋值运算符重载函数
	}
private:
	Time _t;
};

去实例化一个Test类的对象，在实例化过程中会先在初始化列表时调用一次Time类的构造函数，然后在实例化t对象时调用一次Time类的构造函数，最后再调用了一次Time类的赋值运算符重载函数，多次调用 ，效率就降下来了
4. 成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关

class A
{
public:
	//构造函数 
	A(int a)
		//初始化列表，按照声明的顺序初始化
		:_a1(a)
		, _a2(_a1)
	{
	}
	void Print() 
	{
		cout << _a1 << " " << _a2 << endl;
	}
private:
	//声明
	int _a2;
	int _a1;
};
int main()
{
	A aa(1);//调用构造函数 
	aa.Print();//1 随机值
}

在成员变量中 ，_a2先声明 ，_a1后声明 ，根据初始化列表的初始化顺序是成员变量在类中声明次序，所以在A类构造函数的初始化列表中，成员变量_a2先初始化，成员变量_a1后初始化，即最终结果是 1 和随机值

建议 : 声明的顺序和定义的保持一致

explicit关键字

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

单参数的构造函数支持隐式类型转换
在C++中，单参数的构造函数支持隐式类型转换，这意味着当我们使用一个不同类型的参数调用构造函数时，编译器会自动进行类型转换，将参数类型转换为构造函数所需的类型

#include <iostream>
using namespace std;
class Date
{
public:
	Date(int year = 0) //单个参数的构造函数
		:_year(year)
	{
	}
	void Print()
	{
		cout << _year << endl;
	}
private:
	int _year;
};
int main()
{
	Date d1 = 2023; //2023先构造一个Date的临时对象，临时对象再拷贝构造d1——>编译器会优化成用2直接构造
	d1.Print();
	return 0;
}

在早期的编译器中，遇到Date d1 = 2023这句代码时，会先构造一个Date的临时对象，再用临时对象拷贝构造d1；随着编译器的提升 : 构造+拷贝构造---->优化成：直接构造

那么这里为避免隐式类型转换，就用explicit修饰构造函数。会按照Date d1(2023)这句代码处理，这就叫做隐式类型转换。

int a = 10;
double b = a; //隐式类型转换

在这个过程中，编译器会先构建一个double类型的临时变量接收a的值，然后再将该临时变量的值赋值给b。这就是为什么函数可以返回局部变量的值，因为当函数被销毁后，虽然作为返回值的变量也被销毁了，但是隐式类型转换过程中所产生的临时变量并没有被销毁，所以该值仍然存在。

但是，对于单参数的自定义类型来说，Date d1 = 2023这种代码的可读性不是很好，我们若是想禁止单参数构造函数的隐式转换，可以用关键字explicit来修饰构造函数。

#include <iostream>
using namespace std;
class Date
{
public:
 explicit	Date(int year = 0) //单个参数的构造函数
		:_year(year)
	{
	}
	void Print()
	{
		cout << _year << endl;
	}
private:
	int _year;
};
int main()
{
	Date d1 = 2023; //2023先构造一个Date的临时对象，临时对象再拷贝构造d1——>编译器会优化成用2直接构造
	d1.Print();
	return 0;
}

在同一个表达式里面 ，连续的构造，编译器基本都会优化,为了提高效率

单参数的构造函数支持隐式类型转换的应用

class string 
{
public:
   //单个参数的构造函数
  string (const char *str)
  {
  }
};
int main()
{
//zhangsan是const char *，name是string ，类型不同
string name= "zhangsan";//隐式类型转换
return 0 ;
}

class list
{
public:
   
  void push_back(const string &str)
  {
  }
};

int main()
{
list lt 
//隐式类型转换
lt.push_back("lisi");//调用list的构造函数，lisi是const char * ，push_back函数里面是string,类型不一致

return 0 ;
}

static成员

概念

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

特性

1.静态成员为所以类对象所共享，不属于某个具体的对象

class A
{
public:
	//构造函数 
	A()
	{
		++_scount;
	}
	//拷贝构造函数 
	A(const A& aa)
	{
		++_scount;
	}
	//析构函数 
	~A()
	{
		--_scount;
	}
	static int   GetACount()
	{
		return _scount;
	}
private:
	//都是声明 
	//静态成员变量 属于类，属于类的每个对象共享 ，存储在静态区 ，生命周期和全局变量一样
  static	int _scount;
  //成员变量属于每一个类对象 ，存储在对象里面
  int _a1 = 1;
  int _a2 = 1;
};
//全局位置，必须在类外面定义
int A::_scount = 0;
int main() 
{
	cout << A::GetACount() << endl;
	A a1, a2;
	A a3(a1);//拷贝构造 
	cout << A::GetACount() << endl;
	return 0; 
}

静态成员_n是存储在静态区的，属于整个类，也属于类的每个对象共享，在计算类的大小或是类对象的大小时，静态成员并不计入其总大小之和

成员变量是属于每个一个类对象，存储对象里面

2.静态成员变量必须在类外定义，定义时不添加static关键字

class Test
{
private:
	static int _n;
};
// 静态成员变量的定义初始化
int Test::_n = 0;

注意：这里静态成员变量_n虽然是private，但是我们在类外突破类域直接对其进行了访问。这是一个特例，不受访问限定符的限制，否则就没办法对静态成员变量进行定义和初始化了。

3.静态成员函数没有隐藏的this指针，不能访问任何非静态成员

class Test
{
public:
    //没有this指针 ，指定类域和访问限定符就可以访问
	static void Fun()
	{
		cout << _a << endl; //error不能访问非静态成员
		cout << _n << endl; //correct
	}
private:
	int _a; //非静态成员
	static int _n; //静态成员
};

含有静态成员变量的类，一般含有一个静态成员函数，用于访问静态成员变量。也就是说一般静态成员函数和静态成员变量是配套出现的
4.1当静态成员变量为公有时，有以下几种访问方式：

#include <iostream>
using namespace std;
class Test
{
public :
	static int _n;

};
// 静态成员变量的定义初始化
int Test::_n = 0;
int main()
{
	Test test; //创建对象 
	cout << Test::_n << endl;  //通过类名突破类域
	cout << test._n << endl; //通过类对象突破类域
	cout << Test()._n << endl; //通过匿名对象突破类域 
	return 0;
}

4.2当静态成员变量为私有时，有以下几种访问方式：

#include <iostream>
using namespace std;
class Test
{
public:
	static int GetN()
	{
		return _n;
	}

private:
	static int _n;
};
//静态成员变量的定义初始化
int Test::_n = 0;
int main()
{
	Test test; //创建对象 
	//通过对象调用成员函数 
	cout << test.GetN()<<endl;
	//通过匿名对象调用成员函数 
	cout << Test().GetN << endl;
	//通过类名调用成员函数 
	cout << Test::GetN << endl; 
	return 0;
}

5.静态成员和类的普通成员一样，也有public、private和protected这三种访问级别
 所以当静态成员变量设置为private时，尽管我们突破了类域，也不能对其进行访问。

静态成员函数可以调用非静态成员函数吗？

：不可以。因为非静态成员函数的第一个形参默认为this指针，而静态成员函数中没有this指针，故静态成员函数不可调用非静态成员函数。

非静态成员函数可以调用静态成员函数吗？

：可以。因为静态成员函数和非静态成员函数都在类中，在类中不受访问限定符的限制。

友元

友元分为友元函数和友元类。友元提供了一种突破封装的方式，有时提供了便利。但是友元会增加耦合度，破坏了封装，所以友元不宜多用。

友元函数

友元函数可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，但需要在类的内部声明，声明时需要加friend关键字。

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

class Date
 
{
 
public:
	Date(int year, int month, int day)
		: _year(year)
		, _month(month)
		, _day(day)
	{}
	// d1 << cout; -> d1.operator<<(&d1, cout); 不符合常规调用
 
	// 因为成员函数第一个参数一定是隐藏的this，所以d1必须放在<<的左侧
 
	ostream& operator<<(ostream& _cout)
	{
		_cout << _year << "-" << _month << "-" << _day << endl;
		return _cout;
	}
 
private:
	int _year;
	int _month;
	int _day;
};

友元函数可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，但需要在 类的内部声明，声明时需要加friend关键字。

class Date
 
{
  //声明 
 friend ostream& operator<<(ostream& _cout, const Date& d);
 friend istream& operator>>(istream& _cin, Date& d);
public:
 Date(int year = 1900, int month = 1, int day = 1)
 : _year(year)
 , _month(month)
 , _day(day)
 {
 }
 
private:
 int _year;
 int _month;
 int _day;
};
 
ostream& operator<<(ostream& _cout, const Date& d)
{
 _cout << d._year << "-" << d._month << "-" << d._day;
 return _cout; 
}
 
istream& operator>>(istream& _cin, Date& d)
{
 _cin >> d._year;
 _cin >> d._month;
 _cin >> d._day;
 return _cin;
}
 
int main()
{
 Date d;
 cin >> d;
 cout << d << endl;
 return 0;
}

注意：

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

友元类

友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员

class Time
{

	//声明友元类,声明放在那个位置都是一样的，
	//只有成员才会受私有或者共有的限制 ，访问限定符限制的是一个成员的访问方式，成员包含成员变量和成员函数 
	friend class Date;
public:
	Time(int hour = 10, int minute = 50, int  second = 40)
		:_hour(hour)
		, minute(minute)
		, _second(second)
	{

	}
private:
	int _hour;
	int minute;
	int _second;
};
class Date
{
	
public :
	Date(int year = 2023 ,int month =5 ,int day =22)
		:_year(year)
		,_month(month)
		,_day (day )
	{

	}

	void SetTimeOfDate(int hour, int minute, int second)
	{
		_t._hour = hour;
		_t.minute = minute;
		_t._second = second;
	}
private:
	int _year;
	int _month;
	int _day;
	Time _t;
};

内部类

概念：

如果一个类定义在另一个类的内部，这个内部类就叫做内部类
内部类是一个独立的类， 它不属于外部类，更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越 的访问权限。

【注意】：内部类就是外部类的友元类，参见友元类的定义，内部类可以通过外部类的对象参数来访 问外部类中的所有成员。但是外部类不是内部类的友元。

特性：

1. 内部类可以定义在外部类的public、protected、private都是可以的。

2. 注意内部类可以直接访问外部类中的static成员，不需要外部类的对象/类名。

3. sizeof(外部类)=外部类，和内部类没有任何关系。

class A
{
public:
//private:
	//内部类

	//B在A的类域里面，但是B不占空间 
	class B
	{
	public:
		//内部类是外部类的友元
		void foo(const A & a)
		{
			cout << k << endl;
			cout << a.h << endl;
		}

	};
private:
	//成员变量 
	int h;
	//静态成员变量 
	static int k;//不占空间 ，静态成员变量不在对象里面 
};
//静态成员变量定义初始化 
int A::k = 1;

int main()
{
	A::B bb;
	cout <<sizeof(A)<<endl;
	return 0;
}

匿名对象

class A
{
public:
	A(int a = 0)
		:_a(a)
	{
		cout<< "	A(int a = 0)" << endl;
	}

	~A()
	{
		cout << "~A()" << endl;
	}
private:
	int _a;
};
class Solution
{
public:
	int Sum_Solution( int n)
	{
		cout << "Sum_Solution" << endl;

		return n;
	 }

};


int main()
{
	A aa(1) ; //有名对象 ，生命周期在当前函数的局部域
	A(2);//匿名对象  ，生命周期在当前行

	Solution sl;//有名对象调用 
	sl.Sum_Solution(10);

	//匿名对象调用 ,即用即销毁

	Solution().Sum_Solution(20);
	//匿名对象具有常性
	//A& ra = A(1);//err
	const A& ra = A(1); //const引用延长了匿名对象的生命周期 ，生命周期在当前函数的作用域 
	return 0;
}

如果你觉得这篇文章对你有帮助，不妨动动手指给点赞收藏加转发，给鄃鳕一个大大的关注
你们的每一次支持都将转化为我前进的动力！！！文章来源地址https://www.toymoban.com/news/detail-459206.html

到了这里，关于史上最全类和对象 ，只要你认真看完C++类和对象，分分钟钟都吊打面试官【 C++】的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！