三、拷贝构造函数

3.1概念

拷贝构造函数，又称复制构造函数，是一种特殊的构造函数，它由编译器调用来完成一些基于同一类的其他对象的构建及初始化。其形参必须是引用，但并不限制为const，一般普遍的会加上const限制。此函数经常用在函数调用时用户定义类型的值传递及返回。拷贝构造函数要调用基类的拷贝构造函数和成员函数。

说白了，其实拷贝构造函数是构造函数的一种重载，拷贝构造函数其实就是一种特殊构造函数，只不过是用同类型的对象进行构造。

来看下面这段代码：

class Date
{
public:
  Date(int year = 2023, int month = 5, int day = 20)
  {
  _year = year;
  _month = month;
  _day = day;
  }
  Date(Date& d)
  {
  cout << "Date(Date& d)" << endl;
  _year = d._year;
  _month = d._month;
  _day = d._day;
  }
private:
  int _year;
  int _month;
  int _day;
};
void func(Date d)
{}
void func(int i)
{}
int main()
{
  Date da1(2000);
  Date da2(da1);
  func(da1);
  func(10);
  return 0;
}

上述代码中，da2是da1的拷贝。

3.2特征

拷贝构造函数特征：

1.拷贝构造函数时构造函数的一个重载形式。

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

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

//this指针执行的是da2，d就是d1
//Date d2(d1);
Date(Date& d)
{
  _year = d._year;
  _month = d._month;
  _day = d._day;
}

上述中的拷贝构造函数的参数必须只有一个而且必须是类类型对象的引用，如果选择传值方式的话编译器就会报错，如果编译器不报错的话，就会造成无穷递归的后果。之所以会进行报错就是因为编译器会对这里进行强制检查。其中d就是da1的别名。

注意

我们这里进行拷贝构造的时候，一般要加上const，即Date(const Date& d);。加上const后就可以保护this指针指向的内容不可以进行修改，下面这种写法就是典型的错误。

下面我们来看看使用传值方式的分析：

下面我们来对比一下C++中内置类型传参和自定义类型传参的区别。

其实这里除了用引用可以解决问题，用指针也可以解决问题，任何类型的指针都是内置类型，但是如果用指针来解决问题的话其实是非常别扭的。所以我们一般都是利用传引用的方式来解决问题。

下面是加上的结果：

Date(const Date& d)
{
  cout << "Date(Date& d)" << endl;
  this->_year = d._year;
  _month = d._month;//this指针可以省略
  this->_day = d._day;
}

其中，d是da1的别名，而da2其实传给了this指针。

3.3浅拷贝

现在我们来看看拷贝构造函数的特征3：若未显式定义，编译器会生成默认的拷贝构造函数，默认的拷贝构造函数对象按内存存储按字节序来完成拷贝，这种拷贝叫做浅拷贝（也叫值拷贝）。

1.内置类型成员完成值拷贝/浅拷贝。

2.自定义类型成员会调用它的拷贝构造。

现在我们不写拷贝构造函数，Date da2(da1);依然是可以完成拷贝构造的，这里会完成值拷贝（类似于memcpy），会一个字节一个字节的拷贝过去。调试结果如下：

随着这里用的是编译器默认生成的拷贝构造函数，结果的确符合我们的预期，但这并不意味着编译器默认生成的所有拷贝构造函数都符合我们的预期，有时候我们必须自己写。比如下面这里，请看：

这里我们通过调试可以看到这里依然是可以进行拷贝的，只不过程序最后崩掉了，导致结果并不是我们想要的：

以上就是浅拷贝/值拷贝。

3.4深拷贝

深拷贝：深拷贝是指源对象与拷贝对象互相独立，其中任何一个对象的改动都不会对另外一个对象造成影响。

Stack(const Stack& st)
  {
  _array = (int*)malloc(sizeof(int) * st._capacity);
  if (nullptr == _array)
  {
    perror("malloc 申请空间失败");
    return;
  }
  memcpy(_array, st._array, sizeof(int) * st._top);
  _top = st._top;
  _capacity = st._capacity;
  }

倘若我们使用浅拷贝的话，就会调用析构函数两次导致程序崩掉，而且浅拷贝还会导致两个对象之间会存在一定的干扰，互相影响（即一个改变会影响另外一个）。

所以可以这么说，拷贝构造函数就是为了自定义类型的深拷贝对象而诞生的（日期类的拷贝构造根本就不需要我们自己写拷贝构造函数，默认生成的即可）。

下面这种就不需要我们自己写拷贝构造，请看：

3.5引用返回需要注意的点

我们先来看日期类的传值和传引用，请看：

下面我们来看看自定义Stack类型的传值和传引用：

下面是错误的传引用返回，请看：

所以这里只能传值返回

出了作用域对象还在的情况：

四、赋值运算符重载

C++中希望在某些时候可以向运算内置类型那样来对自定义类型进行运算，所以C++就推出了运算符重载这样的一个机制，赋予运算符新的功能。但是，是否要进行运算符重载取决于这个运算符对这个类有意义。有意义当然可以运算符重载，没意义的话进行运算符重载就没有必要了。

//就拿下面代码来举例
//da2 - da1就是有意义的，我们可以用来计算二者相距多少天。
//da2 + da1就没啥意义
Date da1(19, 5, 21);
Date da2(20, 5, 20);

4.1什么是运算符重载

运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。

运算符重载注意事项：

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

2.重载运算符至少有一个类类型参数，比如bool operator<(const Date& x1, const Date& x2)就符合，但是bool operator<(const int& x1, const int& x2)就不可以。

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

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

5.* :: sizeof ?: . 注意以上5个运算符不能重载。

赋值运算符重载的格式：

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

参数类型：const T&

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

