五、拷贝构造函数

对于内置类型，编译器可以直接对数据完成拷贝；但是在对自定义类型进行拷贝时，编译器是不适合直接拷贝的，而这时可以使用拷贝构造函数。

1、概念

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

2、特性

拷贝构造函数是特殊的成员函数 。它的名字也为类名，和构造函数构成函数重载，且必须使用传引用传参，使用传值传参会报错：

验证传值传参报错：

一定要加上引用才不会报错 ：

Date(Date d) // 拷贝构造函数
{
    _year = d._year;
    _month = d._month;
    _day = d._day;
}

拷贝构造函数的参数只有一个且必须是类的类型对象的引用，使用 传值方式 编译器 直接报错 ，因为这会引发无穷递归调用；这是拷贝构造函数的特性之一，这句话该如何理解，如何理解会引发无穷递归调用？

仔细观察拷贝构造函数传参的过程，是不是又是 Date date(d1) ，在传参时，是不是无形中又调用了拷贝构造函数？

因为我们的 date 形参就是原对象 d1 ，而传参过来，则是一份和原先对象一模一样的对象，这个对象不存在，所以我们需要先进行拷贝构造，而拷贝构造到下一层也是相同的原理，就是在一直拷贝构造不存在的形参，从而形成死递归 。

但是使用引用传参就没事了，因为 date 此刻变为 d1 的别名，这时就不存在 拷贝对象不存在从而继续拷贝的情况 。此刻就可以顺利进入拷贝构造函数。

所以拷贝构造参数一定不能为传值，要传引用！我们也可以抽象出一个概念：定义类型传值传参就是拷贝构造 。

而对于拷贝构造函数的参数，一般加 const 修饰 ，因为拷贝构造函数的功能可能会写反，比如：

Date(Date& d) // 拷贝构造函数
{
    d._year = _year; // 写反了
    _month = d._month;
    _day = d._day;
}

这时不仅没有拷贝构造成功，还把 d1 改了：

这就错误了，但是加上 const 修饰就没事：

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

当 Date 类没有拷贝构造函数时，仍然按照字节序完成了值拷贝：

但是对于 Stack 类就不行：

class Stack
{
public:
  Stack(int capacity = 4)
  {
    _array = (int*)malloc(sizeof(int) * capacity);
    if (_array == nullptr)
    {
      cout << "malloc fail" << endl;
      exit(-1);
    }
    _top = 0;
    _capacity = capacity;
  }
  void Push(const int& data) 
  {
    _array[_top] = data;
    _top++;
  }
  ~Stack()
  {
    free(_array);
    _array = nullptr;
    _top = _capacity = 0;
  }
private:
  int* _array;
  size_t _top;
  size_t _capacity;
};
int main()
{
  Stack st1;
  st1.Push(1);
  Stack st2(st1);
  return 0;
}

不出意外，当我们进行操作时，程序奔溃了 ：

因为 st1 和 st2 指向的同一块空间，释放了两次。

这里我们使用的默认拷贝构造就是编译器自动处理的，很明显这里不行。而如果要实现正确的拷贝构造，需要深拷贝。所谓深拷贝，就是让它们有独立的空间，就比如这里的 Stack ，就是让 _array 指向不同的空间，使得它们之间的操作互不影响，接下来，我们简单写一下深拷贝：

class Stack
{
public:
  Stack(int capacity = 4)
  {
    _array = (int*)malloc(sizeof(int) * capacity);
    if (_array == nullptr)
    {
      cout << "malloc fail" << endl;
      exit(-1);
    }
    _top = 0;
    _capacity = capacity;
  }
  Stack(const Stack& st)
  {
    _array = (int*)malloc(sizeof(int) * st._capacity);
    if (_array == nullptr)
    {
      cout << "malloc fail" << endl;
      exit(-1);
    }
    memcpy(_array, st._array, sizeof(st._array) * st._top); // 拷贝 st1 指向空间的值到 st2 指向的空间
    _top = st._top;
    _capacity = st._capacity;
  }
  void Push(const int& data)
  {
    _array[_top] = data;
    _top++;
  }
  ~Stack()
  {
    free(_array);
    _array = nullptr;
    _top = _capacity = 0;
  }
private:
  int* _array;
  size_t _top;
  size_t _capacity;
};

这时就没有问题了，st1 和 st2 指向了不同的空间：

由此，我们总结出一个结论：当自己实现了析构函数释放空间，就需要实现拷贝构造（深拷贝），而深拷贝我们之后也会详细讲解。

类中自定义类型成员会自动调用它的拷贝构造 ：

class A
{
public:
  A() {}
  A(const A& a) // 拷贝构造
  {
    cout << "A(const A&)" << endl;
  }
};
class Date
{
public:
  Date(int year = 0, int month = 1, int day = 1)
  {
    _year = year;
    _month = month;
    _day = day;
  }
  ~Date()
  {
    cout << "~Date()" << endl;
  }
private:
  int _year;
  int _month;
  int _day;
  A _aa; // 自定义类型
};
int main()
{
  Date d1;
  Date d2(d1);
  return 0;
}

