【C++语法堂】C++类和对象

约定不等于承诺〃 2024-03-23 16:02 63阅读 0赞

**目录**

【1】面向过程和面向对象初步认识

【2】 类的引入

【3】类的定义

【4】类的访问限定符及封装

【4.1】 访问限定符

【4.2】成员变量命名规则的建议

【4.3】封装

【5】类的作用域

【6】类的实例化

【7】类对象模型

【7.1】如何计算类对象的大小

【7.2】类对象的存储方式猜测

【7.3】结构体内存对齐规则

【8】this指针

【8.1】 this指针的引出

【8.2】 this指针的特性

【8.3】C语言和C++实现Stack的对比

【9】类的6个默认成员函数

【9.1】构造函数

【9.1.1】概念

【9.1.2】特性

【9.2】 析构函数

【9.2.1】概念

【9.2.2】特性

【9.3】 拷贝构造函数

【9.3.1】概念

【9.3.2】特性

【10】赋值运算符重载

【10.1】 运算符重载

【10.2】 赋值运算符重载

【10.3】文本重载

【10.4】 隐式转换

【10.5】 日期类的实现

【11】const成员

【11.1】 const做数据成员

【11.2】 const做成员函数

【11.3】 const做对象

【11.4】 取地址及const取地址操作符重载

【12】在谈构造函数

【12.1】 构造函数体赋值

【12.2】 初始化列表

【12.3】explicit关键字

【13】static成员

【13.1】 概念

【13.2】 特性

【14】友元

【14.1】 友元函数

【14.2】 友元类

【15】内部类

【16】匿名对象

【17】拷贝对象时的一些编译器优化

--------------------

## **【1】面向过程和面向对象初步认识**  ##

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

![efd049f467614c66af96a310fa247256.png][]

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

![df54a7ea676343bab4037ec529aa407d.png][]

## **【2】 类的引入**  ##

**C语言结构体中只能定义变量，在C++中，结构体内不仅可以定义变量，也可以定义函数。**比如：之前在数据结构初阶中，用C语言方式实现的栈， **结构体中只能定义变量；**现在以**C++方式实现，会发现struct中也可以定义函数。**

#include<iostream>
    using namespace std;
    // 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(){
        // C++兼容C语言结构体.
        struct Stack s1;
        Stack s2;
        return 0;
    }

**这是c到c++的一个过度，上面结构体的定义，在C++中更喜欢用class来代替 。**

## **【3】类的定义**  ##

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

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

## **【4】类的访问限定符及封装**  ##

### **【4.1】 访问限定符**  ###

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

![cd1fab7322be42c2a11da9c069883a01.png][]

**【访问限定符说明】**

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

class Stack {
    public:// 访问限定符(共有).
    	// 成员函数.
    	void Init(int capacity = 4) {}
    	void Push(int val) {}
    	void Destory() {}
    
    protected:// 访问限定符(保护).
    
    private:// 访问限定符(私有).
    	// 成员变量.
    	int* _data;
    	int _size;
    	int _capacity;
    };

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

**问题：**C++中struct和class的区别是什么？

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

### **【4.2】成员变量命名规则的建议** ###

// 我们看看这个函数，是不是很僵硬？
    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;
    };
    // 其他方式也可以的，主要看公司要求。一般都是加个前缀或者后缀标识区分就行。

### **【4.3】封装**  ###

**【面试题】** 面向对象的三大特性：**封装、继承、多态。**

**问题：**在类和对象阶段，主要是研究类的封装特性，那什么是封装呢？

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

**封装本质上是一种管理，让用户更方便使用类。**

比如：对于电脑这样一个复杂的设备，提供给用户的就只有开关机键、通过键盘输入，显示器，USB插孔等，让用户和计算机进行交互，完成日常事务。但实际上电脑真正工作的却是CPU、显卡、内存等一些硬件元件。

![3e015a94fbe6453f9b4db170d71bb964.png][]

对于计算机使用者而言，不用关心内部核心部件，比如主板上线路是如何布局的，CPU内部是如何设计的等，用户只需要知道，怎么开机、怎么通过键盘和鼠标与计算机进行交互即可。因此**计算机厂商在出厂时，在外部套上壳子，将内部实现细节隐藏起来，仅仅对外提供开关机、鼠标以**及键盘插孔等，让用户可以与计算机进行交互即可。 在C++语言中实现封装，可以通过类将数据以及操作数据的方法进行有机结合，通过访问权限来隐藏对象内部实现细节，控制哪些方法可以在类外部直接被使用。

## **【5】类的作用域**  ##

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

**类的两种定义方式：**

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

![b8a917dc6746407d8871a3407d25a543.png][]

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

一般情况下，更期望采用第二种方式。

![17d4b09458884dafb4d09b9356f62620.png][]

**注意：**上课为了方便演示使用方式一定义类，大家后序工作中尽量使用第二种。

// 定义类
    class Person {
    public:
    	void PrintPersonInfo();
    
    private:
    	char* _name;
    	char* _gender;
    	int _age;
    };
    
    // 实现Person::ShowInfo();
    // 这里需要指定PrintPersonInfo是属于Person这个类域.
    void Person::PrintPersonInfo() {
    	cout << _name << " " << _gender << " " << _age << endl;
    }
    -----------------------------------------------------------------------------------------
    /* 类：栈 */
    class Stack {
    public:// 访问限定符(共有).
    	// 成员函数.
    	void Init(int capacity = 4);
    	void Push(int val);
    	void Destory();
    
    protected:// 访问限定符(保护).
    
    private:// 访问限定符(私有).
    	// 成员变量.
    	int* _buffer;
    	int _size;
    	int _capacity;
    };
    
    // 分离：成员函数实现.
    void Stack::Init(int capacity) {
    
    }
    // 分离：成员函数实现.
    void Stack::Push(int val) {
    
    }
    // 分离：成员函数实现.
    void Stack::Destory() {
    
    }
    -----------------------------------------------------------------------------------------
    /* 类：队里 */
    class Queue {
    public:// 访问限定符(共有).
    	// 成员函数.
    	void Init(int capacity = 4);
    	void Push(int val);
    	void Destory();
    
    protected:// 访问限定符(保护).
    
    private:// 访问限定符(私有).
    	// 成员变量.
    	int* _buffer;
    	int _size;
    	int _capacity;
    };
    
    // 分离：成员函数实现.
    void Queue::Init(int capacity) {
    
    }
    // 分离：成员函数实现.
    void Queue::Push(int val) {
    
    }
    // 分离：成员函数实现.
    void Queue::Destory() {
    
    }

## **【6】类的实例化**  ##

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

**类是对对象进行描述的**，是一个**模型**一样的东西，限定了类有哪些成员，定义出一个类**并没有分配实际的内存空间**来存储它；比如：入学时填写的学生信息表，表格就可以看成是一个类，来描述具体学生信息。

*  类就像谜语一样，对谜底来进行描述，谜底就是谜语的一个实例。
 *  谜语："年纪不大，胡子一把，主人来了，就喊妈妈" 谜底：山羊。
    
    一个类可以实例化出多个对象，**实例化出的对象 占用实际的物理空间，存储类成员变量。**

int main()
    {
    	Person._age = 100; // 编译失败：error C2059: 语法错误:“.”
    	return 0;
    }

