[C++知识库]C++类和对象详解

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

首先我们先给出以下结论：
C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。
C++是基于面向对象的，关注的是对象，将一件事拆分成不同的对象，靠对象之间的交互完成。

2 类的引入

C语言结构体中只能定义变量，而在C++中，结构体内不仅可以定义变量，也可以定义函数。用C语言方式实现的栈，结构体中只能定义变量；现在以C++方式实现，会发现struct中也可以定义函数，这是因为C++将struct升级成了类。

struct Stack
{
    void Init();
    void Push();
    int Top();
    void Destroy();
    
    int* _arr;
    size_t _capacity;
    size_t _size;
};

3 类的定义

class ClassName
{
    //成员函数
    //成员变量
};

在C++中，一般不用struct，而是用class定义类。class为定义类的关键字，ClassName为类的名字，{}中为类的主体，注意类定义结束时后面分号不能省略。

类体中内容称为类的成员：

• 类中的变量称为类的属性或成员变量
• 类中的函数称为类的方法或者成员函数。

类的两种定义方式：

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

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

一般地，我们将短小的函数按第一种方式定义，将其看成内联函数；将较长的函数按第二种方式定义。

4 类的封装及访问限定符

4.1 封装

面向对象的三大特性：

• 封装
• 继承
• 多态

在类和对象阶段，我们只研究封装特性，什么是封装？
封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互。

封装本质上是一种管理，让用户更方便使用类。在C++语言中实现封装，可以通过类将数据以及操作数据的方法进行有机结合，通过访问权限来隐藏对象内部实现细节，开放一些共有的成员函数对成员合理的访问。

C语言 —> 没办法封装，规范使用函数访问数据 ，也可以直接访问数据 ——不安全

C++ —> 封装， 必须规范使用函数访问数据，不能直接访问数据 ——安全

4.2 访问限定符

访问限定符说明：

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

class的默认访问权限为private，struct为public(因为struct要兼容C)

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

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

答：C++需要兼容C语言，所以C++中struct可以当成结构体使用。另外C++中struct还可以用来定义类。和class定义类是一样的。

区别是：struct定义的类默认访问权限是public，class定义的类默认访问权限是private。

注意：在继承和模板参数列表位置，struct 和 class也有区别。

5 类的作用域

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

class Person
{
public:
	void Print();
private:
	char _name[20];
	char _gender[3];
	int _age;
};

 // 这里需要指定Print属于Person这个类域
void Person::Print()
{
    cout << _name << " " << _gender << " " << _age << endl;
}

域：主要影响编译器的搜索规则，而不是影响生命周期的

影响生命周期的是变量的存储位置，如：栈区，堆区，静态区，常量区

6 类的实例化

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

1. 类是对对象进行描述的，是一个模型一样的东西，限定了类有哪些成员，定义出一个类并没有分配实际的内存空间来存储它。
   类就像谜语一样，对谜底来进行描述，谜底就是谜语的一个实例。
2. 一个类可以实例化出多个对象，实例化出的对象 占用实际的物理空间，存储类成员变量 。

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

7 类对象模型

7.1 类对象的存储方式

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

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


int main()
{
	A a1;
	A a2;
	a1.f();
	a2.f();
	return 0;
}

转汇编：

可以用下面代码验证，编译运行的结果是？A、崩溃 B、编译报错 C、正常运行

class A
{
public:
    void Print()
    {
        cout << "Print()" << endl;
    }
private:
    int _a;
};
int main()
{
    A* ptr = nullptr;
    ptr->func();
    return 0;
}

结果是正常运行。因为该程序不是对ptr解引用找到的函数，在编译链接时就根据函数名去公共代码区找到函数的地址，运行时直接call函数地址。

7.2 如何计算类对象的大小

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

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

int main()
{
	cout << sizeof(A1) << endl;
	cout << sizeof(A2) << endl;
	cout << sizeof(A3) << endl;
	return 0;
}

结论：一个类的大小，实际就是该类中”成员变量”之和，当然要注意内存对齐。

注意空类的大小，空类比较特殊，编译器给了空类一个字节来唯一标识这个类的对象。

7.3 结构体内存对齐规则

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

8 命名习惯：驼峰法

