【C++】类与对象 II 【深入浅出万字详解】

类与对象 II

一、类的6个默认成员函数
二、构造函数
三、析构函数
四、拷贝构造函数
五、赋值运算符重载
前言：运算符重载（运算符重载出现的意义）
（一）运算符重载
六、前置++和后置++重载
七、日期类的实现
八、const成员函数
九、取地址及 const取地址操作符重载
- - 6大默认成员函数中的最后两个

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

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

class Date {
    
    };

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

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

在这里插入图片描述

二、构造函数

前言：构造函数产生的由来及引入

没有初始化会产生什么问题？

没有初始化了，会造成野指针、随机值问题
在这里插入图片描述

C语言中关于初始化会出现的问题总结：

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

1. C语言中，每次都要初始化一下 。对于Date类，可以通过 Init 公有方法给对象设置日期，但如果每次创建对象时都调用该方法设置信息 ，未免有点麻烦 。

那能否在对象创建时，就将信息设置进去呢？

C++改进：构造函数（函数自动初始化）。

构造函数，将初始化嵌入到类里，让类对象被创建时，自动调用初始化 [ 即是默认构造函数 ]

（一）构造函数的概念

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

（二）构造函数的特性

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

其特征如下：

函数名与类名相同 。
无返回值 。【 不需要写 void 】
★ 对象实例化时 编译器自动调用对应的构造函数。

内置类型编译器默认不处理

自定义类型进行默认构造函数的调用

【若 显式定义构造函数 ，则编译器则会调用该显式定义的构造函数，不再自动生成的构造函数。】

构造函数 可以重载 。（如下：无参构造，带参构造）

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; // 调用无参构造函数     
      // 注意：如果通过无参构造函数创建对象时，对象后面不用跟括号，否则就成了函数声明
     
      Date d2(2015, 1, 1); // 调用带参的构造函数
  
     
      // 以下代码的函数：声明了d3函数，该函数无参，返回一个日期类型的对象
      // warning C4930: “Date d3(void)”: 未调用原型函数(是否是有意用变量定义的?)
      Date d3();
 }

★ 构造函数和函数声明的区分

无参
1. 构造函数：Date d1； // 没有参数，不能加（）
2. 函数声明：Date d1（）； //（）函数调用操作符
带参
1. 构造函数：Date d1（2023，10，19）； // 只需要根据缺省参数，给出对应初始化的值
2. 函数声明：Date d1（int，int，int）； // 函数声明，参数要有类型声明

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

默认构造函数：对于内置类型，编译器默认不处理；对于自定义类型，编译器进行默认构造函数的调用。

关于编译器生成的默认成员函数 ：

很多童鞋会有疑惑：不实现构造函数的情况下，编译器会生成默认的构造函数。但是看起来默认构造函数又没什么用？

d对象调用了编译器生成的默认构造函数，但是d对象_year/_month/_day，依旧是随机值。 也就说在这里编译器生成的默认构造函数并没有什么用？？
- 解答：
- C++把类型分成内置类型(基本类型)和自定义类型。
- 内置类型 就是 语言提供的数据类型 ，如：int/char/ 指针 …，自定义类型 就是我们使用class/struct/union等 自己定义的类型 。
  
  Date* p 也是内置类型，只是指向不同 。
- 看看下面的程序，就会发现编译器生成默认的构造函数会对自定类型成员_t调用的它的默认成员函数。
默认构造函数：对于内置类型，编译器默认不处理；对于自定义类型，编译器进行默认构造函数的调用。

★ 总结：

一般情况下，我们都要自己写构造函数
对于内置类型，都默认编译器不会进行处理，自己在类中声明时给默认值进行初始化（给缺省值）。

成员都是自定义类型，或者声明时给了缺省值，可以考虑让编译器自己生成构造函数。

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;
 int _month;
 int _day;
 // 自定义类型
 Time _t;
};

int main()
{
    
    
 Date d;
 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;
}

【小知识：一般更新，只会向前兼容，不敢在原版改，怕改错了原代码不兼容了。所以都是以打补丁的形式，兼容之前的代码】

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

注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数 ，都可以认为是默认构造函数 。【 不需要传参的 => 默认构造函数 】

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

情况：声明和定义分离（X）：缺省参数 不能声明和定义同时给（怕给的不一致，规定只能在声明给），内置类型初始化时不能访问private 】

三、析构函数

前言：为什么会产生析构函数及析构函数的引入