Person类是没有空间的，只有Person类实例化出的对象才有具体的年龄。

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

![19b35f70eaf94bf483aeb93df78bf2a3.png][]

## **【7】类对象模型**  ##

### **【7.1】如何计算类对象的大小**  ###

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

如何计算一个类的大小？

class Person
    {
    public:
    	void PrintPersonInfo()
    	{
    		cout << _age << endl;
    	}
    
    private:
    	int _age;
    	char* _gender;
    	int _age;
    };
    
    int main()
    {
    	Person person;
    	cout << sizeof(Person) << endl;		// 4
    	cout << sizeof(person) << endl;		// 4
    	return 0;
    }

class A {
    public:
    	A() {
    		cout << "A()" << endl;
    	}
    
    private:
    	char _a;
    };
    
    
    int main() {
    	A a;
    	cout << sizeof(A) << endl;		// 1
    	cout << sizeof(a) << endl;		// 1
    
    	return 0;
    }

### **【7.2】类对象的存储方式猜测**  ###

*  **对象中包含类的各个成员**

![aca516c5baf647e9870138e45969cf9f.png][]

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

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

![e607334f6ec14d0ab00fb6cbb5c011d8.png][]

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

![37cd0e0176a140938ed7500a38c243e0.png][]

![62b48d668b7e4dcba70c38e4d3efcc5f.png][]

对上述三种存储方式，通过反编译进行观察：

class A {
    public:
    	A(char a) {
    		_a = a;
    	}
    
    public:
    	void PrintA() {
    		cout << _a << endl;
    	}
    
    private:
    	char _a;
    };
    
    
    int main() {
    	A a1('A');
    	A a2('B');
    	a1.PrintA();
    	a2.PrintA();
    	cout << sizeof(A) << endl;
    	cout << sizeof(a1) << endl;
    	cout << sizeof(a2) << endl;
    
    	return 0;
    }

![6e8b0541e6e649e0ae38d21470f43f36.png][]

**问题：**对于上述三种存储方式，那计算机到底是按照那种方式来存储的？

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

// 类中既有成员变量，又有成员函数
    class A1 {
    public:
    	void f1() {}
    private:
    	int _a;
    };
    // 类中仅有成员函数
    class A2 {
    public:
    	void f2() {}
    };
    // 类中什么都没有---空类
    class A3
    {};
    
    sizeof(A1) :  4  sizeof(A2) : 1  sizeof(A3) : 1

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

### **【7.3】结构体内存对齐规则**  ###

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

**【面试题】**

*  结构体怎么对齐？ 为什么要进行内存对齐？
 *  如何让结构体按照指定的对齐参数进行对齐？能否按照3、4、5即任意字节对齐？
 *  什么是大小端？如何测试某台机器是大端还是小端，有没有遇到过要考虑大小端的场景 。

## **【8】this指针**  ##

### **【8.1】 this指针的引出**  ###

我们先来定义一个日期类 Date

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

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

**代码原型：**

#pragma once  
    #include <iostream>
    using namespace std;
    
    class Date {
    public:
    	Date(int year, int month, int day) {
    		this->_year = year;				// this指针是可以显示用的！！！！！！！！
    		this->_month = month;
    		this->_day = day;
    	}
    
    public:
    	void Print(Date* this) {			// this指针不可以显示写和显示传！！！！！！
    		cout << _year << ":" << _month << ":" << _day << endl;
    	}
    
    private:
    	int _year;
    	int _month;
    	int _day;
    };
    
    int main() {
    	Date d1(2023, 04, 28);
    	Date d2(2023, 05, 29);
    	d1.Print();
    	d2.Print();
    
    	return 0;
    }

### **【8.2】 this指针的特性**  ###

*  this指针的类型：类类型\* const，即成员函数中，不能给this指针赋值。
 *  只能在“成员函数”的内部使用。
 *  this指针本质上是“成员函数”的形参，当对象调用成员函数时，将对象地址作为实参传递给this形参。所以对象中不存储this指针。
 *  this指针是“成员函数”第一个隐含的指针形参，一般情况由编译器通过ecx寄存器自动传递，不需要用户传递。

![9ed6b958b76e456e9b1b6d8ce7d36862.png][]

**【面试题】**

*  **this指针存在哪里？ 答：this指针存放到栈里**
 *  **this指针可以为空吗？ 答：不能**

// 1.下面程序编译运行结果是？ A、编译报错 B、运行崩溃 C、正常运行
    class A //（运行正常）成员函数不在对象中，在公共代码区.
    {
    public:
    	void Print()
    	{
    		cout << "Print()" << endl;
    	}
    private:
    	int _a;
    };
    int main()
    {
    	A* p = nullptr;
    	p->Print();
    	return 0;
    }
    // 1.下面程序编译运行结果是？ A、编译报错 B、运行崩溃 C、正常运行
    class A //（运行崩溃）引用了_a这个变量.
    {
    public:
    	void PrintA()
    	{
    		cout << _a << endl;
    	}
    private:
    	int _a;
    };
    int main()
    {
    	A* p = nullptr;
    	p->PrintA();
    	return 0;
    }

### **【8.3】C语言和C++实现Stack的对比**  ###

**以下是一段c写Stack的代码：**

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

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

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

**以下是一段c++写Stack的代码：**

#include<iostream>
    using namespace std;
    
    typedef int STKDataType;
    class Stack
    {
    public :
    	// 初始化
    	void Init()
    	{
    		_data = nullptr;
    		_top = _capacity = 0;
    	}
    
    	// 内存释放
    	void Destory()
    	{
    		free(_data);
    		_top = _capacity = 0;
    	}
    
    	// 入栈
    	void Push(STKDataType data)
    	{
    		// 检查容量
    		if (_top == _capacity)
    		{
    			// 扩容
    			size_t newCapacity = _capacity == 0 ? 4 : _capacity * 2;
    			STKDataType* pTemp = (STKDataType*)realloc(_data, sizeof(STKDataType) * newCapacity);
    			if (pTemp == nullptr)
    			{
    				perror("StackPush reallco fail");
    				exit(-1);
    			}
    			else
    			{
    				_data = pTemp;
    				_capacity = newCapacity;
    			}
    		}
    
    		_data[_top] = data;
    		_top++;
    	}
    
    	// 获取栈顶数据
    	STKDataType Top()
    	{
    		return _data[_top - 1];
    	}
    
    	// 出栈
    	void Pop()
    	{
    		_top--;
    	}
    
    
    	// 打印数据
    	void Print()
    	{
    		for (int i = 0; i <= GetSize(); i++)
    		{
    			cout << _data[i] << " ";
    		}
    		cout << endl;
    	}
    
    	// 获取栈中数据个数
    	int GetSize()
    	{
    		return (int)_top - 1;
    	}
    
    	// 判断栈中数据不为空
    	bool Empty()
    	{
    		return _top == 0;
    	}
    
    private:
    	STKDataType* _data;
    	size_t _top;
    	size_t _capacity;
    };
    
    int main()
    {
    	Stack stk;
    	stk.Init();
    	stk.Push(1);
    	stk.Push(2);
    	stk.Push(3);
    	stk.Push(4);
    	stk.Push(5);
    	cout << "入栈数据: " ;
    	stk.Print();
    
    	cout << endl << "出栈数据: ";
    	while (!stk.Empty())
    	{
    		cout << stk.Top() << " ";
    		stk.Pop();
    	}
    	cout << endl;
    	
    
    
    	stk.Destory();
    	return 0;
    }

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