1. 函数名、类名等所有单词首字母大写 如：GetYear

2. 变量首字母小写，后面单词首字母大写 如：getYear

3. 成员变量首单词前面加_ 如：_year

9 this指针

9.1 this指针的引入

我们先创建一个日期类

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, 10, 15);
    d2.Init(2000, 2, 3);
    d1.Print();
    d2.Print();
    return 0;
}

思考：函数体中没有关于不同对象的区分，当d1调用Init函数时，该函数是如何知道应该设置d1对象，而不是设置d2对象呢？

• 因为在类里面的函数体内，有一个隐藏的this指针，函数在编译的时候，编译器会将其处理成

void Init(Date* const this, int year, int month, int day)
{
    this->_year = year;
    this->_month = month;
    this->_day = day;
}

void Print(Date* const this)
{
    cout << this->_year << "-" << this->_month << "-" << this->_day << endl;
}

这里的this是一个常量指针，该指针不能被修改。

• 在main函数中，调用函数编译器也会多加一个参数。

int main()
{
    Date d1, d2;
    d1.Init(&d1, 2022, 10, 15);
    d2.Init(&d2, 2000, 2, 3);
    d1.Print(&d1);
    d2.Print(&d1);
    return 0;
}

哪个对象调用就是哪个对象传给this指针，也就是调用对象的年月日。

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

但是我们可以在函数体内部使用this指针，如下所示。

void Init(int year, int month, int day)
{
    this->_year = year;
    this->_month = month;
    this->_day = day;
}
void Print()
{
    cout << this->_year << "-" << this->_month << "-" << this->_day << endl;
}

9.2 this指针的特性

• this指针的类型：类型* const，即成员函数中，不能修改this指针。

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

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

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

this指针存在哪里？

this指针本质上其实是一个成员函数的形参，所以this指针存在于栈中。但是在vs中为了提高效率，this指针存在于ecx寄存器中

this指针可以为空吗？

下面程序编译运行结果是？ A、崩溃 B、编译报错 C、正常运行

class A
{
public:
    void Print()
    {
        cout << _a << endl;
    }
private:
    int _a;
};
int main()
{
    A* ptr = nullptr;
    ptr->Print();
    return 0;
}

结果是崩溃。因为这传参的时候传进去的就是nullptr，所以Print函数里面的this指针也是nullptr，打印_a就是对this指针解引用，也就是对空指针解引用，所以程序运行崩溃。

10 类的6个默认成员函数

如果一个类中什么成员都没有，简称为空类。

空类中真的什么都没有吗？并不是，任何类在什么都不写时，编译器会自动生成以下6个默认成员函数。

默认成员函数：用户没有显式实现，编译器会生成的成员函数称为默认成员函数。

• 构造函数：
  1、大部分的类都需要自己写构造函数
  2、只有像Myqueue这样类不需要显示写构造函数
  3、每个类最好都要提供默认构造函数。

• 析构函数：
  1、一些类需要显示写析构函数。比如:Stack、Queue…
  2、一些类不需要显示写析构函数。

  • a、比如Dte这样类，没有资泯需要清理
  • b、比如MyQueue也可以不写，默认生成的就可以

• 拷贝构造、赋值重载：

  1、一些类需要显示写拷贝和赋值。比如: Stack、Queue…

  2、一些类不需要显示写拷贝和赋值。

  • a、比如Date这样的类，默认生成就会完成值拷贝/浅拷贝
  • b、比如MyQueue这样的类，默认生成就会调用他的自定义类型成员Stack的拷贝和赋值

• 取地址重载：这两个很少会自己实现，一般默认生成的就可以

11 构造函数

11.1 概念

对于Date类，可以通过 Init 公有方法给对象设置日期，但如果每次创建对象时都调用该方法设置信息，有时候可能忘记初始化了，程序就会出错。针对这个问题，C++在类里面定义了一个构造函数，构造函数是一个特殊的成员函数，名字与类名相同,创建类类型对象时由编译器自动调用，以保证每个数据成员都有 一个合适的初始值，并且在对象整个生命周期内只调用一次。

11.2 特性

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

1. 函数名与类名相同。
2. 无返回值，不需要写void
3. 对象实例化时编译器自动调用对应的构造函数。
4. 构造函数可以重载。

