【C++】拆分详解 - 类与对象

如泡似影

已于 2024-07-17 10:39:42 修改

阅读量1.6k

点赞数 51

分类专栏： C++ 文章标签： c++ c语言经验分享笔记

于 2024-03-27 20:51:58 首次发布

本文链接：https://blog.csdn.net/bubble_shadow/article/details/136718444

版权

C++ 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

文章目录

一、面向过程和面向对象初步认识
二、类的引入
三、类的6个默认成员函数
四、再谈构造函数
五、static成员
- 1. 概念
- 2. 特性
六、友元
- 1. 友元函数
- 2. 友元类
七、内部类
- 1. 概念
- 2. 特性
八、匿名对象
九、拷贝对象时的一些编译器优化
十、练习题
总结

一、面向过程和面向对象初步认识

C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。

在这里插入图片描述

C++是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。

在这里插入图片描述

要想深刻地理解面向对象与面向过程的区别，需要等读者实践过一定的项目后才能自己体会到，这里三言两语是讲不清楚的

二、类的引入

C语言结构体中只能定义变量，在C++中，结构体内不仅可以定义变量，也可以定义函数。

比如：用C语言方式实现的栈，结构体中只能定义变量；现在以C++方式实现，会发现struct中也可以定义函数。
下面结构体的定义，在C++中更喜欢用class来代替。

typedef int DataType;
struct Stack
{
	void Init(size_t capacity)
	{
		_array = (DataType*)malloc(sizeof(DataType) * capacity);
		if (nullptr == _array)
		{
			perror("malloc申请空间失败");
			return;
		}
		_capacity = capacity;
		_size = 0;
	}
	void Push(const DataType& data)
	{
		// 扩容
		_array[_size] = data;
		++_size;
	}
	DataType Top()
	{
		return _array[_size - 1];
	}
	void Destroy()
	{
		if (_array)
		{
			free(_array);
			_array = nullptr;
			_capacity = 0;
			_size = 0;
		}
	}
	DataType* _array;
	size_t _capacity;
	size_t _size;
};
int main()
{
	Stack s;
	s.Init(10);
	s.Push(1);
	s.Push(2);
	s.Push(3);
	cout << s.Top() << endl;
	s.Destroy();
	return 0;
}

1. 类的定义

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

class为定义类的关键字，ClassName为类的名字，{}中为类的主体，注意类定义结束时后面分号不能省略。

类体中内容称为类的成员：
类中的变量称为类的属性或成员变量; 类中的函数称为类的方法或者成员函数。

类的两种定义方式：

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

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

一般情况下，更期望采用第二种方式。注意：文中代码为了方便演示使用方式一定义类，读者后序工作中尽量使用第二种。

成员变量命名规则的建议：

// 我们看看这个函数，是不是很僵硬？
class Date
{
public:
	void Init(int year)
	{
		// 这里的year到底是成员变量，还是函数形参？
		_year = year;
	}
private:
	int _year;
};
// 所以一般都建议这样
class Date
{
public:
	void Init(int year)
	{
		_year = year;
	}
private:
	int _year;
};
// 或者这样
class Date
{
public:
	void Init(int year)
	{
		mYear = year;
	}
private:
	int mYear;
};
// 其他方式也可以的，主要看公司要求。一般都是加个前缀或者后缀标识区分就行。

2. 类的访问限定符及封装

2.1 访问限定符

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

在这里插入图片描述

【访问限定符说明】

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

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

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

C++需要兼容C语言，所以C++中struct可以当成结构体使用。另外C++中struct还可以用来定义类。和class定义类是一样的，区别是struct定义的类默认访问权限是public，class定义的类默认访问权限是private。注意：在继承和模板参数列表位置，struct和class也有区别，以后再介绍。

2.3 封装

面向对象的三大特性：封装、继承、多态。
在类和对象阶段，主要是研究类的封装特性，那什么是封装呢？

封装：
将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互。
封装本质上是一种管控，让用户更方便使用类。
比如：对于电脑这样一个复杂的设备，提供给用户的就只有开关机键、通过键盘输入，显示器，USB插孔等，让用户和计算机进行交互，完成日常事务。但实际上电脑真正工作的却是CPU、显卡、内存等一些硬件元件。

对于计算机使用者而言，不用关心内部核心部件，比如主板上线路是如何布局的，CPU内部是如何设计的等，用户只需要知道，怎么开机、怎么通过键盘和鼠标与计算机进行交互即可。因此计算机厂商在出厂时，在外部套上壳子，将内部实现细节隐藏起来，仅仅对外提供开关机、鼠标以及键盘插孔等，让用户可以与计算机进行交互即可。

在C++语言中实现封装，可以通过类将数据以及操作数据的方法进行有机结合，通过访问权限来隐藏对象内部实现细节，控制哪些方法可以在类外部直接被使用。

3. 类的作用域

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

class Person
{
public:
	void PrintPersonInfo();
private:
	char _name[20];
	char _gender[3];
	int  _age;
};
// 这里需要指定PrintPersonInfo是属于Person这个类域
void Person::PrintPersonInfo()
{
	cout << _name << " " << _gender << " " << _age << endl;
}

4. 类的实例化

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

类是对对象进行描述的，是一个模型一样的东西，限定了类有哪些成员，定义出一个类并没有分配实际的内存空间来存储它
一个类可以实例化出多个对象，实例化出的对象占用实际的物理空间，存储类成员变量
打个比方。类实例化出对象就像现实中使用建筑设计图建造出房子，类就像是设计图，只设计出需要什么东西，但是并没有实体的建筑存在，同样类也只是一个设计，实例化出的对象才能实际存储数据，占用物理空间