## **【9】类的6个默认成员函数**  ##

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

class Date {};

### **【9.1】构造函数**  ###

#### **【9.1.1】概念**  ####

对于Date类，可以通过 Init 公有方法给对象设置日期，但如果每次创建对象时都调用该方法设置信息，未免有点麻烦，那能否在对象创建时，就将信息设置进去呢？ 构造函数是一个特殊的成员函数，名字与类名相同,创建类类型对象时由编译器自动调用，以保证每个数据成员都有 一个合适的初始值，并且在对象整个生命周期内只调用一次。

#include<iostream>
    using namespace std;
    
    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 date1(2022, 9, 22);
    	Date date2(2022, 9, 20);
    
    	date1.Print();
    	date2.Print();
    	return 0;
    }

#### **【9.1.2】特性**  ####

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

**其特征如下：**

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

#include<iostream>
    using namespace std;
    
    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:
    	int _year;
    	int _month;
    	int _day;
    };
    
    int main()
    {
    	Date date1(2022, 9, 22);
    	Date date2;
    
    	date1.Print();
    	date2.Print();
    	return 0;
    }
    
    //---------------------------------------------------------------------------------------
    
    #include<iostream>
    using namespace std;
    
    class Date
    {
    public :
    	// 无参构造函数。
    	//Date()
    	//{
    	//	_year = 1;
    	//	_month = 1;
    	//	_day = 1;
    	//}
    	// 带参构造函数。
    	Date(int year = 1, int month = 1, int day = 1)
    	{
    		_year = year;
    		_month = month;
    		_day = day;
    	}
    	
    	void Print()
    	{
    		cout << _year << "-" << _month << "-" << _day << endl;
    	}
    private:
    	int _year;
    	int _month;
    	int _day;
    };
    
    int main()
    {
    	Date date1(2022, 9, 22);
    	Date date2;
    
    	date1.Print();
    	date2.Print();
    	return 0;
    }

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

![44bbd8818bb64297b0b9256e0df9f025.png][]

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类中构造函数放开，代码编译失败，因为一旦显式定义任何构造函数，编译器将不再生成
    	// 无参构造函数，放开后报错：error C2512: “Date”: 没有合适的默认构造函数可用
    	Date d1;
    	return 0;
    }
    }

*  关于编译器生成的默认成员函数，很多童鞋会有疑惑：不实现构造函数的情况下，编译器会生成默认的构造函数。但是看起来默认构造函数又没什么用？d对象调用了编译器生成的默认构造函数，但是d对象*year/*month/\_day，依旧是随机值。也就说在这里编译器生成的默认构造函数并没有什么用？？

**解答：**\++把类型分成**(内置类型)、(基本类型)、(自定义类型)。**内置类型就是语言提供的数据类型。

如：int/char...，自定义类型就是我们使用class/struct/union等自己定义的类型，看看下面的程序，就会发现编译器生成默认的构造函数会对自定类型成员\_t调用的它的默认成员函数。

![ee5e9ca895b0413783e615eb1df7a1cb.png][]

#include <iostream>
    using namespace std;
    
    /* 类：栈 */
    class Stack {
    public:// 访问限定符(共有)
    	// 带参构造函数
    	Stack(int capacity = 4) {
    		_buffer = (int*)malloc(sizeof(int) * capacity);
    		if (_buffer == nullptr) {
    			perror("Stack malloc fail!");
    			exit(-1);
    		}
    
    		_size = 0;
    		_capacity = capacity;
    	}
    
    	~Stack() {
    		free(_buffer);
    		_buffer = nullptr;
    		_size = _capacity = 0;
    	}
    	
    private:// 访问限定符(私有)
    	int* _buffer;
    	int _size;
    	int _capacity;
    };
    
    class A {
    private:
    	Stack s1;
    	Stack s2;
    };
    
    /* 主程序入口 */
    int main()
    {
    	A A;
    	return 0;
    }

**注意：**C++11 中针对内置类型成员不初始化的缺陷，又打了补丁，即：内置类型成员变量在类中声明时可以给默认值。

class Time
    {
    public:
    	Time()
    	{
    		cout << "Time()" << endl;
    		_hour = 0;
    		_minute = 0;
    		_second = 0;
    	}
    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;
    }

*  无参的构造函数和全缺省的构造函数都称为默认构造函数，**并且默认构造函数只能有一个。**

**注意：**无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认构造函数。

int main()
    {
    	Date date1;
    	date1.Show();
    	Date date2(date1);
    	date2.Show();
    	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;
    }

### **【9.2】 析构函数**  ###

#### **【9.2.1】概念**  ####

通过前面构造函数的学习，我们知道一个对象是怎么来的，那一个对象又是怎么没呢的？ **析构函数：** 与构造函数功能相反，析构函数不是完成对对象本身的销毁，局部对象销毁工作是由编译器完成的。而**对象在销毁时会自动调用析构函数，完成对象中资源的清理工作。**

#### **【9.2.2】特性**  ####

**析构函数** 是特殊的成员函数，其特征如下：

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

#include<iostream>
    using namespace std;
    
    typedef int STKDataType;
    class Stack
    {
    public :
    	// 构造函数初始化
    	Stack(int capacity = 4)
    	{
    		_data = (STKDataType*)malloc(sizeof(STKDataType) * capacity);
    		if (_data == nullptr)
    		{
    			perror("Stack malloc fail\n");
    			exit(-1);
    		}
    		else
    		{
    			_capacity = capacity;
    			_top = 0;
    		}
    	}
        
        // 内存释放
    	//void Destory()
    	//{
    	//	free(_data);
    	//	_top = _capacity = 0;
    	//}
    
    	// 析构函数清理内存
    	~Stack()
    	{
    		free(_data);
    		_data = nullptr;
    		_top = _capacity = 0;
    	}
    
    	// 入栈
    	void Push(STKDataType val)
    	{
    		// 检查容量
    		if (_top == _capacity)
    		{
    			// 扩容
    			size_t newCapacity = _capacity == 0 ? 4 : _capacity * 2;
    			STKDataType* pTemp = (STKDataType*)realloc(_data, sizeof(STKDataType) * newCapacity);
    			if (pTemp == NULL)
    			{
    				perror("StackPush reallco fail");
    				exit(-1);
    			}
    			else
    			{
    				_data = pTemp;
    				_capacity = newCapacity;
    			}
    		}
    
    		_data[_top] = val;
    		_top++;
    	}
    
    	// 获取栈顶数据
    	STKDataType Top()
    	{
    		return _data[_top - 1];
    	}
    
    	// 出栈
    	void Pop()
    	{
    		_top--;
    	}
    
    
    	// 打印数据
    	void Print()
    	{
    		for (int i = 0; i <= GetSize(); i++)
    		{
    			cout << _data[i] << " ";
    		}
    		cout << endl;
    	}
    
    	// 获取栈中数据个数
    	int GetSize()
    	{
    		return (int)_top - 1;
    	}
    
    	// 判断栈中数据不为空
    	bool Empty()
    	{
    		return _top == 0;
    	}
    
    private:
    	STKDataType* _data;
    	size_t _top;
    	size_t _capacity;
    };
    
    int main()
    {
    	Stack stk;
    	stk.Push(1);
    	stk.Push(2);
    	stk.Push(3);
    	stk.Push(4);
    	stk.Push(5);
    	cout << "入栈数据: " ;
    	stk.Print();
    
    	cout << endl << "出栈数据: ";
    	while (!stk.Empty())
    	{
    		cout << stk.Top() << " ";
    		stk.Pop();
    	}
    	cout << endl;
    
    	return 0;
    }

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

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;
    }
    // 程序运行结束后输出：~Time()
    // 在main方法中根本没有直接创建Time类的对象，为什么最后会调用Time类的析构函数？
    // 因为：main方法中创建了Date对象d，而d中包含4个成员变量，其中_year, _month,_day三个是
    // 内置类型成员，销毁时不需要资源清理，最后系统直接将其内存回收即可；而_t是Time类对象，所以在
    // d销毁时，要将其内部包含的Time类的_t对象销毁，所以要调用Time类的析构函数。但是：main函数
    // 中不能直接调用Time类的析构函数，实际要释放的是Date类对象，所以编译器会调用Date类的析构函
    // 数，而Date没有显式提供，则编译器会给Date类生成一个默认的析构函数，目的是在其内部调用Time
    // 类的析构函数，即当Date对象销毁时，要保证其内部每个自定义对象都可以正确销毁
    // main函数中并没有直接调用Time类析构函数，而是显式调用编译器为Date类生成的默认析构函数
    // 注意：创建哪个类的对象则调用该类的析构函数，销毁那个类的对象则调用该类的析构函数