• 实现日期类的构造函数（无参和带参）

注意：如果通过无参构造函数创建对象时，对象后面不用跟括号，否则就成了函数声明

以下代码的函数：声明了d3函数，该函数无参，返回一个日期类型的对象

Date d3();

由结果可以看出，构造函数可以重载且可以带参或无参，对于无参构造函数编译器会给一个随机值。

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

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

class Date
{
public:
	//1.无参构造函数
	Date()
	{}
	//2.全缺省参数的构造函数
	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 d1;  
	return 0;
}

在调用构造函数的时候产生了歧义。因为两个都是默认构造函数，都可以调用。

7. 在不实现构造函数的情况下，编译器会生成默认的构造函数。但是看起来默认构造函数又没什么用？d对象调用了编译器生成的默认构造函数，但是d对象_year/_month/day，依旧是随机值。也就说在这里编译器生成的默认构造函数并没有什么用？？

   解答：C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语言提供的数据类型，如：int/char…（包括指针），自定义类型就是我们使用class/struct/union等自己定义的类型，看看下面的程序，就会发现编译器生成默认的构造函数会对自定类型成员t调用的它的默认成员函数，不会对内置类型初始化。
   

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

11.3 初始化列表

我们在之前函数体内初始化，有的情况不能解决。

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

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

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

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

【注意】

1. 每个成员变量在初始化列表中只能出现一次（初始化列表只能初始化一次）
2. 类中包含以下成员，必须放在初始化列表位置进行初始化：
   • 引用成员变量
   • const成员变量
   • 自定义类型成员（且该类没有默认构造函数时）
3. 尽量使用初始化列表初始化，因为不管你是否使用初始化列表，对于自定义类型成员变量，一定会先使用初始化列表初始化。

结论：

自定义类型成员，推荐使用初始化列表初始化

初始化列表可以认为是成员变量定义的地方。

问：我们已经有了初始化列表，还有必要使用函数体内初始化吗？

答：有些初始化工作还是必须在函数体内完成。

class A
{
public:
	A(int N)
		:_a((int*)malloc(sizeof(int)* N))
		, _N(N)
	{
		if (_a == nullptr)
		{
			perror("malloc fail");
		}
		memset(_a, 0, sizeof(int) * N);
	}
private:
	int* _a;
	int _N;
};
int main()
{
	A aa(10);
	return 0;
}

这样的初始化看起来很难受，所以像这种我们就在函数体内初始化了。

class A
{
public:
	A(int N)
		:_N(N)
	{
		_a = (int*)malloc(sizeof(int) * N);
		
		if (_a == nullptr)
		{
			perror("malloc fail");
		}
		memset(_a, 0, sizeof(int) * N);
	}
private:
	int* _a;
	int _N;
};
int main()
{
	A aa(10);
	return 0;
}

初始化是按它的声明顺序初始化。

11.4 explicit关键字

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

class Date
{
public:
	Date(int year)
		:_year(year)
	{
		cout << "Date(int year)" << endl;
	}
private:
	int _year;
};

int main()
{
	Date d1(2022);
	Date d2 = 2020;
	return 0;
}

d1是直接调用构造；d2是隐式类型转换：构造 + 拷贝构造 + 优化 —> 直接调用构造。看下面简单点的例子。

为什么说d2是编译器的优化呢？

我们可以验证一下，C++里面有一个关键字explicit，explicit修饰构造函数，可以禁止类型转换。

12 析构函数

12.1 概念

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

12.2 特性

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

1. 析构函数名是在类名前加上字符 ~。

2. 无参数无返回值类型。

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

4. 对象生命周期结束时，C++编译系统系统自动调用析构函数，如：

   class Date
   {
   public:
   	Date(int year = 1, int month = 1, int day = 1)
   		: _year(year)
   		, _month(month)
   		, _day(day)
   	{}
   	~Date()
   	{
   		cout << "~Date" << endl;
   	}
   
   private:
   	int _year = 0;
   	int _month = 0;
   	int _day = 0;
   };
   
   int main()
   {
   	Date d;
   	return 0;
   }
   

   

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

   

   • 在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类生成的默认析构函数。

   注意：创建哪个类的对象则调用该类的析构函数，销毁那个类的对象则调用该类的析构函数

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

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)
	{
		_array[_size] = data;
		_size++;
	}
	~Stack()
	{
		if (_array)
		{
			free(_array);
			_array = nullptr;
			_capacity = 0;
			_size = 0;
		}
	}