由于 只要自定义构造函数和拷贝构造函数就不生成默认构造函数 的原因，所以需要定义一下构造函数 A() {} 。

对 d2 进行拷贝构造时，其中 _aa 成员变量，会自动调用它本身的拷贝构造。

拷贝构造会经常存在，比如返回时，或传参时，都会发生拷贝构造：

例如这里，就是在 a2 传参时，拷贝构造成了参数 a ，并且在 a 返回时，拷贝构造给了临时变量。拷贝构造是有消耗的，所以用好引用很重要 。

特性总结 ：

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

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

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

       只要自定义构造函数或者拷贝构造函数，都不会生成构造函数，自定义类型成员会调用它的拷贝构造。

总结：拷贝构造我们不写生成的默认拷贝构造函数对于内置类型和自定义类型都会拷贝处理。但是处理细节和构造和析构是不一样的。

六、运算符重载

1、规则

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

我们依然围绕日期类进行讲解，首先写一下日期类：

class Date
{
public:
  Date(int year = 0, int month = 1, int day = 1)
  {
    _year = year;
    _month = month;
    _day = day;
  }
private:
  int _year;
  int _month;
  int _day;
};
int main()
{
  Date d1(2023, 2, 3);
  Date d2(2023, 3, 4);
  return 0;
}

创建 d1 和 d2 两个对象，时间分别为 2023.2.3 和 2023.3.4 ，如何比较它们的天数的先后，或者是算它们中间相差的天数？

对于平常情况下，我们可以手算，但是对于计算机呢？如何直接用运算符来比较？可不可以直接比较它们的先后？可以不可以让 d2 的天数直接减去 d1 的天数？例如 d1 > d2 ，d2 - d1 ？

在 C++ 中，只支持对内置类型的运算符计算，并不支持直接对自定义类型进行运算符计算，但是通过运算符重载可以达到这个效果 。

运算符重载：

       函数名字为：关键字operator后面接 需要重载的运算符符号

       函数原型：返回值类型 operator操作符(参数列表)

返回值与参数：

       对于返回值：不同的运算符重载函数，返回值是不同的，例如 > 就是 bool 类型；- 就是 int 类型

       对于参数操作数有几个操作符，就有几个操作数

对于一个比较大小运算符重载的参数需要注意几点：

bool operator>(const Date& d1, const Date& d2);

重载的是 > ，对于这个符号有两个操作数；参数写成引用的形式，减少空间的消耗；加上 const 修饰，也防止这两个对象由于引用的原因被修改。

接下来，我们写出这个运算符重载：

但是这迎来一个问题 ：运算符重载在类外部访问不到成员变量，这样就使得运算符重载不起作用了。那么我们就要相除解决方案。

plan 1（可以但不推荐）：

去掉 Date 类中成员变量的 private 的私有，我们先取巧，先用了再说：

这时，调试，然后到 d1 > d2 ，f11 进入运算符重载：

对于这边的调用有两种方式：

编译器看到自定义类型 d1 > d2 去找是否重载了运算符，如果找到了，就转换为 operator>(d1, d2) 调用函数，找不到就 报错：

如果这时候我们把 operator> 屏蔽掉：

这也就验证了我们的说法。

plan 2：

刚刚破坏了封装性，所以方法不太可行。所以可以写在类的里面 ，但是这里会有一个问题：

写成成员函数时，成员函数默认会有一个 this 指针，但是对于运算符重载的参数个数等于操作数个数，> 有两个，现在就有三个了，所以错了。

例如如果直接调用 operaror> 函数时：

Date d1;
d1.operator>(d2);

d1 作为 this 指针被传过去，d2 被作为另一个参数，但是这里对于我们当前的函数来说，有三个参数：this, d1, d2 ，参数不匹配了！

所以需要修改：

(可以写成 this->_year，因为 this 指针可以省略)

这时 d1 > d2 ，会先去到类的成员里面找，找到了转换为 d1.operator>(d2)，若类中没找到，再到全局找，找到转换为 operator>(d1, d2) ，进行调用。

对于上面两种 operator> 全局的和类中的可以同时存在（参数不同构成重载），若同时存在，则调用类中成员的，和就近原则没什么关系，取决于编译器的实现机制；但是这种情况一般不存在，因为成员变量一般都是 private 私有的，全局的并没有用。

对于运算符重载的规则：

       不能通过连接其他符号来创建新的操作符 ：比如operator@

       重载操作符必须有一个类类型参数

       用于内置类型的运算符，其含义不能改变，例如：内置的整型+，不 能改变其含义

       作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的this

       [.*](没用过类似于访问解引用，背住) :: sizeof ?:(三目运算符) .(访问自定义类型) 注意以上5个运算符不能重载。这个经常在笔试选择题中出现。

       返回值类型不一定是内置类型，例如 Date operate++() 返回值还是个日期

       运算符重载的返回值必须写