*  如果类中没有申请资源时，析构函数可以不写，直接使用编译器生成的默认析构函数，比如Date类；有资源申请时，一定要写，否则会造成资源泄漏，比如Stack类。

### **【9.3】 拷贝构造函数**  ###

#### **【9.3.1】概念**  ####

在现实生活中，可能存在一个与你一样的自己，我们称其为双胞胎 .

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

#### **【9.3.2】特性** ####

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

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

class Date
    {
    public:
    	Date(int year = 1900, int month = 1, int day = 1)
    	{
    		_year = year;
    		_month = month;
    		_day = day;
    	}
    	// Date(const Date& d) // 正确写法
    	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);
    	return 0;
    }

![4771717f6c3940baa44aaacb08963695.png][]

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

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

**注意：**在编译器生成的默认拷贝构造函数中，内置类型是按照字节方式直接拷贝的，而自定 义类型是调用其拷贝构造函数完成拷贝的。

*  **编译器生成的默认拷贝构造函数已经可以完成字节序的值拷贝了,**还需要自己显式实现吗？当然像日期类这样的类是没必要的。那么下面的类呢？验证一下试试？

// 这里会发现下面的程序会崩溃掉？这里就需要我们以后讲的深拷贝去解决。
    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;
    }

![d9f08f0d9cab44f3ad11d91a7216dc11.png][]

![93b6f47d547a472ab3f2a51a9fe5c5d8.png][]

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

// 正确书写方式：
    #include <iostream>
    using namespace std;
    
    /* 类：栈 */
    class Stack {
    public:// 访问限定符(共有)
    	// 带参构造函数
    	Stack(int capacity = 4) {
    		_buffer = (int*)malloc(sizeof(int) * capacity);
    		if (_buffer == nullptr) {
    			perror("Stack malloc fail!");
    			exit(-1);
    		}
    
    		_size = 0;
    		_capacity = capacity;
    	}
    
    	// 拷贝构造>深拷贝
    	Stack(const Stack& s) {
    		_buffer = (int*)malloc(sizeof(int) * s._capacity);
    		if (_buffer == nullptr) {
    			perror("Stack(const Stack& s) malloc fail!");
    			exit(-1);
    		}
    
    		memcpy(_buffer, s._buffer, s._size);
    		_size = s._size;
    		_capacity = s._capacity;
    	}
    
    	~Stack() {
    		free(_buffer);
    		_buffer = nullptr;
    		_size = _capacity = 0;
    	}
    
    public:
    	void Push(const int iVal) {
    		// ...
    		_buffer[_size++] = iVal;
    	}
    	
    private:// 访问限定符(私有)
    	int* _buffer;
    	int _size;
    	int _capacity;
    };
    
    /* 主程序入口 */
    int main()
    {
    	// 演示默认的拷贝构造：
    	Stack s1;
    	s1.Push(1);
    	s1.Push(2);
    	// 深拷贝.
    	Stack s2(s1);
    
    	return 0;
    }

*  拷贝构造函数典型调用场景：
    
     *  使用已存在对象创建新对象
     *  函数参数类型为类类型对象
     *  函数返回值类型为类类型对象

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

![9a8158b4740d47c290b250a353884523.png][]

为了提高程序效率，一般对象传参时，尽量使用引用类型，返回时根据实际场景，能用引用尽量使用引用。

## **【10】赋值运算符重载**  ##

### **【10.1】 运算符重载**  ###

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

**注意：**

*  不能通过连接其他符号来创建新的操作符：比如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;
    }

### **【10.2】 赋值运算符重载**  ###

1.  赋值运算符重载格式:

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

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

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

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

![81b8dbf3774a4a45a868c9d4b24cd48a.png][]

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

既然**编译器生成的默认赋值运算符重载函数已经可以完成字节序的值拷贝了，**还需要自己实 现吗？当然像日期类这样的类是没必要的。那么下面的类呢？验证一下试试？

#include<iostream>
    using namespace std;
    
    typedef int STKDataType;
    class Stack
    {
    public:
    	Stack(int defaultCapacity = 4)
    	{
    		STKDataType* pNewBuffer = (STKDataType*)malloc(sizeof(STKDataType) * defaultCapacity);
    		if (pNewBuffer == nullptr)
    		{
    			perror("Stack Stack malloc fail!");
    			exit(-1);
    		}
    		else
    		{
    			_array = pNewBuffer;
    			pNewBuffer = nullptr;
    
    			_top = 0;
    			_capacity = defaultCapacity;
    		}
    	}
        
    	~Stack()
    	{
    		free(_array);
    		_array = nullptr;
    
    		_top = _capacity = 0;
    	}
    
    	void Push(STKDataType val)
    	{
    		// 检查容量
    		if (_top == _capacity)
    		{
    			// 进行扩容
    			size_t newCapacity = _capacity * 2;
    			STKDataType* pNewBuffer = (STKDataType*)realloc(_array, sizeof(STKDataType) * newCapacity);
    			if (pNewBuffer == nullptr)
    			{
    				perror("Stack Push realloc fail!");
    				exit(-1);
    			}
    			else
    			{
    				_array = pNewBuffer;
    				pNewBuffer = nullptr;
    
    				_capacity = newCapacity;
    				newCapacity = 0;
    			}
    		}
    
    		// 插入数据
    		_array[_top] = val;
    		_top++;
    	}
    
    	STKDataType Top()
    	{
    		if (!Empty())
    		{
    			cout << "栈为空栈" << endl;
    			return -1;
    		}
    		return _array[_top - 1];
    	}
    
    	void Pop()
    	{
    		if (!Empty())
    		{
    			cout << "栈为空栈" << endl;
    			return ;
    		}
    		_top--;
    	}
    
    	int Size()
    	{
    		return (int)_top - 1;
    	}
    
    
    	bool Empty()
    	{
    		return _top != 0;
    	}
    
    private:
    	STKDataType* _array;
    	size_t _top;
    	size_t _capacity;
    };
    
    int main()
    {
    	Stack pSTK1(8);
    	pSTK1.Push(1);
    	pSTK1.Push(2);
    
    	Stack pSTK2(8);
    	pSTK2.Push(100);
    	pSTK2.Push(101);
    
    	pSTK1 = pSTK2;		// 报错，同一块内存空间被析构了两次。
    
    	return 0;
    }

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