函数销毁也是一经常容易忘记的事，会导致内存泄露的问题。编译器检测不出内存泄露问题并报错。

所以将销毁的信息也嵌入到类中，编译器自动调用对应的析构函数（ destroy ）

（一）析构函数概念：

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

（1）对象的空间开辟与销毁以及对象中资源的开辟与销毁

对象的空间开辟与销毁

对象的空间开辟和销毁是跟着系统（栈帧）的开辟和销毁进行的。空间是构造栈帧的时候开的，函数调用结束，函数main销毁，它也跟着销毁了。【那么他们开辟构造和销毁析构的顺序就跟栈的顺序一样（后进先出）】。

【这只是对象的空间内存的开辟，在对象中的资源的开辟与清理工作，还需要靠构造函数和析构函数来进行。】

对象中资源的开辟与销毁

有关于内存资源动态开辟与销毁的，就得用构造函数和析构函数。

开辟：构造函数（构造函数虽叫构造，但又负责初始化 。)

销毁：析构函数（销毁）

在这里插入图片描述

（二）特性

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

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

不能释放内存空间【有的情况（如迭代器），系统不敢擅作主张】，若有动态开辟的资源，则需要自己构建析构函数。
关于编译器自动生成的析构函数，是否会完成一些事情呢？ 下面的程序我们会看到，编译器生成的默认析构函数，对自定类型成员调用它的析构函数。

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类。

（三）C与CPP [ 加入构造函数与析构函数的实例对比 ]

在这里插入图片描述

四、拷贝构造函数

前言：想在创建对象时，创建一个与已存在对象一某一样的新对象

问题再现
C 中原生版本

想要创建一个与已存在对象一某一样的新对象，但在下面的创建过程中，会出现什么问题？

但类 Stack stk1 在调用的时候，还能否像上面类Date（）那样的传参拷贝?

问题分析：对于如果有自己开辟的空间，浅拷贝/值拷贝会出现二次析构的风险。

传值传参（值拷贝），形参st（ st1 的一份临时拷贝（形参对实参没有影响），既然是拷贝，那么a指针都指向同一地址）。
1. st出了func2 会自动调用一次析构函数【临时拷贝（形参对实参没有影响）st里的a析构置空nullPtr，并不影响原实参里的指针a还指向原来的地址】。
2. 当 Stack st1 出main函数时，又还会自动调用一次析构函数。

则对于Stack来说，那还是 浅拷贝，赋的指针还是跟原来一样，指向同一块地方，那就重演刚刚同一块空间发生两次析构，则会出现函数崩溃的情况。

而且这也并不是在创建新对象，指针都指向的是同一块内存空间，这并不是真正意义上的创建一个新对象。

真正的创建新对象是：另外再开辟一个跟原来相同大小的空间，这两个对象都分别指向自己对应的空间，而不是指向同一个。指向同一个的，那只是浅拷贝/值拷贝。

C++里浅拷贝/值拷贝在会有风险，深拷贝才能解决问题。

如何解决问题：

传参拷贝时，拷贝构造 （深拷贝）

默认生成 的 值拷贝

【对于需要自己开的空间的，都需要深拷贝（另外再开辟一个跟原来相同大小的空间）】

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

所以也就有了 C++中拷贝构造函数 的引入。

☆ C++规定，自定义类型对象 传参拷贝，必须调用拷贝构造

默认成员函数，会对类里 内置成员函数 完成 值拷贝，自定义类型 调用其 拷贝构造

Date都是内置类型，都只需要用默认生成拷贝（默认拷贝构造函数）完成值拷贝即可 【兼容C语言，C就是传值传参完成值拷贝】
MyQueue 则因为是由栈Stack来实现，Stack里面本身就写好了拷贝构造函数，每传参调用一次Stack类就需要经过一次拷贝构造。
而Stack （为基础单元时，指针所指向的开辟的空间需要深拷贝，所以要自己写拷贝构造）则需要自己写拷贝构造，完成深拷贝

顺序表（和栈的拷贝差不多）、链表（一个节点那样开辟，数据拷贝）、二叉树【自己开的空间的，都需要深拷贝】

（一）拷贝构造函数的概念

★ 拷贝构造：调用同类型的对象来赋值初始化这个对象。

拷贝构造函数：

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

（二）拷贝构造函数的特征

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

拷贝构造函数是构造函数的一个重载形式。
拷贝构造函数的 参数只有一个 且 必须是类类型对象的引用 ，使用传值方式编译器直接报错，因为会引发无穷递归调用。
若未显式定义 ，编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按字节序完成拷贝 ，这种拷贝叫做 浅拷贝，或者 值拷贝 。

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

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

