四、拷贝构造函数

1.拷贝构造函数的概念

学习了构造函数可以对新对象进行赋初值后，我们可能会有一个问题：创建对象时，可否创建一个与已存在对象一某一样的新对象呢？如果可以，它又是怎么创建的？还是用构造函数进行初始化吗？

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

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

无穷递归调用图解：

产生这个问题的原因：传值传参是将实参的一份临时拷贝作为参数传给函数，因此如果拷贝函数使用传值传参，那么在形成临时拷贝这一过程就会调用拷贝构造函数，就会导致拷贝的递归调用。

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

举个例子：

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

运行这段代码，我们会发现程序崩溃了。

那么程序崩溃的原因是什么呢？

首先，通过调试我们发现程序崩溃是在结束程序的一瞬间，也就结束程序时出现了问题。

其次，通过上面的学习，我们知道程序结束，又或者对象在被销毁时会自动调用其析构函数，因此初步判断是析构函数出现问题。那么析构函数又为什么会出错呢？

接着，通过进一步调试分析，我们将问题锁定在拷贝构造这一部分：

如图所示，将拷贝构造这个操作注释编译器就可以成功编译。

程序分析图解：

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

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

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

运行结果：

程序分析图解：

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

五、赋值运算符重载

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;
}
int main()
{
  Test();
  return 0;
}

运行结果如下：

要保证这里的封装性我们有两种解决办法：

1.将全局函数声明为类的友元函数（关于友元函数之后会详细说明）；

2.直接将函数定义为成员函数。

class Date
{
public:
  Date(int year = 1900, int month = 1, int day = 1)
  {
    _year = year;
    _month = month;
    _day = day;
  }
  // bool operator==(Date* this, const Date& d2)
  // 这里需要注意的是，左操作数是this，指向调用函数的对象
  bool operator==(const Date& d2)
  {
    return _year == d2._year
      && _month == d2._month
      && _day == d2._day;
  }
private:
  int _year;
  int _month;
  int _day;
};
void Test()
{
  Date d1(2018, 9, 26);
  Date d2(2018, 9, 27);
  cout << (d1 == d2) << endl;
}
int main()
{
  Test();
  return 0;
}

运行结果如下：

2.赋值运算符重载

1.赋值运算符重载格式

参数类型：const T&，传递引用可以提高传参效率
返回值类型：T&，返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值
需要检测是否自己给自己赋值
返回*this ：要符合连续赋值的含义（如a=b=c=1,“=”运算符是从右至左结合,意味着先将1赋给c,再将c赋给b,再将b赋给a,此时 a,b,c都是1,即完成了连续赋值。）

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

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 =”必须是非静态成员

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

C++之面向对象（中）（二）

四、拷贝构造函数

1.拷贝构造函数的概念

2.拷贝构造函数的特性

五、赋值运算符重载

1.运算符重载

2.赋值运算符重载

1.赋值运算符重载格式

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

热门文章

最新文章

相关课程

相关电子书

相关实验场景