![1dafbc7dc5dd4c039e06db5d6c9b2ff9.png][]

// pSTK1 = pSTK2;
    Stack& operator=(const Stack& stack)
    {
    	free(_array);
    	STKDataType* pNewCapacity = (STKDataType*)malloc(sizeof(STKDataType) * stack._capacity);
    	if (pNewCapacity == nullptr)
    	{
    		perror("Stack Operator= malloc fail!");
    		exit(-1);
    	}
    
    
    	// void *memcpy(void *str1, const void *str2, size_t n)
    	// str1 -- 指向用于存储复制内容的目标数组，类型强制转换为 void* 指针。
    	// str2 -- 指向要复制的数据源，类型强制转换为 void* 指针。
    	// n	   -- 要被复制的字节数。
    	memcpy(_array, stack._array, sizeof(STKDataType) * stack._capacity);
    	_top = stack._top;
    	_capacity = stack._capacity;
    	
    	return *this;
    }

#include<iostream>
    #include<string.h>
    using namespace std;
    
    typedef int STKDataType;
    class Stack
    {
    public:
    	Stack(int defaultCapacity = 4)
    	{
    		STKDataType* pNewBuffer = (STKDataType*)malloc(sizeof(STKDataType) * defaultCapacity);
    		if (pNewBuffer == nullptr)
    		{
    			perror("Stack Stack malloc fail!");
    			exit(-1);
    		}
    		else
    		{
    			_array = pNewBuffer;
    			pNewBuffer = nullptr;
    
    			_top = 0;
    			_capacity = defaultCapacity;
    		}
    	}
    
    	~Stack()
    	{
    		free(_array);
    		_array = nullptr;
    
    		_top = _capacity = 0;
    	}
    
    
    	// pSTK1 = pSTK2;
    	Stack& operator=(const Stack& stack)
    	{
    		if (this != &stack)
    		{
    			free(_array);
    			STKDataType* pNewCapacity = (STKDataType*)malloc(sizeof(STKDataType) * stack._capacity);
    			if (pNewCapacity == nullptr)
    			{
    				perror("Stack Operator= malloc fail!");
    				exit(-1);
    			}
    
    
    			// void *memcpy(void *str1, const void *str2, size_t n)
    			// str1 -- 指向用于存储复制内容的目标数组，类型强制转换为 void* 指针。
    			// str2 -- 指向要复制的数据源，类型强制转换为 void* 指针。
    			// n	   -- 要被复制的字节数。
    			memcpy(_array, stack._array, sizeof(STKDataType) * stack._capacity);
    			_top = stack._top;
    			_capacity = stack._capacity;
    		}
    		
    		return *this;
    	}
    
    
    	void Push(STKDataType val)
    	{
    		// 检查容量
    		if (_top == _capacity)
    		{
    			// 进行扩容
    			size_t newCapacity = _capacity * 2;
    			STKDataType* pNewBuffer = (STKDataType*)realloc(_array, sizeof(STKDataType) * newCapacity);
    			if (pNewBuffer == nullptr)
    			{
    				perror("Stack Push realloc fail!");
    				exit(-1);
    			}
    			else
    			{
    				_array = pNewBuffer;
    				pNewBuffer = nullptr;
    
    				_capacity = newCapacity;
    				newCapacity = 0;
    			}
    		}
    
    		// 插入数据
    		_array[_top] = val;
    		_top++;
    	}
    
    	STKDataType Top()
    	{
    		if (!Empty())
    		{
    			cout << "栈为空栈" << endl;
    			return -1;
    		}
    		return _array[_top - 1];
    	}
    
    	void Pop()
    	{
    		if (!Empty())
    		{
    			cout << "栈为空栈" << endl;
    			return ;
    		}
    		_top--;
    	}
    
    	int Size()
    	{
    		return (int)_top - 1;
    	}
    
    
    	bool Empty()
    	{
    		return _top != 0;
    	}
    
    private:
    	STKDataType* _array;
    	size_t _top;
    	size_t _capacity;
    };
    
    
    int main()
    {
    	Stack pSTK1(8);
    	pSTK1.Push(1);
    	pSTK1.Push(2);
    
    	Stack pSTK2(8);
    	pSTK2.Push(100);
    	pSTK2.Push(101);
    	pSTK2.Push(103);
    
    	pSTK1 = pSTK2;		// 报错，同一块内存空间被析构了两次。
    
    	return 0;
    }

### **【10.3】文本重载** ###

所谓的文本重载，就是重载后缀，是固定的写法。

*  函数参数：一定是：unsigned long类型
 *  函数名：operator""要重载的后缀 --- 一般重载后缀采用下划线系列。
    
     *  一个运算符或者一个后缀只能重载/被重载。

// 小时转换为秒.
    unsigned long long operator"" _h(unsigned long long num)
    {
    	return num * 3600;
    }
    
    // 分钟转换为秒.
    unsigned long long operator"" _min(unsigned long long num)
    {
    	return num * 60;
    }
    
    // 秒转换为秒.
    unsigned long long operator"" _s(unsigned long long num)
    {
    	return num;
    }
    
    
    int main()
    {
    	cout << 1_h << endl;
    	cout << 1_min << endl;
    	cout << 1_s << endl;
    
    	// 计算时间戳.
    	unsigned long long Date = 1_h + 1_min + 1_s;
    	cout << Date << endl;
    	return 0;
    }

### **【10.4】 隐式转换** ###

所谓的隐式转换就是让对象直接赋值给普通数据。

class MM
    {
    public:
    	friend ostream& operator<<(ostream& out, const MM& m);
    
    public:
    	MM(string name = "", double money = 0)
    		: _name(name)
    		, _money(money)
    	{}
    
    	// 隐式转换运算符重载.
    	operator string()
    	{
    		return this->_name;
    	}
    	// 饮食转换运算符重载.
    	operator int()
    	{
    		return this->_money;
    	}
    
    private:
    	string _name;
    	double _money;
    };
    
    inline ostream& operator<<(ostream& out, const MM& m)
    {
    	out << m._name << " " << m._money << endl;
    	return out;
    }
    
    
    int main()
    {
    	MM m("ShaXiang", 22);
    	cout << m << endl;
    	
    	string s = m;
    	int i = m;
    	cout << s << " " << i << endl;
    
    	return 0;
    }

### **【10.5】 日期类的实现** ###