在这里插入图片描述

5. 类对象模型

5.1 如何计算类对象的大小

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

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

5.2 类对象的存储方式

对象中包含类的各个成员（浪费空间）

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

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

结论：

一个类的大小，实际就是该类中”成员变量”之和，当然要注意内存对齐。
注意空类的大小，空类比较特殊，编译器给了空类一个字节来唯一标识这个类的对象。好比上面我们举过的例子，类是一个设计图，设计图即使是空白的，也是一张图纸，要占据一点空间。

5.3 结构体内存对齐规则

第一个成员在与结构体偏移量为0的地址处。
其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。
注意：对齐数 = 编译器默认的一个对齐数与该成员大小的较小值。
VS中默认的对齐数为8
结构体总大小为：最大对齐数（所有变量类型最大者与默认对齐参数取最小）的整数倍。
如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。

为什么存在内存对齐？

平台原因 (移植原因)：
不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常。
性能原因：
计算机有32根地址总线，硬件规定从其整数倍开始读（32bit），一般一次读 4/8 字节。如下图，如果不对齐，则读a会执行两次内存访问后再组合，效率太低

总体来说：结构体的内存对齐是拿空间来换取时间的做法。

6. 隐藏的this指针

6.1 引出

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, d2;
	d1.Init(2022, 1, 11);
	d2.Init(2022, 1, 12);
	d1.Print();
	d2.Print();
	return 0;
}

对于上述类，有这样的一个问题：

Date类中有 Init 与 Print 两个成员函数，函数体中没有关于不同对象的区分，那当d1调用 Init 函数时，该函数是如何知道应该设置d1对象，而不是设置d2对象呢？

C++中通过引入this指针解决该问题，即：C++编译器给每个“非静态的成员函数“增加了一个隐藏的指针参数，让该指针指向当前对象(函数运行时调用该函数的对象)，在函数体中所有“成员变量”的操作，都是通过该指针去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。

6.2 特性

在这里插入图片描述

函数形参和实参的位置，我们不能将this指针写出来
在函数内部可以使用
this指针的类型：自定义类型* const，即成员函数中，不能给this指针赋值
this指针本质上是“成员函数”的第一个隐含的指针形参，当对象调用成员函数时，将对象地址作为实参传递给this形参。所以对象中不存储this指针。那this指针存在哪里？

6.3 深入理解

this指针存在哪里？
因为是形参，所以一般存储在栈中。但也有例外，某些编译器比如VS可能用寄存器存储

扩展：
const 常量 -> 常量区
const 变量和指针 -> 栈

this指针可以为空吗？

// 1.下面程序编译运行结果是？ A、编译报错 B、运行崩溃 C、正常运行
class A
{
public:
	void PrintA()
	{
		cout << "Print()" << endl;
	}
private:
	int _a;
};
int main()
{
	A* p = nullptr;
	p->PrintA();
	return 0;
}

在这里插入图片描述

// 2.下面程序编译运行结果是？ A、编译报错 B、运行崩溃 C、正常运行
class A
{
public:
	void PrintA()
	{
		cout << _a << endl;// this->_a
	}
private:
	int _a;
};
int main()
{
	A* p = nullptr;
	p->PrintA();
	return 0;
}

在这里插入图片描述

结论：this指针可以为空

语法上可以传递空指针为参数，但不能解引用空指针
有解引用操作符 -> 不一定会发生解引用，编译器会智能识别，例如上面的程序 p->PrintA(); Print为类的成员函数，实际代码等同于(*p).PrintA(&p) 【这里我们写出了this指针只是为了方便观察，实际操作时不能显式写】由于成员函数存储在公共代码区，不在p指向的空间内，则此时不会对p进行解引用，而是去调用PrintA函数。这里类类型的p指针 起指向作用，意思是告诉编译器去类里面找，当识别出是成员函数时，如前分析，直接去公共代码区找，而不发生解引用。

程序1 正常运行的原因是 PrintA函数体内没有对类的对象进行调用，也就不需要解引用this指针p ，也就不会发生错误
程序 2 运行崩溃的原因是 PrintA函数体内调用了类的成员变量，因此会对this指针p进行解引用，解引用空指针崩溃

6.4 C语言和C++实现Stack的对比

C语言实现

typedef int DataType;
typedef struct Stack
{
	DataType* array;
	int capacity;
	int size;
}Stack;

void StackInit(Stack* ps)
{
	assert(ps);
	ps->array = (DataType*)malloc(sizeof(DataType) * 3);
	if (NULL == ps->array)
	{
		assert(0);
		return;
	}
	ps->capacity = 3;
	ps->size = 0;
}

void StackDestroy(Stack* ps)
{
	assert(ps);
	if (ps->array)
	{
		free(ps->array);
		ps->array = NULL;
		ps->capacity = 0;
		ps->size = 0;
	}
}

void CheckCapacity(Stack* ps)
{
	if (ps->size == ps->capacity)
	{
		int newcapacity = ps->capacity * 2;
		DataType* temp = (DataType*)realloc(ps->array,
			newcapacity * sizeof(DataType));
		if (temp == NULL)
		{
			perror("realloc fail");
			return;
		}
		ps->array = temp;
		ps->capacity = newcapacity;
	}
}

void StackPush(Stack* ps, DataType data)
{
	assert(ps);
	CheckCapacity(ps);
	ps->array[ps->size] = data;
	ps->size++;
}

int StackEmpty(Stack* ps)
{
	assert(ps);
	return 0 == ps->size;
}