private:
	DataType* _array;
	int _capacity;
	int _size;
};

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

7. 析构顺序

• 定义在栈帧里的变量，后调用的先析构，先调用的后析构。跟数据结构里面的栈是一样的，后进先出。

13 拷贝构造函数

13.1 概念

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

13.2 特征

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

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

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

  class Date
  {
  public:	
  	Date(int year=1900, int month=1, int day=1)
  	{
  		_year = year;
  		_month = month;
  		_day = day;
  	}
  	//拷贝构造
      //Date(Date d)           错误写法
  	Date(const Date& d)    //正确写法
  	{
  		_year = d._year;
  		_month = d._month;
  		_day = d._day;
  	}
  private:
  	int _year;
  	int _mon  th;
  	int _day;
  };
  int main()
  {
  	Date d1(2021,3,7);
  	Date d2(d1);
      Date d3 = d1;
      return 0;
  }
  

  

  层层传值引发对象的拷贝的递归调用，所以会引发无穷递归调用。

• 若未显式定义，编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按字节序完成拷贝（就像是使用memcpy一样），这种拷贝叫做浅拷贝，或者值拷贝。

• 编译器生成的默认拷贝构造函数已经可以完成字节序的值拷贝了，还需要自己显式实现吗？当然像日期类这样的类是没必要的。那么下面的类呢？但是像Stack这样关注着内存块资源的类浅拷贝是不能解决的，需要自己实现拷贝构造，即深拷贝！

  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)
  	{
  		_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);
  	Stack s2(s1);
  	return 0;
  }
  

  

  1. s1对象调用构造函数创建，在构造函数中，默认申请了10个元素的空间然后里面存了2个元素1 2

  2. s2对象使用s1拷贝构造，而Stack类没有显式定义拷贝构造函数，则编译器会给Stack类生成一份默认的拷贝构造函数，默认拷贝构造函数是按照值拷贝的，即将s1中内容原封不动的拷贝到s2中。因此s1和s2指向了同一块内存空间。

  3. 当程序退出时，s2和s1要销毁。s2先销毁，s2销毁时调用析构函数，已经将0xFFFFFF的空间释放了，但是s1并不知道，到s1销毁时，会将0xFFFFFF的空间再释放一次，一块内存空间多次释放，肯定会造成程序崩溃。

  注意：类中如果没有涉及资源申请时，拷贝构造函数是否写都可以；一旦涉及到资源申请时，则拷贝构造函数是一定要写的，否则就是浅拷贝。 为了提高程序效率，一般对象传参时，尽量使用引用类型，返回时根据实际场景，能用引用尽量使用引
  用。

14 赋值运算符重载

14.1 运算符重载

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

注意：

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

内置类型可有直接使用运算符运算，编译器知道要如何运算。

自定义类型无法直接使用运算符，编译器不知道如何运算。想要支持，必须自己实现运算符重载。我们使用==重载举例。

• 全局的operator==

我们将成员私有改为共有，封装性不能保证，是不安全的。

• 类内的operator==

这里operator函数的参数也是两个，只是this指针隐藏了。

14.2 赋值运算符重载

1. 赋值运算符重载格式

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

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

   检测是否自己给自己赋值

   返回*this ：要复合连续赋值的含义，如a = b = c

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

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

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

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

   注意：内置类型成员变量是直接赋值的，而自定义类型成员变量需要调用对应类的赋值运算符重载完成赋值。如果类中未涉及到资源管理，赋值运算符是否实现都可以；一旦涉及到资源管理则必须要实现深拷贝。

14.3 前置++和后置++重载

• 前置++

// 返回+1之后的结果
// 注意：this指向的对象函数结束后不会销毁，故以引用方式返回提高效率
Date& operator++()
{
    _day += 1;
    return *this;
}

后置++