#include<iostream>
    using namespace std;
    
    class Date
    {
        // 友元声明(可以在类中的任何位置)
    	friend ostream& operator<<(ostream& out, const Date& d);
    	friend istream& operator>>(istream& in, Date& d);
    public:
    	// 构造函数 - 初始化
    	Date(int year, int month, int day)
    	{
    		_year = year;
    		_month = month;
    		_day = day;
    
    		if (!((year >= 1) && (month >= 1 && month <= 12) && day <= (GetMonthDay(year, month))))
    		{
    			cout << "日期的规格不正确！" << endl;
    		}
    	}
    
    	// 构造函数 - 拷贝
    	Date(const Date& d)
    	{
    		_year = d._year;
    		_month = d._month;
    		_day = d._day;
    	}
    
    	// 析构函数 - 释放
    	~Date()
    	{
    		//...
    	}
    
    	// 获取年->月的天数。
    	int GetMonthDay(int year, int month);
    
    	// 运算符重载 - 等于
    	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);
    
    	// 运算符重载 - 加等于
    	Date& operator+=(const int day);
    
    	// 运算符重载 - 加
    	Date operator+(const int day);
    
    	// 运算符重载 - 减等于
    	Date& operator-=(const int day);
    
    	// 运算符重载 - 减
    	Date operator-(const int day);
    
    	// 运算符重载 - 前置加加
    	Date& operator++();
    
    	// 运算符重载 - 后置加加
    	Date operator++(int);
    
    	// 运算符重载 - 前置减减
    	Date& operator--();
    
    	// 运算符重载 - 后置减减
    	Date operator--(int);
    
        // 运算符重载 - 日期减法
    	int operator-(const Date& d);
    
    
    
    	// 打印当前的年份
    	void Print();
    	
    private:
    	int _year;
    	int _month;
    	int _day;
    };

#include"Date.h"
    // 获取年->月的天数。
    int Date::GetMonthDay(int year, int month)
    {
    	// 定义静态变量，可以省去频繁开辟控件。
    	static int getMonthDayArray[13] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
    	// 特殊：闰年的2月是特殊的29天。
    	if (month == 2 && ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)))
    	{
    		return 29;
    	}
    	else
    	{
    		return getMonthDayArray[month];
    	}
    }
    
    // 运算符重载 - 等于
    bool Date::operator==(const Date& d)
    {
    	return (_year == d._year && _month == d._month && _day == d._day);
    }
    
    // 运算符重载 - 大于
    bool Date::operator>(const Date& d)
    {
    	if (_year > d._year)
    		return true;
    	else if (_year == d._year && _month > d._month)
    		return true;
    	else if (_year == d._year && _month == d._month && _day > d._day)
    		return true;
    	else
    		return false;
    }
    
    // 运算符重载 - 大于等于
    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+=(const int day)
    {
    	if (day < 0)
    	{
    		return *this -= -day;
    	}
    
    	_day += day;
    	while (_day > GetMonthDay(_year, _month))
    	{
    		_day -= GetMonthDay(_year, _month);
    		_month++;
    
    		if (_month == 13)
    		{
    			_year++;
    			_month = 1;
    		}
    	}
    
    	return *this;
    }
    
    // 运算符重载 - 加
    Date Date::operator+(const int day)
    {
    	Date ret(*this);
    
    	ret += day;
    	return ret;
    }
    
    // 运算符重载 - 减等于
    Date& Date::operator-=(const int day)
    {
    	if (day < 0)
    	{
    		return *this += -day;
    	}
    
    	_day -= day;
    	while (_day <= 0)
    	{
    		_month--;
    		if (_month == 0)
    		{
    			_year--;
    			_month = 12;
    		}
    
    		_day += GetMonthDay(_year, _month);
    	}
    
    	return *this;
    }
    
    // 运算符重载 - 减
    Date Date::operator-(const int day)
    {
    	Date ret(*this);
    
    	ret -= day;
    
    	return ret;
    }
    
    // 运算符重载 - 前置加加
    Date& Date::operator++()
    {
    	*this += 1;
    	return *this;
    }
    
    // 运算符重载 - 后置加加
    Date Date::operator++(int)
    {
    	Date ret(*this);
    	*this += 1;
    	return ret;
    }
    
    // 运算符重载 - 前置减减
    Date& Date::operator--()
    {
    	*this -= 1;
    	return *this;
    }
    
    // 运算符重载 - 后置减减
    Date Date::operator--(int)
    {
    	Date ret(*this);
    	*this -= 1;
    	return ret;
    }
    
    // 运算符重载 - 日期减法
    int Date::operator-(const Date& d)
    {
    	// 假设母体为大日期，传引用为小日期
    	Date MaxDate = *this;
    	Date MinDate = d;
    	int flag = 1;
    
    	// 判断
    	if (*this < d)
    	{
    		MaxDate = d;
    		MinDate = *this;
    		flag = -1;
    	}
    
    	int n = 0;
    	while (MinDate != MaxDate)
    	{
    		++n;
    		++MinDate;
    	}
    
    	return n * flag;
    }
    
    
    // 运算符重载 - <<
    inline ostream& operator<<(ostream& out, const Date& d)
    {
    	out << d._year << "年" << d._month << "月" << d._day << "日" << endl;
    
    	return out;
    }
    
    inline istream& operator>>(istream& in, Date& d)
    {
    	in >> d._year >> d._month >> d._day ;
    
    	return in;
    }
    
    
    // 打印当前的年份
    void Date::Print()
    {
    	cout << _year << "-" << _month << "-" << _day << endl;
    }

## **【11】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();
    }
    class Date
    {
    public:
    	Date* operator&()
    	{
    		return this;
    	}
    }

### **【11.1】 const做数据成员** ###

*  **不能**被修改const成员
 *  初始化必须采用**初始化列表**

### **【11.2】 const做成员函数** ###

*  写法上比较特殊的写法，const修饰函数，写在函数的后面。、
 *  const函数和普通函数可以**共存。**
 *  普通对象优先调用普通对象。
 *  常对象只能调用常对象。
 *  const函数不能修改数据成员。

### **【11.3】 const做对象** ###

*  常对象只能调用常成员函数。

// const测试案例
    class Girl
    {
    public:
    	Girl(string name, int age)
    		: _name(name)
    		, _age(age)
    	{}
    
    	void Print()
    	{
    		cout << "普通对象优先调用普通对象。" << endl;
    		cout << _name << "\t" << _age << endl;
    	}
    
    	void Print() const
    	{
    		cout << "常对象只能调用常对象。" << endl;
    		cout << _name << "\t" << _age << endl;
    	}
    
    	void PrintDate()
    	{
    		cout << "" << endl;
    		cout << _name << "\t" << _age << endl;
    	}
    
    protected:
    	string _name;
    	int _age;
    };
    
    int main()
    {
    	Girl girl1("MM", 19);		// 调用普通对象.
    	girl1.Print();
    
    	const Girl girl2("SS", 20); // 调用常对象.
    	girl2.Print();
    	// girl2.PrintDate();		// 报错.
    	return 0;  
    }

### **【11.4】 取地址及const取地址操作符重载**  ###

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

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

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

## **【12】在谈构造函数** ##

### **【12.1】 构造函数体赋值**  ###

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

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

虽然上述构造函数调用之后，对象中已经有了一个初始值，但是不能将其称为对对象中成员变量的初始化，**构造函数体中的语句只能将其称为赋初值**，而不能称作初始化。**因为初始化只能初始化一次，而构造函数体内可以多次赋值。**