void StackPop(Stack* ps)
{
	if (StackEmpty(ps))
		return;
	ps->size--;
}

DataType StackTop(Stack* ps)
{
	assert(!StackEmpty(ps));
	return ps->array[ps->size - 1];
}

int StackSize(Stack* ps)
{
	assert(ps);
	return ps->size;
}

int main()
{
	Stack s;
	StackInit(&s);
	StackPush(&s, 1);
	StackPush(&s, 2);
	StackPush(&s, 3);
	StackPush(&s, 4);
	printf("%d\n", StackTop(&s));
	printf("%d\n", StackSize(&s));
	StackPop(&s);
	StackPop(&s);
	printf("%d\n", StackTop(&s));
	printf("%d\n", StackSize(&s));
	StackDestroy(&s);
	return 0;
}

可以看到，在用C语言实现时，Stack相关操作函数有以下共性：

每个函数的第一个参数都是Stack*
函数中必须要对第一个参数检测，因为该参数可能会为NULL
函数中都是通过Stack*参数操作栈的
调用时必须传递Stack结构体变量的地址

结构体中只能定义存放数据的结构，操作数据的方法不能放在结构体中，即数据和操作数据的方式是分离开的，而且实现上相当复杂一点，涉及到大量指针操作，稍不注意可能就会出错。

C++实现

typedef int DataType;
class Stack
{
public:
	void Init()
	{
		_array = (DataType*)malloc(sizeof(DataType) * 3);
		if (NULL == _array)
		{
			perror("malloc申请空间失败!!!");
			return -1;
		}
		_capacity = 3;
		_size = 0;
	}
	void Push(DataType data)
	{
		CheckCapacity();
		_array[_size] = data;
		_size++;
	}
	void Pop()
	{
		if (Empty())
			return;
		_size--;
	}
	DataType Top() { return _array[_size - 1]; }
	int Empty() { return 0 == _size; }
	int Size() { return _size; }
	void Destroy()
	{
		if (_array)
		{
			free(_array);
			_array = NULL;
			_capacity = 0;
			_size = 0;
		}
	}
private:
	void CheckCapacity()
	{
		if (_size == _capacity)
		{
			int newcapacity = _capacity * 2;
			DataType* temp = (DataType*)realloc(_array, newcapacity *
				sizeof(DataType));
			if (temp == NULL)
			{
				perror("realloc fail");
				return -1;
			}
			_array = temp;
			_capacity = newcapacity;
		}
	}
private:
	DataType* _array;
	int _capacity;
	int _size;
};
int main()
{
	Stack s;
	s.Init();
	s.Push(1);
	s.Push(2);
	s.Push(3);
	s.Push(4);

	printf("%d\n", s.Top());
	printf("%d\n", s.Size());
	s.Pop();
	s.Pop();
	printf("%d\n", s.Top());
	printf("%d\n", s.Size());
	s.Destroy();
	return 0;
}

C++中通过类可以将数据以及操作数据的方法进行完美结合，通过访问权限可以控制哪些方法在类外可以被调用，即封装，在使用时就像使用自己的成员一样，更符合人类对一件事物的认知。
而且每个方法不需要传递Stack*的参数了，编译器编译之后该参数会自动还原，即C++中 Stack * 参数是编译器维护的【隐藏的this指针】，C语言中需要用户自己维护。

三、类的6个默认成员函数

如果一个类中什么成员都没有，简称为空类。
空类中真的什么都没有吗？并不是，任何类在什么都不写时，编译器会自动生成以下6个默认成员函数。
默认成员函数：用户没有自己显式实现，编译器会自动生成的成员函数称为默认成员函数。

class Date {};

在这里插入图片描述

1. 构造函数

1.1 概念

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(2022, 7, 5);
	d1.Print();
	Date d2;
	d2.Init(2022, 7, 6);
	d2.Print();
	return 0;
}

对于Date类，可以通过 Init 公有方法给对象设置日期，但如果每次创建对象时都调用该方法设置信息，未免有点麻烦，那能否在对象创建时，就将信息设置进去呢？

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

1.2 定义与特性

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

其语法定义如下：

函数名与类名相同。
无返回值。
对象实例化时编译器自动调用对应的构造函数。
构造函数可以重载。

class Date
{
public:
	// 1.无参构造函数
	Date()
	{}

	// 2.带参构造函数
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};

void TestDate()
{
	Date d1;  // √ ，调用无参构造函数
	Data d1();// × ，无参时不能加括号，为了和函数声明区分开

	Date d2(2015, 1, 1); // 调用带参的构造函数
	Date d3();
}

其特性如下：

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