编译器生成的默认拷贝构造函数已经可以完成字节序的值拷贝了，还需要自己显式实现吗？

这里需要看情况：

1. 类中如果没有涉及资源申请时，拷贝构造函数是否写都可以；

2. 一旦涉及到资源申请时，则拷贝构造函数是一定要写的，否则就是浅拷贝。

【详细用例就在我们前面说的四、拷贝构造函数二次析构，同一块空间多次释放会造成程序崩溃的问题】
明白了就不用在看这部分的例子了。
在这里插入图片描述

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

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

（完整代码放后面了）
在这里插入图片描述

1）尽可能传引用

尽管C++传值拷贝，有拷贝构造函数进行初始化，碰到的像 Date d2（d1）这样的还好，只需要传12个字节的内容，而要是像 Tree（）这样的结构进行传值拷贝，拷贝构造，效率则会极其低下。

能用传引用就用传引用（底层本质就是用指针实现，在代码运行上和指针效率一样，引用更多的是方便了程序员进行代码敲写时的）

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

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

temp出了作用域，函数栈帧销毁【只能用传值返回】， return temp；

返回类型Date ，temp传回的是temp的一份临时拷贝（需要调用创建一个新的 Date（）对象，并将temp赋值给其，就得再经历一次拷贝构造【效率就已经极其低下了】）

要是加上static，出了作用域没有销毁，就能用 传引用返回 了，【就少一次拷贝构造，效率嘎嘎高】

更正

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

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

五、赋值运算符重载

前言：运算符重载（运算符重载出现的意义）

内置类型对象，计算机中本身就自带的类型，了解各内置类型的定义，可根据计算机的大小比较规则进行。（内置类型对象可以直接用各种运算符，内置类型都是简单类型，语言自己定义的，编译直接转换成指令）
自定义类型，人为定义的类型，编译器不知道你定义的类型中各项大小的比较的比较规则【自定义类型比较用函数来实现（存在逻辑）】，所以无法用使用各种运算符。

自定义类型运算符默认不支持（想支持就运算符重载）。
C++ 为了增强代码的可读性 引入了运算符重载

（一）运算符重载

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

（1）运算符重载基本概念

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

注意：

不能通过连接其他符号来创建新的操作符 ：比如operator@
重载操作符 必须有一个类类型参数 —> 不能通过重载运算符，而改变内置类型的运算规则
用于内置类型的运算符，其含义不能改变，例如：内置的整型+，不能改变其含义
作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的this
.* :: [ 域 ] sizeof[ 大小 ] ?:[ 三目运算符 ] . [ 对象变量(结构体)取其成员 ]
注意 以上5个运算符不能重载。这个经常在笔试选择题中出现。

.* 这个了解一下就好，这个用的真的太少了

* 可以重载，不要混淆了

* : 1. 乘 2. 解引用（双重含义） ==> 祖师爷顺着这个思路启发，运算符可以有多重含义 => 运算符重载

【C++】C++入门详解 I 中，的（二）C++输入输出的特性：可自动识别变量类型

<< 流运算符自动识别类型（实际上是通过运算符重载 operate << （）, 函数重载，参数（类型）匹配，函数名修饰规则，去调用对应的函数，这个函数别人在库里面已经写好了，内置类型能支持，自定义类型就是函数重载）

放在类里面，默认第一个参数就是 this指针指向的类对象（Date对象默认占据第一个位置），<< 实现的成员函数不符合可读性， 换方向后不知道是流插入还是流提取了

双操作数的运算符，第一个参数是左操作数（ this 指针，隐藏的默认参数），第二个参数是右操作符

在这里插入图片描述

放到全局，就不用Date对象默认占据第一个位置了
private 暂且不设置私有

但 将成员函数 private 设置为 public 公有 ，这种是 不可取 的

Java :访问私有访问不了，=> get 和 set
C++：友元函数

总结：
1. 其他运算符一般是实现成成员函数
2. >> << 流运算符必须是实现到全局，这样才能让流对象做第一个参数，才符合可读性。
分析：
流的本质 是为了解决，自定义类型的输入和输出问题。

printf scanf（“%?”）[ 只能解决内置类型 ]，而无法解决自定义类型的出入输出问题（C无法解决这个问题）
面向对象+ 运算符重载 解决【 彻底解决自定义类型 】

这里是对控制台console的输入和输出