这里先来看一下日期类：

class Date
{
public:
  Date(int year = 23, int month = 5, int day = 20)
  {
  _year = year;
  _month = month;
  _day = day;
  }
  void Print()
  {
  cout << _year << "-" << _month << "-" << _day << endl;
  }
//private:
  int _year;
  int _month;
  int _day;
};
bool operator<(const Date& x1, const Date& x2)
{
  if (x1._year < x2._year)
  return true;
  else if (x1._year == x2._year && x1._month < x2._month)
  return true;
  else if (x1._year == x2._year && x1._month == x2._month && x1._day < x2._day)
  return true;
  return false;
}
int main()
{
  Date da1(19, 5, 21);
  Date da2(20, 5, 20);
  da1 < da2;//相当于operator<(da1,da2);
  return 0;
}

要注意的是：da1 < da2;和operator<(da1,da2);是等价的，或者转换成da1.operator<(d2)请看：

可以发现da1 < da2;和operator<(da1,da2);是等价的。

对于下面这段代码，请看：

bool operator<(const Date& x1, const Date& x2)
{
  if (x1._year < x2._year)
  return true;
  else if (x1._year == x2._year && x1._month < x2._month)
  return true;
  else if (x1._year == x2._year && x1._month == x2._month && x1._day < x2._day)
  return true;
  return false;
}

赋值运算符重载的特征之一，请看：

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

所以我们应该这样写：

还要注意一点：操作符是几个操作数，重载函数就有几个参数。

其中，《C++ Primer》这本书中这样说道：我们可以重载赋值运算符。无论形参的类型是什么，赋值运算符都要定义为成员函数。但是有些时候赋值运算符的确是放在全局域中，具体情况具体分析即可。

下面是赋值运算符重载的一个例子，请看：

这里可以看到完成了拷贝，其实就是一个浅拷贝，日期类一般就是浅拷贝/值拷贝。

现在我们来看这段代码：

int i,j,k;
i=j=k=0;

这里就是连续赋值，从右往左走。表达式k=0的返回值作了j的右操作数，而j=k=0这个整体的返回值又作了i的右操作数。

按照这种赋值方法，我们来看一下日期类的玩法：

我们如果想让da2作为表达式da2=da1的返回值来作为da3的右操作数的话，我们就应该这样来写：

不过这里由于是传值返回，并不会返回da2这个对象，而是返回对象da2的拷贝，这样其实是可以的，但是传值返回的代价很大（传值返回返回的是对象的拷贝）， da3 = da2 = da1; 这里有两个拷贝构造，所以代价其实挺大的。调用了两个拷贝构造，请看：

我们该如何改进这里呢？（仔细回想传值返回和传引用返回的区别）

因为这里出了作用域Date对象依然是存在的，所以这里最好是传引用返回（传引用返回就不需要拷贝构造了，返回的是对象的引用（别名））。优化后：

那现在我们来看一看有没有这样的赋值操作呢？

Date da1(23, 5, 20);
da1 = da1;

我们如果不想让这种情况（自己给自己赋值）发生的话，可以这样，请看：

4.2如果没有显式定义

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

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

举个例子：

默认生成的赋值重载和拷贝构造函数的行为一样：

1.内置类型成员会进行值拷贝/浅拷贝。

2.自定义类型会去调用它的赋值重载。

那什么时候不需要我们写赋值重载呢？

Date和MyQueue

1.Date是因为它的成员变量是内置类型成员，即进行浅拷贝。

2.MyQueue不需要写赋值重载是因为它的成员变量全是自定义类型。

那什么时候需要我们自己实现呢？

Stack就需要我们自己写赋值重载

4.3赋值运算符只能重载成类的成员函数

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

赋值运算符重载函数是一个特殊的成员函数，即是一个默认的成员函数，我们如果不写的话，编译器会自动生成一个赋值运算符重载函数。我们如果重载为全局函数的话会和编译器自动生成的起冲突。

operator=跟operator<、operator>并不是一个性质的函数，因为operator<和operator>我们如果不写的话编译器并不会自己生成，而operator=如果我们不写的话编译器就会自动生成一个。**

4.4前置++和后置++

C++规定：后置++重载时多增加一个int类型的参数，但调用函数时该参数不用传递，编译器自动传递。

要想让两个运算符重载构成函数重载的话，即这里要区分前置++和后置++，所以我们在后置++运算符重载中加上一个int类型的参数，即Date operator++(int)。后置++加上这个int参数并不是为了接收具体的值，仅仅是为了占位，为的就是跟前置++构成重载函数来区分二者。

++da1;//da1.operator++();
da2++;//da2.operator++(0);
1
2
class Date
{
public:
  Date(int year = 1900, int month = 1, int day = 1)
  {
  _year = year;
  _month = month;
  _day = day;
  }
  //前置++
  Date& operator++()
  {
  _day += 1;
  return *this;
  }
  //后置++
  Date operator++(int)
  {
  Date tmp(*this);
  _day += 1;
  return tmp;
  }
private:
  int _year;
  int _month;
  int _day;
};

1.前置++时，由于this指针指向的对象在函数结束后并不会销毁，所以前置++可以返回引用。

2.后置++时，由于要返回++之前的值，所以我们要先临时保存一份this指针指向的对象（即利用tmp来保存，Date tmp(*this)），然后才能进行返回操作。注意：tmp是临时对象，因此只能以值的方式返回，不能返回引用。

内置类型的前置++和后置++在效率上其实差距并不是太大的自定义，类型的前置++后置++在效率上才会有明显的差别。所以我们用的话会一般会使用前置++，因为后置++会凭空多创建2个对象。

以上就是C++类和对象中拷贝构造函数和赋值运算符重载的介绍。