class Date
{
public:
	/*
	// 如果用户显式定义了构造函数，编译器将不再生成
	Date(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类中构造函数屏蔽后，代码可以通过编译，因为编译器生成了一个无参的默认构造函数
	 
	// 将Date类中构造函数放开，代码编译失败，因为一旦显式定义任何构造函数，编译器将不再生成无参的默认构造函数，此时只能调用带参的构造函数
	
	Date d1;
	return 0;
}

编译器生成的默认构造函数对内置类型不做处理，对自定义类型则回去调用该类型的默认构造函数。看看下面的程序，就会发现编译器生成默认的构造函数会对自定类型成员_t调用的它的默认成员函数。

在这里插入图片描述

class Time
{
public:
	Time() //Time _t 调用该函数
	{
		cout << "Time()" << endl;
		_hour = 0;
		_minute = 0;
		_second = 0;
	}
private:
	int _hour;
	int _minute;
	int _second;
};

class Date
{
private:
	// 基本类型(内置类型)
	int _year;
	int _month;
	int _day;
	// 自定义类型
	Time _t; //调用Time类中的构造函数
};
int main()
{
	Date d;
	return 0;
}

因此，绝大部分场景下，都需要我们自己实现构造函数，那这样看来编译器生成的默认构造函数并没有什么用？？？其实不然，编译器生成的默认构造函数本质意义是减少重复工作，提高代码的简洁性和工作效率。
我们来看下面这个 MyQueue 自定义类型，我们不需要写MyQueue的构造函数，因为它是由栈组成的，直接调用栈的构造函数就行了。自定义类型本质上就是套娃，都是由内置类型组成的。就像人一样，最终都是由元素组成，元素组成原子，原子组成分子，分子组成细胞… 我们只需要处理最终的内置类型，拆解处理的过程交给编译器就行

class Stack
{
public:
	Stack() //栈的构造函数
	{
		//...
		cout << "Stack()" << endl;
	}
	//...
};

// 两个栈实现队列
class MyQueue
{
private:
	Stack st1;
	Stack st2;
};

int main()
{
	MyQueue q;//回去调用栈的默认构造函数
	return 0;
}

注意：C++11 中针对内置类型成员不初始化的缺陷，又打了补丁，即：内置类型成员变量在类中声明时可以给缺省值，编译器此时会根据缺省值初始化变量

class Date
{
private:
	// 基本类型(内置类型)
	int _year = 1970;
	int _month = 1;
	int _day = 1;
};

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

无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。
注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数（无参），都可以认为是默认构造函数。

class Date
{
public:
	Date()
	{
		_year = 1900;
		_month = 1;
		_day = 1;
	}
	Date(int year = 1900, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};
// 以下测试函数能通过编译吗？
void Test()
{
	Date d1;
}

在这里插入图片描述

2. 析构函数

2.1 概念

通过前面构造函数的学习，我们知道一个对象是怎么来的，那一个对象又是怎么没呢的？

析构函数：与构造函数功能相反，析构函数不是完成对对象本身的销毁，局部对象销毁工作是由编译器完成的。而对象在销毁时会自动调用析构函数，完成对象中资源的清理工作。

2.2 定义与特性

析构函数是特殊的成员函数，其语法定义如下：

析构函数名是在类名前加上字符 ~。
无参数无返回值类型。
一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。注意：析构函数不能重载
对象生命周期结束时，C++编译系统自动调用析构函数。

typedef int DataType;
class Stack
{
public:
	Stack(size_t capacity = 3)
	{
		_array = (DataType*)malloc(sizeof(DataType) * capacity);
		if (NULL == _array)
		{
			perror("malloc申请空间失败!!!");
			return;
		}
		_capacity = capacity;
		_size = 0;
	}
	void Push(DataType data)
	{
		// CheckCapacity();
		_array[_size] = data;
		_size++;
	}
	// 其他接口函数...

	~Stack() //析构函数
	{
		if (_array)
		{
			free(_array);
			_array = NULL;
			_capacity = 0;
			_size = 0;
		}
	}
private:
	DataType* _array;
	int _capacity;
	int _size;
};

void TestStack()
{
	Stack s;
	s.Push(1);
	s.Push(2);
}

其特性如下：
5. 编译器生成的默认析构函数，跟默认构造函数类似，对内置类型不作处理，对自定义类型成员调用它的析构函数。

class Time
{
public:
	~Time()
	{
		cout << "~Time()" << endl;
	}
private:
	int _hour;
	int _minute;
	int _second;
};
class Date
{
private:
	// 基本类型(内置类型)
	int _year = 1970;
	int _month = 1;
	int _day = 1;
	// 自定义类型
	Time _t;
};
int main()
{
	Date d;
	return 0;
}
/*
	main中创建了Date对象d，而d中包含4个成员变量，_year, _month, _day三个是内置类型成员，销毁时不需要资源清理，最后系统直接将其内存回收即可；
	而_t是Time类对象，所以在d销毁时，要将其内部包含的Time类的_t对象销毁，所以要调用Time类的析构函数。
	但是：main函数中不能直接调用Time类的析构函数，实际要释放的是Date类对象，所以编译器会调用Date类的析构函数；
		而Date没有显式提供，则编译器会给Date类生成一个默认的析构函数，目的是在其内部调用Time类的析构函数。
		
	注意：创建哪个类的对象则调用该类的析构函数，销毁那个类的对象则调用该类的析构函数

*/

如果类中没有申请资源时，析构函数可以不写，直接使用编译器生成的默认析构函数，比如Date类；有资源申请时，一定要写，否则会造成资源泄漏，比如Stack类。【动态开辟的空间需要手动释放】

回收顺序：
① 局部对象 -> 局部静态对象 -> 全局对象
② 与栈后进先出的性质相同，同类型的对象后定义的先析构

3. 拷贝构造

3.1 概念

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

3.2 定义与特性

拷贝构造函数也是特殊的成员函数，其特征如下：

拷贝构造函数是构造函数的一个重载形式。
拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错，因为会引发无穷递归调用。如下图，传值方式传参，形参就是实参的一份临时拷贝，为了拷贝生成形参又去调用另一个拷贝构造函数，而调用的拷贝构造函数要正常执行还是需要传形参给函数使用，因此会不断递归调用，始终无法进入函数体内完成拷贝，最终栈溢出程序崩溃。

在这里插入图片描述
3. 浅拷贝

若未显式定义，编译器会生成默认的拷贝构造函数。默认的拷贝构造函数对象按内存存储按字节序（逐字节）完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。
注意：在编译器生成的默认拷贝构造函数中，对内置类型做拷贝，而自定义类型是调用其拷贝构造函数完成拷贝的。【对于自定义类型，拷贝构造能不断调用自定义类型的拷贝构造，直到调用到最后的内置类型。这时与构造和析构函数不同的是，拷贝构造对内置类型作处理，则实际上拷贝构造既处理内置类型，也处理自定义类型，由编译器实现，而不像之前的构造和析构只起调用作用，最后还是由用户实现。

class Time
{
public:
	Time()
	{
		_hour = 1;
		_minute = 1;
		_second = 1;
	}
	Time(const Time& t)
	{
		_hour = t._hour;
		_minute = t._minute;
		_second = t._second;
		cout << "Time::Time(const Time&)" << endl;
	}
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;
	// 用已经存在的d1拷贝构造d2，此处会调用Date类的拷贝构造函数
	// 但Date类并没有显式定义拷贝构造函数，则编译器会给Date类生成一个默认的拷贝构造函数
	Date d2(d1);
	return 0;
}

4. 深拷贝

编译器生成的默认拷贝构造函数已经可以完成字节序的浅拷贝了，但对于涉及资源申请的类的拷贝，这时必须要我们手动写一个深拷贝，为动态开辟的空间开辟另一块同等大小的空间，这是浅拷贝做不到的。

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(s1);
	return 0;
}