// C++规定：后置++重载时多增加一个int类型的参数，但调用函数时该参数不用传递，编译器自动传递
// 注意：后置++是先使用后+1，因此需要返回+1之前的旧值，故需在实现时需要先将this保存一份，然后给this+1
// 而temp是临时对象，因此只能以值的方式返回，不能返回引用
Date operator++(int)
{
    Date temp(*this);
    _day += 1;
    return temp;
}

15 友元

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

15.1 << 运算符重载+函数重载

我们内置类型可以直接使用<<，这是因为在头文件中的ostream类里就写好了<< 的运算符重载+函数重载。

int main()
{
	int a = 10;
	double b = 1.2;
	cout << a;
	cout << b;
	return 0;
}

这里的cout << a就会转换成cout.operator<<(a)；cout << b会转换成cout.operator<<(b)。这就形成了运算符重载。

• 运算符重载：让自定义类型对象可以用运算符，转换成调用这个重载函数。

• 函数重载：支持函数名相同的函数存在。

• 虽然运算符重载和函数重载都用了重载这个词，但是它们之间没有必然的联系。

自定义类型想使用<<，就得自己写一个<<的运算符重载。

void operator<<(ostream& out) //避免与库里面的cout冲突
{
    out << _year << "-" << _month << "-" << _day <<endl;
}

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

15.2 友元函数

class Date
{
	//友元函数 - 这个函数内部可以使用Date对象访问私有保护的成员
	friend ostream& operator<<(ostream& out, const Date& d);
public:
	
private:
	int _year;
	int _month;
	int _day;
};
ostream& operator<<(ostream& out, const Date& d)
{
	out << d._year << "-" << d._month << "-" << d._day << endl;
	return out;
}

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

注意:

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

15.3 友元类

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

• 友元关系是单向的，不具有交换性。
  比如上述Time类和Date类，在Time类中声明Date类为其友元类，那么可以在Date类中直接访问Time类的私有成员变量，但想在Time类中访问Date类中私有的成员变量则不行。
• 友元关系不能传递
  如果B是A的友元，C是B的友元，则不能说明C时A的友元。
• 友元关系不能继承。

class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
		: _year(year)
		, _month(month)
		, _day(day)
	{}
	void SetTime(int hour, int minute, int second)
	{
		// 直接访问时间类私有的成员变量
		_t._hour = hour;
		_t._minute = minute;
		_t._second = second;
	}
private:
	int _year;
	int _month;
	int _day;

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

16 const成员

首先来看下面的代码。

class Date
{
public:
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << "Print()" << endl;
		cout << _year << _month << _day << endl;
	}
private:
	int _year; 
	int _month; 
	int _day; 
};
int main()
{
	Date d1(1, 1, 1);
	d1.Print();
	const Date d2(2022, 10, 19);
	d2.Print();
	return 0;
}

d2的打印是错误的，因为权限被放大了。

const Date* this 和 Date* const this 的区别。

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

注意：权限可以平移，也可以缩小，但是不能放大。

17 取地址重载

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

Date* operator&()
{
    return this;
}

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

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

Date* operator&()
{
    return nullptr;
}

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

18 匿名对象

匿名对象的声明周期只有这一行，

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

匿名对象的一些使用场景，如只想调用类里面的函数，没必要创建一个对象

int main()
{
	//普通对象
	Date d(2000);
	d.Print();
	//使用匿名对象
	Date(2022).Print();

	return 0;
}

使用匿名对象，只是让代码更简洁。

19 static成员

19.1 概念

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

有时候我们一个全局的变量，但是使用全局变量会破坏封装，所以C++提供了静态成员全局变量。

19.2 特性

1. 静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区

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

3. 类静态成员即可用 类名::静态成员 或者 对象.静态成员 来访问

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

5. 静态成员也是类的成员，受public、protected、private 访问限定符的限制

【问题】

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

   没有this，不能调用。

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

   可以，类的静态成员函数属于整个类，所以非静态成员函数也可以调用。

20 内部类

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

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

特性：

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

class A
{
private:
	int _a;
public:
	class B
	{
	public:
	private:
		int _b;
	};
};

B定义A里面

1、B受A的类域限制，也受访问限定符的限制

2、B天生是A的友元，也就是在B里面可以访问A的成员变量

在外面访问B的成员变量得说明域限定符。

int main()
{
    A::B b;
    return 0;
}