后面还解决了文件file 和字符串string 的输入和输出

<< >> 双重意义：

流输入和输出
位运算符（左移右移）=》整型才能左移右移 【自定义类型不存在位运算（左移右移），只有整型才能运用】

分清：

cin/cout + << >> + 自定义类型 => 流插入/流提取

cin/cout + << >> +内置类型 => 也是流插入/流提取【只不过是自动识别类型，库里已经写好了重载的函数】

<< >> + 整型 => 位运算（左移右移）

（二）赋值运算符重载

（1）赋值运算符重载格式

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

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

编译器生成的默认赋值运算符重载函数虽已经可以完成字节序的值拷贝，如果类中未涉及到资源管理，赋值运算符是否实现都可以；一旦涉及到资源管理则必须要实现。

// 这里会发现下面的程序会崩溃掉？这里就需要我们以后讲的深拷贝去解决。
typedef int DataType;
class Stack
{
    
    
public:
 Stack(size_t capacity = 10)
 {
    
    
 _array = (DataType*)malloc(capacity * sizeof(DataType));   
 if (nullptr == _array)
 {
    
    
 perror("malloc申请空间失败");
 return;
 }
 
 size = 0;
 _capacity = capacity;
 }
 
 void Push(const DataType& data)
 {
    
    
 // CheckCapacity();
 _array[_size] = data;
 _size++;
 }
 
 ~Stack()
 {
    
    
 if (_array)
 {
    
    
 free(_array);
 _array = nullptr;
 _capacity = 0;
 _size = 0;
 }
 }
 
private:
 DataType *_array;
 size_t _size;
 size_t _capacity;
};

int main()
{
    
    
 Stack s1;
 s1.Push(1);
 s1.Push(2);
 s1.Push(3);
 s1.Push(4);
 Stack s2;
 s2 = s1;    //没有写赋值运算符重载函数，编译器会自动生成的默认赋值运算符重载函数完成字节序的值拷贝/浅拷贝
 return 0;
}

在这里插入图片描述

六、前置++和后置++重载

七、日期类的实现

【会单独开一篇文章来今进行讲解 前置++和后置++重载 和 日期类的实现 ，到时候会把文章链接放在这里】

八、const成员函数

语法：在成员函数后面放 const 【实际中的意义：const 成员函数】

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

请思考下面的几个问题：

【解析如下图的下部分】

const对象可以调用非const成员函数吗？

不能（权限不能放大）
非const对象可以调用const成员函数吗？

可以（权限可缩小）

【解析如下图的上部分】

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

不能（权限不能放大）
非const成员函数内可以调用其它的const成员函数吗？

可以（权限可缩小）

在这里插入图片描述

const Date * 【const this】=> 相当于const 变量被初始化【 const int i = j 】，并不会出现权限的放大问题

在这里插入图片描述

成员函数定义的原则：

不进行成员变量的修改的成员函数，就都加const
【是挺好的】，这样 const 对象[ 权限可平移 ] 和非const对象[ 权限可缩小 ] 都可以调用 const成员函数

但也不是所有成员函数都要加 const，要进行成员变量的修改的成员函数，不能被定义成const

【带const的成员变量就更不可能传给非const（可被修改）的成员函数了】 const对象不能调用（很合理）非const才能调用

【那要 注意传参时，传的顺序要对应好，不要发生权限放大 就行了】

成员函数才要加 const

特点：声明和定义都得写 const

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

6大默认成员函数中的最后两个

默认成员函数，任何类在什么都不写时（没有显示实现），编译器会自动生成。

为了逻辑自洽，自定义类型用运算符都得重载。

本质：取地址 重载（参数不同） => 函数名修饰规则

虽然重载了也没什么用，就算不重载，这两个其中一个都可以用。
const能调用const，非const 也能调 const [ 权限缩小 ]会找更匹配的

class Date
{
    
    
public :

 //取地址操作符重载 ( 普通对象取地址 )
 Date* operator&()
 {
    
    
 return this ;
 }
 
 //const取地址操作符重载 （ const对象取地址 ）
 const Date* operator&()const
 {
    
    
 return this ;
 }
 
private :
 int _year ; // 年
 int _month ; // 月
 int _day ; // 日
};

编译器没有这些中间步骤，编译器不需要加上隐藏的this指针，再进行编译 ，编译器直接就转汇编了，用指令就去取了隐藏的this指针，不存在中间步骤死循环的问题。

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

【一般的类都不需要去重载这个问题】