在这里插入图片描述
5. 拷贝构造函数典型调用场景：

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

class Date
{
public:
	 Date(int year, int minute, int day)
	 {
	 	cout << "Date(int,int,int):" << this << endl;
	 }
	 Date(const Date& d)
	 {
	 	cout << "Date(const Date& d):" << this << endl;
	 }
	 ~Date()
	 {
	 	cout << "~Date():" << this << endl;
	 }
private:
	 int _year;
	 int _month;
	 int _day;
};

Date Test(Date d)
{
	 Date temp(d);
	 return temp;
}

int main()
{
	 Date d1(2022,1,13);
	 Test(d1);
	 return 0;
}

在这里插入图片描述
为了提高程序效率，一般对象传参时，尽量使用引用类型，返回时根据实际场景，能用引用尽量使用引用。

4. 赋值运算符重载

4.1 运算符重载

C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。

函数名字为：关键字operator后面接需要重载的运算符符号。
函数原型：返回值类型 operator操作符(参数列表)
注意：

不能通过连接其他符号来创建新的操作符（必须是c/c++语法中存在的）：比如operator@ 就不行
重载操作符必须有一个类类型参数用于内置类型的运算符，其含义不能改变，例如：内置的整型+，不能改变其含义
作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的this
.* :: sizeof ?: . 注意以上5个运算符不能重载。这个经常在笔试选择题中出现。

// 全局的operator==
class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	//private:
	int _year;
	int _month;
	int _day;
};
// 这里会发现运算符重载成全局的就需要成员变量是公有的，那么问题来了，封装性如何保证？
// 这里其实可以用我们后面学习的友元解决，或者干脆重载成成员函数。
bool operator==(const Date& d1, const Date& d2)
{
	return d1._year == d2._year
		&& d1._month == d2._month
		&& d1._day == d2._day;
}
void Test()
{
	Date d1(2018, 9, 26);
	Date d2(2018, 9, 27);
	cout << (d1 == d2) << endl;
}

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

		// bool operator==(Date* this, const Date& d2)
		// 这里需要注意的是，左操作数是this，指向调用函数的对象
	bool operator==(const Date& d2)
	{
		return _year == d2._year
		&& _month == d2._month
			&& _day == d2._day;
	}
private:
	int _year;
	int _month;
	int _day;
};

4.2 赋值运算符重载

1. 赋值运算符重载格式

参数类型：const T&，传递引用可以提高传参效率
返回值类型：T&，返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值
检查是否自己给自己赋值，若为自身赋值则可以跳过赋值步骤直接返回提升效率
返回*this ：要符合连续赋值的含义

连续赋值：赋值表达式返回值为左操作数，如 i = j = 10 ，是将10赋值给 j ，返回左操作数 j ，再将 j 赋值给 i ，再返回 i 作为表达式最终结果。因此我们要返回 *this ，且返回类型为引用，这样才能实现连续赋值。

class Date
{
public:
	Date(int year = 1900, 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;
	}

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

2. 赋值运算符只能重载成类的成员函数不能重载成全局函数

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;
}
// 编译失败：
// error C2801: “operator =”必须是成员函数

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

在这里插入图片描述

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

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

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

4. 深拷贝

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

5.前置++和后置++重载

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

	// 前置++：返回+1之后的结果
	// 注意：this指向的对象函数结束后不会销毁，故以引用方式返回提高效率
	Date& operator++()
	{
		_day += 1;
		return *this;
	}
	// 后置++：
	// 前置++和后置++都是一元运算符，为了让前置++与后置++形成能正确重载
	// C++规定：后置++重载时多增加一个int类型的参数，但调用函数时该参数不用传递，编译器自动传递
	// 注意：后置++是先使用后+1，因此需要返回+1之前的旧值，故需在实现时需要先将this保存一份，然后给this + 1
	//       而tmp是临时对象，因此只能以值的方式返回，不能返回引用
	Date operator++(int)
	{
		Date tmp(*this);
		_day += 1;
		return tmp;
	}

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

int main()
{
	Date d;
	Date d1(2024, 3, 25);
	d = d1++;    
	d = ++d1;    
	return 0;
}

5. 日期类的实现

//头文件 Date.h
#include<iostream>
using namespace std;

class Date
{
public:
	// 获取某年某月的天数
	int GetMonthDay(int year, int month)
	{
		static int days[13] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
		int day = days[month];
		if (month == 2
			&& ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)))
		{
			day += 1;
		}
		return day;
	}

	void Print()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}
	
	// 全缺省的构造函数
	Date(int year = 1900, int month = 1, int day = 1);

	// 拷贝构造函数
	// d2(d1)
	//Date(const Date& d);

	// 赋值运算符重载
	// d2 = d3 -> d2.operator=(&d2, d3)
	//Date& operator=(const Date& d);
	// 析构函数
	//~Date();
	
	// 日期+=天数
	Date& operator+=(int day);
	// 日期+天数
	Date operator+(int day);
	// 日期-天数
	Date operator-(int day);
	// 日期-=天数
	Date& operator-=(int day);
	// 前置++
	Date& operator++();
	// 后置++
	Date operator++(int);
	// 后置--
	Date operator--(int);
	// 前置--
	Date& operator--();

	// >运算符重载
	bool operator>(const Date& d);
	// ==运算符重载
	bool operator==(const Date& d);
	// >=运算符重载
	bool operator >= (const Date& d);

	// <运算符重载
	bool operator < (const Date& d);
	// <=运算符重载
	bool operator <= (const Date& d);
	// !=运算符重载
	bool operator != (const Date& d);
	// 日期-日期 返回天数
	int operator-(const Date& d);
private:
	int _year;
	int _month;
	int _day;
};

//Date.cpp

#include"Date.h"

//全缺省构造函数
Date::Date(int year, int month, int day)
{
	_year = year;
	_month = month;
	_day = day;
}

//运算符重载
bool Date::operator<(const Date& d)
{
	if (_year < d._year)
	{
		return true;
	}
	else if (_year == d._year)
	{
		if (_month < d._month)
		{
			return true;
		}
		else if (_month == d._month)
		{
			if (_day < d._day)
				return true;
		}
	}

	return false;
}

bool Date::operator==(const Date& d)
{
	return _year == d._year
		&& _month == d._month
		&& _day == d._day;
}

bool Date::operator<=(const Date& d)
{
	return *this < d || *this == d;
}

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

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

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


//赋值运算符重载
Date& Date::operator+=(int day)
{
	_day += day;
	while (_day > GetMonthDay(_year, _month))
	{
		_day -= GetMonthDay(_year, _month);
		++_month;
		if (_month == 13)
		{
			_year++;
			_month = 1;
		}
	}

	return *this;
}

Date Date::operator+(int day)
{
	Date tmp = *this;
	tmp += day;
	return tmp;
}

Date& Date::operator-=(int day)
{
	_day -= day;
	while (_day <= 0)
	{
		--_month;
		if (_month == 0)
		{
			--_year;
			_month = 12;
		}

		_day += GetMonthDay(_year, _month);
	}

	return *this;
}

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

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

//后置--
Date Date::operator--(int)
{
	Date tmp = *this;
	*this -= 1;
	return tmp;
}

int Date::operator-(const Date& d)
{
	int flag = 1;
	Date max = *this;
	Date min = d;

	if (*this < d)
	{
		int flag = -1;
		max = d;
		min = *this;
	}

	int n = 0;
	while (min != max)
	{
		++min;
		++n;
	}

	return n * flag;
}

#include"Date.h"

int main()
{
	Date d1(2024, 3, 25);
	Date d2 = d1 + 20;
	d2.Print();
	d1.Print();

	d2 -= 20;
	d2.Print();

	d1 += 30000;
	d1.Print();

	//前置++
	++d1;
	d1.operator++();
	d1.Print();

	d1++;
	d1.operator++(1);//可以随便给，不给编译器也会自动传递
	d1.Print();

	Date d4(2024, 3, 25);
	Date d5(2024, 8, 1);
	cout << d5 - d4 << endl;

	return 0;
}

6. const成员

将const修饰的“成员函数”称之为const成员函数，const修饰类成员函数，实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进行修改。

在这里插入图片描述

class Date
{
public:
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_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; // 日
};

void Test()
{
	Date d1(2022, 1, 13);
	d1.Print();
	const Date d2(2022, 1, 13);
	d2.Print();
}

请思考下面的几个问题：

const对象可以调用非const成员函数吗？
非const对象可以调用const成员函数吗？
const成员函数内可以调用其它的非const成员函数吗？
非const成员函数内可以调用其它的const成员函数吗？

其实判断起来很简单，只需要记住谁调用谁，调用者的权限必须 >= 被调用者的权限，这跟我们现实生活也一致，vip 可以使用vip权限，也可以使用普通用户权限，而普通用户不能使用vip权限。

在这里插入图片描述

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

功能只有返回地址，无论是内置类型还是自定义类型，甚至是空类，在实现上都没有什么区别，因此这两个默认成员函数一般不用重新定义，编译器默认会生成。

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

这两个运算符一般不需要重载，使用编译器生成的默认取地址的重载即可，只有特殊情况，才需要重载，比如想让别人获取到指定的内容！

四、再谈构造函数

1. 构造函数体赋值

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

虽然上述构造函数调用之后，对象中已经有了一个初始值，但是不能将其称为对成员变量的初始化，构造函数体中的语句只能将其称为二次赋值，而不能称作初始化。因为初始化只能初始化一次，而构造函数体内可以多次赋值，实际上编译器在处理时先调用初始化列表进行初始化，再执行构造函数体内的赋值，如果未写初始化列表则也会初始化为随机值。