### **【12.2】 初始化列表**  ###

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

// 对象每个成员什么时候定义初始化呢？ --> 初始化列表
    // 每个成员都要走初始化列表，就算不显示在初始化列表写，也会走！
    // 如果没有在初始化列表显示初始化:
    // 1、内置类型，有缺省值用缺省值，没有缺省值会用随机值。
    // 2、自定义类型，调用默认它的构造函数，如果没有默认构造函数就会报错。
    class Date
    {
    public:
    	Date(int year = 1, int month = 1, int day = 1)
    		:_year(year)
    		,_month(month)
    		,_day(day)
    	{}
    
    private:
    	int _year;
    	int _month;
    	int _day;
    };
    
    int main()
    {
    	Date d;
    
    	return 0;
    }
    
    -----------------------------------------------------------------------------------------
    
    class Stack {
    public:// 访问限定符(共有)
    	// 带参构造函数
    	Stack(int capacity = 4) 
    		: _size(0)
    		, _capacity(capacity) 
    	{
    
    		_buffer = (int*)malloc(sizeof(int) * capacity);
    		if (_buffer == nullptr) {
    			perror("Stack malloc fail!");
    			exit(-1);
    		}
    
    		_size = 0;
    		_capacity = capacity;
    	}
    
    	~Stack() {
    		free(_buffer);
    		_buffer = nullptr;
    		_size = _capacity = 0;
    	}
    
    public:
    	void Push(const int iVal) {
    		// ...
    		_buffer[_size++] = iVal;
    	}
    
    private:// 访问限定符(私有)
    	int* _buffer;
    	int _size;
    	int _capacity;
    };

【注意】

*  每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)
 *  类中包含以下成员，必须放在初始化列表位置进行初始化：
    
     *  引用成员变量
     *  const成员变量
     *  自定义类型成员(且该类没有默认构造函数时)

class A
    {
    public:
    	A(int a)
    		:_a(a)
    	{
    
    	}
    private:
    	int _a = 100;
    
    };
    
    class B
    {
    public:
    	B(int a, int ref)
    		: _createA(a)
    		, _createRef(ref)
    		, _createN(200)
    	{
    
    	}
    
    private:
    	A _createA;				// 没有默认构造函数的自定义类型。
    	int& _createRef;		// 引用类型。
    	const int _createN;		// const类型。
    };
    
    
    int main()
    {
    	int cRef = 10;
    	B b(1, cRef);
    	
    
    	return 0;
    }

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

class A
    {
    public:
    	A(int a = 1000)		// 使用默认构造函数
    		:_a(a)
    	{
    
    	}
    private:
    	int _a = 100;
    
    };
    
    class B
    {
    public:
    	B(int a, int ref)
    		//： _createA(a)
    		: _createRef(ref)
    		, _createN(200)
    	{
    
    	}
    
    private:
    	A _createA;				// 没有默认构造函数的自定义类型。
    	int& _createRef;		// 引用类型。
    	const int _createN;		// const类型。
    };
    
    
    int main()
    {
    	int cRef = 10;
    	B b(1, cRef);
    	
    
    	return 0;
    }

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

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 随机值  √

### **【12.3】explicit关键字**  ###

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

