史上最全类和对象，只要你认真看完C++类和对象，分分钟钟都吊打面试官【 C++】网站首页 学无止境

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

鄃鳕 2024-06-17 10:43:18

简介史上最全类和对象，只要你认真看完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为类的名字，{}中为类的主体，注意类定义结束时后面分号不能省略。类体中内容称为类的成员：类中的变量称为类的属性或成员变量; 类中的函数称为类的方法或者成员函数

类的两种定义方式：

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

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;


};

类声明放在.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++实现封装的方式：用类将对象的属性和方法结合在一块，让对象更加完善，通过访问权限，选择性的将其接口提供给外部的用户使用

在这里插入图片描述
访问限定符说明：

public修饰的成员在类外可以直接被访问
protected和private修饰的成员在类外不能直接被访问(此处protected和private是类似的)
访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现时为止
如果后面没有访问限定符，作用域就到 } 即类结束。
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指针的特性

this指针的类型：类的类型* const，即成员函数中，不能给this指针赋值。
只能在“成员函数”的内部使用
this指针本质上是“成员函数”的形参，当对象调用成员函数时，将对象地址作为实参传递给this形参。所以对象中不存储this指针。

那this指针存在哪里?

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

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就是一个构造函数。当你用该日期类创建一个对象时，编译器会自动调用该构造函数对新创建的变量进行初始化

特性

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

其特征如下：

构造函数函数名与类名相同。
构造函数无返回值。
无返回值并不是返回值是void ，是函数没有返回值
对象实例化时编译器自动调用对应的构造函数。

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;
}

构造函数可以重载

构造函数支持函数重载

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;
}

如果类中没有显式定义构造函数，则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;
}

在这里插入图片描述

如果你觉得这篇文章对你有帮助，不妨动动手指给点赞收藏加转发，给鄃鳕一个大大的关注
你们的每一次支持都将转化为我前进的动力！！！

风语者！平时喜欢研究各种技术，目前在从事后端开发工作，热爱生活、热爱工作。

上一篇
僵尸进程？孤儿进程？为什么他有如此惨烈...

下一篇
Zero Shot、Few Shot、One Shot闲聊

站长推荐

SpringSecurity实现前后端分离认证授权
SpringSecurity实现前后端分离认证授权
stm32使用HAL库配置串口中断收发数据（保姆级教程）
stm32使用HAL库配置串口中断收发数据（保姆级教程）
U8W/U8W-Mini使用与常见问题解决
U8W/U8W-Mini使用与常见问题解决
【社区图书馆】伴我前行的一本书《The C Programming Language》
【社区图书馆】伴我前行的一本书《The C Programming Language》
【云原生进阶之容器】第六章容器网络6.6.1--Cilium网络方案概述
【云原生进阶之容器】第六章容器网络6.6.1--Cilium网络方案概述

您现在的位置是：首页 >学无止境 >史上最全类和对象 ，只要你认真看完C++类和对象，分分钟钟都吊打面试官【 C++】网站首页学无止境

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

文章目录

基础篇

面向过程和面向对象

类的引入

类的定义

类的访问限定符

类的封装

类的作用域

类的实例化

类对象模型

如何计算类对象的大小

类对象的存储方式猜测

对象中包含类的各个成员

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

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

this指针

this指针的特性

提高篇

类的6个默认成员函数

构造函数

特性

构造函数的调用

默认构造函数

析构函数

析构函数的特性

拷贝构造函数

拷贝构造函数的特性

赋值运算符重载

运算符重载

赋值运算符重载

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

const成员

const修饰类的成员函数

日期类的实现

日期类的构造函数

日期类的打印函数

日期类的大小关系比较

< 运算符的重载

==运算符的重载

>=运算符的重载

<=运算符的重载

!=运算符的重载

>运算符的重载

日期 + 天数

日期 += 天数

日期 -= 天数

日期 - 天数

上一篇 僵尸进程？孤儿进程？为什么他有如此惨烈...

下一篇 Zero Shot、Few Shot、One Shot闲聊

站长推荐

您现在的位置是：首页 >学无止境 >史上最全类和对象，只要你认真看完C++类和对象，分分钟钟都吊打面试官【 C++】网站首页学无止境

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

上一篇
僵尸进程？孤儿进程？为什么他有如此惨烈...

下一篇
Zero Shot、Few Shot、One Shot闲聊