2. 初始化列表

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

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

【注意】

每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)
类中包含以下成员，必须放在初始化列表位置进行初始化：

引用成员变量
const成员变量
自定义类型成员(且该类没有默认构造函数时)

class A
{
public:
	A(int a)
		:_a(a)
	{}
private:
	int _a;
};

class B
{
public:
	B(int a, int ref)
		:_aobj(a)
		, _ref(ref)
		, _n(10)
	{}
private:
	A _aobj;  // 没有默认构造函数
	int& _ref;  // 引用
	const int _n; // const 
};

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

class Time
{
public:
	Time(int hour = 0)
		:_hour(hour)
	{
		cout << "Time()" << endl; //走初始化列表，不会调用函数体内的打印
	}
private:
		int _hour;
};

class Date
{
public:
	Date(int day)
	{}
private:
	int _day;
	Time _t;
};

int main()
{
	Date d(1); 
	return 0;
}

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

//A.输出1  1
//B.程序崩溃
//C.编译不通过
//D.输出1  随机值

在这里插入图片描述

声明顺序为初始化顺序，则先初始化_a2 ，再初始化_a1 。由于_a2使用_a1的值进行初始化，此时_a1还未进行初始化，值为随机值即_a2初始化为随机值，然后才将传参1给_a1进行初始化。

5. 声明处给缺省值

可供初始化列表使用进行初始化

class Date
{
public: 
	// 初始化列表是每个成员变量定义初始化的位置
	Date(int year, int month, int day)
		:_n(1)
		, _month(2)
	{
		// 赋值修改
		_year = year;
		_month = month;
		_day = day;
	}

private:
	// 声明
	int _year = 1;  // 缺省值
	int _month = 1;
	int _day;
	const int _n;
};

3. explicit关键字

3.1 隐式类型转换

单参数构造函数支持隐式类型转换（C++98）

class Date
{
public:
	// 1.单参构造函数，具有类型转换作用
	Date(int year)
	:_year(year)
{}
	// 2. 虽然有多个参数，但是创建对象时后两个参数可以不传递，也具有类型转换作用
	/*Date(int year, int month = 1, int day = 1)
	: _year(year)
	, _month(month)
	, _day(day)
	{}*/
private:
	int _year;
	int _month;
	int _day;
};

void Test()
{
	Date d1(2022);
	d1 = 2023; //实际为编译器用2023调用构造函数构造一个Date类的临时对象，
			   //再将该临时对象赋值给d1
	Date d2 = 2024; //原理相同，直接使用临时对象初始化d2
}

多参数构造函数支持隐式类型转换（C++11）

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

void Test()
{
	Date d1 = { 2022, 2023, 2024 }; //使用花括号包含多参数，原理同单参数隐式类型转换
}

在这里插入图片描述

观察上图代码，假如一个栈插入的数据为自定义类型，按以前所学我们要先定义该自定义类型的变量，再将该变量传参给栈接口；
而隐式类型转换可以帮助我们节省中间步骤，由编译器帮助我们进行，如st.Push(4); 实际上为编译器先用4创建一个C类型的临时对象，再将该临时对象传参给栈的插入接口。

3.2 explicit修饰

explicit修饰构造函数，会禁止隐式类型转换

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

void Test()
{
	Date d1 = { 2022, 2023, 2024 }; //报错
}

五、static成员

1. 概念

声明为static的类成员称为类的静态成员，用static修饰的成员变量，称之为静态成员变量；用static修饰的成员函数，称之为静态成员函数。
静态成员变量一般用私有封装在类中，避免被别人修改，也因此需要专门设置一个静态成员函数对其进行获取

2. 特性

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


class A
{
public:
	static int GetACount() //静态成员函数，类外可调用，返回私有变量值
	{
		return _scount; 
	}
private:
	static int _scount; //静态私有成员变量，只能在类内访问
};

六、友元

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

友元分为：友元函数和友元类

1. 友元函数

问题：现在尝试去重载operator<<，然后发现没办法将operator<<重载成成员函数。

class Date
{
public:
	Date(int year, int month, int day)
		: _year(year)
		, _month(month)
		, _day(day)
	{}
	ostream& operator<<(ostream& _cout)
	{
		//_cout 作为左操作数需要第一个参数为cout的输出流对象，而此时this指针占据了第一个参数的位置，导致不能使用
		_cout << _year << "-" << _month << "-" << _day << endl;
		return _cout;
	}
private:
	int _year;
	int _month;
	int _day;
};

因为cout的输出流对象和隐含的this指针在抢占第一个参数的位置。 规定操作符的第一个参数为左操作数，而作为成员函数，this指针占据了第一个参数的位置，导致cout需要的流对象处于第二个参数位置，无法正常传参调用。如果写成_year << _cout 可以正常使用，但不符合常规写法，所以只能将operator<<重载成全局函数，但这又会导致类外没办法访问成员，此时就需要友元来解决。operator>>同理。

友元函数：可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，但需要在类的内部声明，声明时需要加friend关键字。
说明:
友元函数可访问类的私有和保护成员，但不是类的成员函数
友元函数不能用const修饰
友元函数可以在类定义的任何地方声明，不受类访问限定符限制
一个函数可以是多个类的友元函数
友元函数的调用与普通函数的调用原理相同

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

2. 友元类

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

友元关系是单向的，不具有交换性。
【你把别人当朋友，别人不一定把你当朋友】比如上述Time类和Date类，在Time类中声明Date类为其友元类，那么可以在Date类中直接访问Time类的私有成员变量，但想在Time类中访问Date类中私有的成员变量则不行。
友元关系不能传递
如果C是B的友元， B是A的友元，则不能说明C时A的友元。
友元关系不能继承，在继承位置再给大家详细介绍

class Time
{
	friend class Date;   // 声明日期类为时间类的友元类，则在日期类中就直接访问Time类中的私有成员变量
public:
	Time(int hour = 0, int minute = 0, int second = 0)
		: _hour(hour)
		, _minute(minute)
		, _second(second)
	{}

private:
	int _hour;
	int _minute;
	int _second;
};

class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
		: _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. 概念

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

2. 特性

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

class A
{
private:
	static int k;
	int h;
public:
	class B // B天生就是A的友元
	{
	public:
		void foo(const A& a)
		{
			cout << k << endl;//OK
			cout << a.h << endl;//OK
		}
	};
};
int A::k = 1;

int main()
{
	A::B b;
	b.foo(A());

	return 0;
}

八、匿名对象

语法：生命周期只在当前一行
用处：①只为调用类的成员函数时（结合下方代码理解）

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

class B {
public:
	int Sum_Solution(int n) {
		//...
		return n;
	}
};
int main()
{
	A aa1; //定义有名对象 aa1
//	A aa1(); // 不能这么定义对象，因为编译器无法识别是一个函数声明，还是对象定义
	
	A(); // 但是我们可以这么定义匿名对象，匿名对象的特点不用取名字，
		// 但是他的生命周期只有这一行，我们可以看到下一行他就会自动调用析构函数

	A aa2(2); // 单纯为了调用类的成员函数而创建了对象aa2
	B().Sum_Solution(10); //使用匿名对象调用，用完即销毁，非常方便
	return 0;
}

九、拷贝对象时的一些编译器优化

在传参和传返回值的过程中，一般编译器会做一些优化，减少对象的拷贝，这个在一些场景下还是非常有用的。这里具体的优化我们不需要去记忆，只需要了解有作优化即可，不同的编译器优化不一样。

class A
{
public:
	A(int a = 0)
		:_a(a)
	{
		cout << "A(int a)" << endl;
	}
	A(const A& aa)
		:_a(aa._a)
	{
		cout << "A(const A& aa)" << endl;
	}
	A& operator=(const A& aa)
	{
		cout << "A& operator=(const A& aa)" << endl;
		if (this != &aa)
		{
			_a = aa._a;
		}
		return *this;
	}
	~A()
	{
		cout << "~A()" << endl;
	}
private:
	int _a;
};

void f1(A aa)
{}

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

int main()
{
	// 传值传参
	A aa1;
	f1(aa1);
	cout << endl;
	// 传值返回
	f2();
	cout << endl;
	// 隐式类型，连续构造+拷贝构造->优化为直接构造
	f1(1);
	// 一个表达式中，连续构造+拷贝构造->优化为一个构造
	f1(A(2));
	cout << endl;
	// 一个表达式中，连续拷贝构造+拷贝构造->优化一个拷贝构造
	A aa2 = f2();
	cout << endl;
	// 一个表达式中，连续拷贝构造+赋值重载->无法优化
	aa1 = f2();
	cout << endl;
	return 0;
}

十、练习题

1. 构造函数 + static成员变量

求1+2+3+…+n，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句【此处格外要求不使用：位运算、等差求和、递归】牛客网OJ链接

方法①

class Sum
{
public:
	//构造函数
    Sum()
    {
        _ret += _i;
        _i++;
    }
	//静态成员函数 -> 从外部获取被私有封装的静态成员变量
    static int GetRet()
    {
        return _ret;
    }
private:
    static int _i; //静态成员为所有类对象共享，每次调用修改都是这一个值
    static int _ret;
};

int Sum::_i = 1; //静态成员变量要在类外定义。且定义时不写static
int Sum::_ret = 0;

class Solution {
public:
    int Sum_Solution(int n) {
        Sum a[n]; //构造n个对象，调用n次构造函数达成连加的效果
        return Sum::GetRet();
    }
};

方法②（使用内部类 + 友元概念）

class Solution {
	//内部类，天生是外部类的友元可直接使用外部类的成员，因此可将static成员变量移到外部类，省去Get函数
    class Sum
    {
    public:
        Sum()
        {
            _ret += _i;
            _i++;
        }
    };

public:
    int Sum_Solution(int n)
    {
        Sum a[n]; 
        return _ret; //变量处在Solution类内，不需要使用Get函数
    }
private:
    static int _i;
    static int _ret;
};

int Solution::_i = 1;
int Solution::_ret = 0;

/*修订中------

2. 日期类相关

2.1

总结

本文介绍了类和对象的核心知识，知识框架可看文章开头的目录。
尽管文章修正了多次，但由于水平有限，难免有不足甚至错误之处，敬请各位读者来评论区批评指正。全文字数27k，感谢你能看到这里。

如泡似影

关注

51
点赞
踩
60

收藏

觉得还不错? 一键收藏
0
评论
【C++】拆分详解 - 类与对象

/ 类体：由成员函数和成员变量组成// 一定要注意后面的分号class为定义类的关键字ClassName为类的名字，{}中为类的主体，注意类定义结束时后面分号不能省略。类体中内容称为类的成员类中的变量称为类的属性或成员变量;类中的函数称为类的方法或者成员函数。声明和定义全部放在类体中，需注意：成员函数如果在类中定义，编译器可能会将其当成内联函数处理。类声明放在.h文件中，成员函数定义放在.cpp文件中，注意：成员函数名前需要加一般情况下，更期望采用第二种方式。
复制链接

扫一扫