class Date
    {
    public:
    	// 1. 单参构造函数，没有使用explicit修饰，具有类型转换作用
    // explicit修饰构造函数，禁止类型转换---explicit去掉之后，代码可以通过编译
    	explicit Date(int year)
    		:_year(year)
    	{}
    	/*
    	// 2. 虽然有多个参数，但是创建对象时后两个参数可以不传递，没有使用explicit修饰，具
    	有类型转换作用
    	// explicit修饰构造函数，禁止类型转换
    	explicit Date(int year, int month = 1, int day = 1)
    	: _year(year)
    	, _month(month)
    	, _day(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;
    };
    void Test()
    {
    	Date d1(2022);
    	// 用一个整形变量给日期类型对象赋值
    	// 实际编译器背后会用2023构造一个无名对象，最后用无名对象给d1对象进行赋值
    	d1 = 2023;
    	// 将1屏蔽掉，2放开时则编译失败，因为explicit修饰构造函数，禁止了单参构造函数类型转换的作用
    }

## **【13】static成员**  ##

### **【13.1】 概念**  ###

声明为**static的类成员**称为**类的静态成员，**用static修饰的成员变量，称之为静态**成员变量；**用static修饰的**成员函数，**称之为**静态成员函数。静态成员变量一定要在类外进行初始化** **面试题：**实现一个类，计算程序中创建出了多少个类对象。

#include<iostream>
    using namespace std;
    
    class A
    {
    public:
    	A(int a = 1)
    		:_a(a)
    	{
    		N++;
    	}
    
    	A(const A& a)
    		:_a(a._a)
    	{
    		N++;
    	}
    	
    	// 静态函数没有this*指针，只能访问静态成员。
    	static int GetStaticN()
    	{
    		// _a = 12;
    		return N;
    	}
    
    private:
    	int _a;
    
    	static int N;	// 静态成员变量。
    };
    
    
    void Func1()
    {
    	A a1;
    }
    
    A Func2()
    {
    	A a1;
    	return a1;
    }
    
    
    // 静态成员变量生命周期属于全局，但是受到类域的限制。
    int A::N = 0;		
    int main()
    {
    	A a1(1);		// 调用一次构造函数
    	A a2 = 2;		// 调用一次拷贝构造
    	Func1();		// 调用一次构造函数
    	A a3 = Func2(); // 调用一次构造函数，返回值在调用一次拷贝构造
    
    	cout << A::GetStaticN() << endl;
    	return 0;
    }

### **【13.2】 特性**  ###

*  静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区
 *  静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明
 *  静态成员依旧受权限限定的。
 *  静态成员的访问：通过对象去访问、直接类名限定访问。
 *  类静态成员即可用 类名::静态成员 或者 对象.静态成员 来访问
 *  静态成员函数没有隐藏的this指针，不能访问任何非静态成员
 *  静态成员也是类的成员，受public、protected、private 访问限定符的限制
 *  使用static修饰的数据或者函数，叫做静态静态成员。
 *  静态数据必须在类外做初始化，类初始化不需要static修饰。

// 测试案例
    class Login
    {
    public:
    	Login(string name)
    		: _name(name)
    	{
    		++_count;
    	}
    
    public:
    	static void Print()
    	{
    		// _name 没办法调用，因为没有this指针.
    		// 不能访问非静态成员.
    		cout << _name << "\t" << _count << endl;	// 错误不可以访问.
    	}
    
    	static void PrintCount()
    	{
    		// 可以访问静态成员.
    		cout << _count << endl;
    	}
    
    	static void PrintCount(Login& m)
    	{
    		// 采用传参的方式：
    		cout << m._count << endl;
    		// 采用创建对象的方式
    		Login l("ShaXiang");
    		cout << l._name << l._count << endl;
    	}
    
    
    
    public:
    	// static int count = 0;	// 静态成员必须在类外初始化.
    	static int _count;			// 静态成员。
    protected:
    	string _name;
    };
    
    int Login::_count = 0;	// 类外进行初始化.
    
    
    int main()
    {
    	// 每一次创建对象_count都会进行计数.
    	// 静态数据是所有对象共享的.
    	Login xiaomei("小美");
    	cout << xiaomei._count << endl;	// 对象访问方式  1
    	cout << Login::_count << endl;	// 类名访问      1
    
    	Login xiaohua("小花");
    	cout << xiaomei._count << endl;	// 对象访问方式  2
    	cout << Login::_count << endl;	// 类名访问      2
    
    	return 0;
    }

**利用static的特性练习几道题目：**

**牛客专题 - JZ64** 求1+2+3+...+n

**连接：**[求1+2+3+...+n牛客题霸牛客网 (nowcoder.com)][1_2_3_..._n_ _nowcoder.com]

// 定义一个多次调用的类
    class Sum
    {
    public:
        Sum()
        {
            _ret += _i;
            ++_i;
        }
    
        // 静态函数
        static int Ret()
        {
            return _ret;
        }
    
    private:
        // 静态成员。
        static int _i;
        static int _ret;
    };
    
    // 静态变量的外部初始化。
    int Sum::_i = 1;
    int Sum::_ret = 0;
    
    class Solution {
    public:
        int Sum_Solution(int n) {
            Sum arr[n];
    
            return Sum::Ret();
        }
    };

// 场景：限制调用构造函数
    #include<iostream>
    using namespace std;
    
    class A
    {
    public:
    	// 利用static函数创建对象
    	static A GetObj(int a)
    	{
    		A aa(a);
    		return aa;
    	}
    
    private:
    	// 私有的构造函数
    	A(int a)
    		:_a(a)
    	{}
    private:
    	int _a;
    };
    
    int main()
    {
    	A aaa = A::GetObj(1);
    
    	return 0;
    }

【问题】

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

答：不可以

## **【14】友元**  ##

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

### **【14.1】 友元函数**  ###

**问题：**现在尝试去重载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;
    };
    
    // 使用友元函数
    class Date
    {
    public:
         ostream& operator<<(ostream& out, const Date& d);
        
    public:
    	Date(int year, int month, int day)
    		: _year(year)
    		, _month(month)
    		, _day(day)
    	{}
        
    private:
    	int _year;
    	int _month;
    	int _day;
    };
    
    // 类外声明：
    inline ostream& operator<<(ostream& out, const Date& d)
    {
    	out << d._year << "-" << d._month << "-" << d._day << endl;
    	return out;
    }

**友元函数**可以**直接访问**类的私有成员，它是定义在类外部的普通函数，不属于任何类，但需要在 类的内部声明，声明时需要加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;
    }

### **【14.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;
    };

## **【15】内部类**  ##

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

*  内部类可以定义在外部类的public、protected、private都是可以的。
 *  注意内部类可以直接访问外部类中的static成员，不需要外部类的对象/类名。
 *  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;
    }

**牛客专题 - JZ64** 求1+2+3+...+n(使用内部类改造)

**连接：**[求1+2+3+...+n牛客题霸牛客网 (nowcoder.com)][1_2_3_..._n_ _nowcoder.com]

class Solution {
      public:
        // 定义一个多次调用的类
        class Sum 
        {
        public:
            Sum() 
            {
                _ret += _i;
                ++_i;
            }
        };
    
        int Sum_Solution(int n) 
        {
            Sum arr[n];
            return _ret;
        }
    
    private:
        static int _i;
        static int _ret;
    };
    
    
    // 静态变量的外部初始化。
    int Solution::_i = 1;
    int Solution::_ret = 0;

## **【16】匿名对象**  ##

class A
    {
    public:
    	A(int a = 0)
    		:_a(a)
    	{
    		cout << "A(int a)" << endl;
    	}
    	~A()
    	{
    		cout << "~A()" << endl;
    	}
    private:
    	int _a;
    };
    class Solution {
    public:
    	int Sum_Solution(int n) {
    		//...
    		return n;
    	}
    };
    int main()
    {
    	A aa1;
    	// 不能这么定义对象，因为编译器无法识别下面是一个函数声明，还是对象定义
    	//A aa1();
    	// 但是我们可以这么定义匿名对象，匿名对象的特点不用取名字，
    	// 但是他的生命周期只有这一行，我们可以看到下一行他就会自动调用析构函数
    	A();
    	A aa2(2);
    	// 匿名对象在这样场景下就很好用，当然还有一些其他使用场景，这个我们以后遇到了再说
    	Solution().Sum_Solution(10);
    	return 0;
    }

## **【17】拷贝对象时的一些编译器优化**  ##

在传参和传返回值的过程中，一般编译器会做一些优化，减少对象的拷贝，这个在一些场景下还是非常有用的。

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

[efd049f467614c66af96a310fa247256.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/385e3d64307b4c159d6e87e1c3d61a6f.png
[df54a7ea676343bab4037ec529aa407d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/2a436199f8314ecf9da5ea5058821b8a.png
[cd1fab7322be42c2a11da9c069883a01.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/fbe5067189d7433a97fd03cf2afdbe4f.png
[3e015a94fbe6453f9b4db170d71bb964.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/5337225d42b64f009e97224d2eeadbb9.png
[b8a917dc6746407d8871a3407d25a543.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/1291e2fe2f32467cb06f592e39c7beba.png
[17d4b09458884dafb4d09b9356f62620.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/ced19e2b23484f3fa8923f199b93bd4b.png
[19b35f70eaf94bf483aeb93df78bf2a3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/e1e47e0c6e4d4928b27f2f47385dd322.png
[aca516c5baf647e9870138e45969cf9f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/ed6f27f2a72e45a680315b1eff1b6417.png
[e607334f6ec14d0ab00fb6cbb5c011d8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/7455e845558b48928756155c70465910.png
[37cd0e0176a140938ed7500a38c243e0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/035bbf4d7e2d42338ba4ee5a0c42d88c.png
[62b48d668b7e4dcba70c38e4d3efcc5f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/e51c10d68b6944529c89d72d3b65a308.png
[6e8b0541e6e649e0ae38d21470f43f36.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/4e30b8da187f4933950da94762ba974e.png
[9ed6b958b76e456e9b1b6d8ce7d36862.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/060c097114fc4562a3b001d946dd187d.png
[44bbd8818bb64297b0b9256e0df9f025.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/473f79332ae145259a97f8054aa9885c.png
[ee5e9ca895b0413783e615eb1df7a1cb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/62d417430d1a4a6782994f1191099e25.png
[4771717f6c3940baa44aaacb08963695.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/feafcb49558d453baeb091378e5a21b4.png
[d9f08f0d9cab44f3ad11d91a7216dc11.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/2d0473877d6d4a0b866fceba5c58ae7e.png
[93b6f47d547a472ab3f2a51a9fe5c5d8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/20ddff9522f443458294058325ca2569.png
[9a8158b4740d47c290b250a353884523.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/c982f89d62af46c693446654e40e7efb.png
[81b8dbf3774a4a45a868c9d4b24cd48a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/b428004d1dc44946ae9149a7fe8e4aa9.png
[1dafbc7dc5dd4c039e06db5d6c9b2ff9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/1f05519beb17493992f6adfe2047fb64.png
[1_2_3_..._n_ _nowcoder.com]: https://www.nowcoder.com/practice/7a0da8fc483247ff8800059e12d7caf1?tpId=13&tqId=11200&tPage=3&rp=3&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking