AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

【C++】：拷贝构造函数和赋值运算符重载

2024-06-24 36
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 【C++】：拷贝构造函数和赋值运算符重载

一，拷贝构造函数

1. 什么是拷贝构造函数

拷贝构造函数是特殊的构造函数。是用一个已经存在的对象，赋值拷贝给另一个新创建的已经存在的对象。

本质：用同类型的对象拷贝初始化。

2. 拷贝构造函数的特性

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

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

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

注意：

  • Date d2(d1); 这句代码也等价于Date d2 = d1;也是拷贝构造的写法。
#include <iostream>
using namespace std;
class Date
{
public:
  Date(int year, int month, int day)
  {
    _year = year;
    _month = month;
    _day = day;
  }
  
  //拷贝构造函数
  //参数只有一个，必须是类类型对象的引用。
    //Date d2(d1); 
  Date(Date& d)   //传引用，正确写法
  //Date(Date d)  //传值，错误写法
{
    //用来检测是否调用该拷贝构造函数
  cout << "Date(Date& d)" << endl;
  //d1是d的别名，隐含的this就是d2,相当于把d1的值拷贝给d2
  _year = d._year;
  _month = d._month;
  _day = d._day;
}
  void Print()
  {
    cout << _year << "-" << _month << "-" << _day << endl;
  }
private:
  int _year;  // 年
  int _month; // 月
  int _day;   // 日
};
int main()
{
  Date d1(2024,4,21);
  d1.Print();
  //d2对象不在按指定年月日初始化，而是想和d1对象初始化一样
  //拷贝构造：用同类型的对象拷贝初始化
  
  Date d2(d1);//这句代码也等价于Date d2 = d1;也是拷贝构造的写法
  d2.Print();
  return 0;
}

如果是传值的方式，如上述代码中的错误写法，程序会直接报错。

这是为什么呢？

这是因为自定义类型传值传参要调用拷贝构造，而内置类型就是直接拷贝。

通过下面的代码来侧面说明：

定义一个 func 函数，把类对象 d1 传值过去，运行的结果是调用func之前会先调用拷贝构造函数。

class Date
{
public:
  Date(int year, int month, int day)
  {
    _year = year;
    _month = month;
    _day = day;
  }
  
  Date(Date& d)  
{
    //用来检测是否调用该拷贝构造函数
  cout << "Date(Date& d)" << endl;
  //d1是d的别名，隐含的this就是d2,相当于把d1的值拷贝给d2
  _year = d._year;
  _month = d._month;
  _day = d._day;
}
  void Print()
  {
    cout << _year << "-" << _month << "-" << _day << endl;
  }
private:
  int _year;  // 年
  int _month; // 月
  int _day;   // 日
};
void func(Date d)
{
  d.Print();
}
int main()
{
  Date d1(2024, 4, 12);
  
  //调用func之前会先进入拷贝构造函数
  func(d1);
  return 0;
}

所以在 2.2 的代码中，如果进行传值调用，则在语法逻辑上会出现如下的无穷递归：

那如何让它不调用拷贝构造呢？

方式1：传地址（相当于变为内置类型）

class Date
{
public:
  Date(int year, int month, int day)
  {
    _year = year;
    _month = month;
    _day = day;
  }
  
  Date(Date& d)  
{
    //用来检测是否调用该拷贝构造函数
  cout << "Date(Date& d)" << endl;
  //d1是d的别名，隐含的this就是d2,相当于把d1的值拷贝给d2
  _year = d._year;
  _month = d._month;
  _day = d._day;
}
  void Print()
  {
    cout << _year << "-" << _month << "-" << _day << endl;
  }
private:
  int _year;  // 年
  int _month; // 月
  int _day;   // 日
};
void func(Date* d)
{
  d->Print();
}
int main()
{
  Date d1(2024, 4, 12);
  func(&d1);
  return 0;
}

方式2：传引用（一般都是传引用）。

class Date
{
public:
  Date(int year, int month, int day)
  {
    _year = year;
    _month = month;
    _day = day;
  }
  
  Date(Date& d)  
{
    //用来检测是否调用该拷贝构造函数
  cout << "Date(Date& d)" << endl;
  //d1是d的别名，隐含的this就是d2,相当于把d1的值拷贝给d2
  _year = d._year;
  _month = d._month;
  _day = d._day;
}
  void Print()
  {
    cout << _year << "-" << _month << "-" << _day << endl;
  }
private:
  int _year;  // 年
  int _month; // 月
  int _day;   // 日
};
void func(Date& d)//d是d1的别名
{
  d.Print();
}
int main()
{
  Date d1(2024, 4, 12);
  
  //调用func之前会先进入拷贝构造函数
  func(d1);
  return 0;
}

那有些人会想，拷贝构造函数能不能用指针呢？这能不能避免无穷递归？

答案：可以的。可以完成拷贝，但是此时这个函数就不是拷贝构造函数了，而是一个普通的构造函数。

class Date
{
public:
  Date(int year, int month, int day)
  {
    _year = year;
    _month = month;
    _day = day;
  }
  //用指针就不会形成无穷递归，但此时它就是一个普通构造了，不是拷贝构造。
  //感觉怪怪的，所以一般用引用
  Date(Date* d)
  {
      _year = d->_year;
    _month = d->_month;
    _day = d->_day;
  }
  void Print()
  {
    cout << _year << "-" << _month << "-" << _day << endl;
  }
private:
  int _year;  // 年
  int _month; // 月
  int _day;   // 日
};
int main()
{
  Date d2(2024, 4, 21);
  Date d3(&d2);
  d3.Print();
  return 0;
}

说明：

  • 虽然传地址可以避免无穷递归，并且可以完成拷贝，但是这样怪怪的。在C++中，一般是传引用。并且传引用可以减少拷贝，提高了效率。

在拷贝函数中还有一点就是：在传引用时一般要加 const 修饰。

在显式写拷贝构造函数时，参数写反了……(这就有点尴尬了)

运行结果是：拷贝一堆随机值。

加上 const 之后：

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

注意：

  • 在编译器生成的默认拷贝构造函数中，内置类型是按照字节方式直接拷贝的，而自定义类型是调用其拷贝构造函数完成拷贝的。
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
{
public:
  Date(int year, int month, int day)
  {
    _year = year;
    _month = month;
    _day = day;
  }
  void Print()
  {
    cout << _year << "-" << _month << "-" << _day << endl;
  }
private:
  // 基本类型(内置类型)
  int _year = 1970;
  int _month = 1;
  int _day = 1;
  // 自定义类型
  Time _t;
};
int main()
{
  Date d1(2024, 4, 23);
  // 用已经存在的d1拷贝构造d2，此处会调用Date类的拷贝构造函数
  // 但Date类并没有显式定义拷贝构造函数，则编译器会给Date类生成一个默认的拷贝构造函数
    Date d2(d1);
    d2.Print();
  return 0;
}

2.4.编译器生成的默认拷贝构造函数已经可以完成字节序的值拷贝了，还需要自己显式实现吗？当然像日期类这样的类是没必要的。那么下面的类呢？验证一下试试？

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)
  {
    // CheckCapacity();
    _array[_size] = data;
    _size++;
  }
  //注意：如果没有显示写析构函数，编译器也会自动生成。
  //自动生成的析构对内置类型不做处理，自定义类型才会去调用它的析构
  ~Stack()
  {
    if (_array)
    {
      free(_array);
      _array = NULL;
      _capacity = 0;
      _size = 0;
    }
  }
private:
  DataType* _array;
  int _capacity;
  int _size;
};
int main()
{
  Stack st1;
  st1.Push(1);
  st1.Push(1);
  st1.Push(1);
  
  Stack st2 = st1;
  return 0;
}

运行结果：完成了拷贝，但程序崩溃！

原因：

  • 当栈调用默认生成的拷贝构造函数时，这种函数进行的是浅拷贝(值拷贝) 本质是按字节进行拷贝的。这可能会导致当两个对象指向同一块空间时，如_array，当st1 和st2生命周期结束时，两个对象会分别析构，就相当于释放了两次。 常见的数据结构，栈，队列，链表，树等都有这个问题。

解决方案：

深拷贝：当有指针指向资源时，会开辟建立一块和要拷贝的一模一样的空间，形状，再进行拷贝。

//实现栈的深拷贝
//Stack st2 = st1;  //st是st1的别名
Stack(const Stack& st)
{
  _array = (DataType*)malloc(sizeof(DataType) * st._capacity);
  if (NULL == _array)
  {
    perror("malloc申请空间失败!!!");
    return;
  }
  //开辟好空间后再把值拷贝进去
  memcpy(_array, st._array, sizeof(DataType) * st._size);
  _size = st._size;
  _capacity = st._capacity;
}

把上面栈的深拷贝的代码插入 2.4 的类中，调试结果是：

3. 实践总结

1.如果没有管理资源，一般情况下不需要写拷贝构造，用编译器默认生成的拷贝构造就可以。如 Date类；

2.如果都是自定义类型成员，内置类型成员没有指向资源，用编译器默认生成的拷贝构造就可以。如 MyQueue ；

（小技巧：一般情况下，不需要写析构的，就不需要写拷贝构造。）

3.如果内部有指针或者有一些值指向资源，需要显式写析构函数释放，通常就需要显式写拷贝构造完成深拷贝。如各种数据类型栈，队列，链表，树等。

二，赋值运算符重载

2.1 运算符重载

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

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

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

注意：

  • 不能通过连接其他符号来创建新的操作符：比如operator@ ;
  • 重载操作符必须有一个类类型参数 ；
  • 用于内置类型的运算符，其含义不能改变，例如：内置的整型+，不能改变其含义 (这条仅供参考)；
  • 作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的this；
  • . * (调用成员函数的指针) ， :: (域作用限定符) ， sizeof (计算变量所占内存的大小) ，?: （三目运算符）， . (结构体变量引用符)，注意以上5个运算符不能重载。这个经常在笔试选择题中出现。

简单介绍一下 . * 运算符的用法：

class OB
{
public:
  void func()
  {
    cout << "void func()" << endl;
  }
};
//重新定义成员函数指针类型
//注意：typedef void(*)()  PtrFunc; 是错误写法
typedef  void (OB::* PtrFunc)();
int main()
{
  //成员函数要加&才能取到函数指针
  PtrFunc fp = &OB::func; //定义成员函数指针fp 指向函数func
  OB tmp;//定义OB类对象tmp
  (tmp.*fp)(); //调用成员函数的指针
  return 0;
}

运算符重载的使用：

class Date
{
public:
  Date(int year , int month , int day )
  {
    _year = year;
    _month = month;
    _day = day;
  }
  //d3.operator== (d4)
  //d3传给了隐含的this指针，d是d4的别名
   bool operator== (const Date & d)
   {
     return _year == d._year
       && _month == d._month
       && _day == d._day;
   }
  void Print()
  {
    cout << _year << "-" << _month << "-" << _day << endl;
  }
private:
  int _year;  // 年
  int _month; // 月
  int _day;   // 日
};
//但是如果全局重载（没有private时)和成员函数同时存在，编译不会报错，
//调用时会默认调成员函数，相当于全局重载没有任何意义了。
int main()
{
  Date d3(2024, 4, 12);
  Date d4(2024, 4, 15);
  //显式调用(一般不这样写)
  //cout << d3.operator== (d4) << endl;
  //转换调用 等价于d3.operator== (d4) 汇编代码
  //注意：如果是两个操作数，从左到右的参数是对应的，不能颠倒位置
  cout << (d3 == d4) << endl;
  return 0;
}

2.2 赋值运算符重载

2.2.1 赋值运算符重载格式

  • 参数类型：const 类名 &，传递引用可以减少拷贝，提高传参效率；
  • 返回值类型：类名 &，返回引用可以减少拷贝，提高返回的效率，有返回值目的是为了支持连续赋值；
  • 检测是否自己给自己赋值；
  • 返回*this ：要复合连续赋值的含义.
class Date
{
public:
  Date(int year = 2024, int month = 4, int day = 21)
  {
    _year = year;
    _month = month;
    _day = day;
  }
  //拷贝构造
  Date(const Date& d)
  {
    cout << "Date(const Date& d)" << endl;
    _year = d._year;
    _month = d._month;
    _day = d._day;
  }
  //d1 = d3
  //void operator= (const Date& d)
  //{
  //  _year = d._year;
  //  _month = d._month;
  //  _day = d._day;
  //}
  //有时候会带返回值:目的是为了连续拷贝
  //d1 = d2 = d3; 
  //比如这里，d是d3的别名，从右往左，先d2 = d3,返回值是d2
  Date& operator= (const Date& d)
  {
      //检测是否自己给自己赋值
       if(this != &d)
    {
      _year = d._year;
      _month = d._month;
      _day = d._day;
    }
        
      //这里的d2的地址是this ，*this就是d2。
      //这里的*this才是对象本身，对象在main的作用域
      //里创建的，因此出main作用域才会析构销毁，
      //出了当前函数不会析构。所以可以用引用返回。
    return *this;
  }
  void Print()
  {
    cout << _year << "-" << _month << "-" << _day << endl;
  }
private:
  int _year;  // 年
  int _month; // 月
  int _day;   // 日
};
int main()
{
  Date d1(2024, 4, 12);
  //拷贝构造
  //一个已经存在的对象，拷贝给另一个要创建初始化的对象
  Date d2 = d1;
  Date d3(2024, 5, 1);
  //赋值拷贝/赋值重载
  //一个已经存在的对象，拷贝赋值给另一个已经存在的对象
  //d1 = d3;
  //连续赋值
  d1 = d2 = d3;
  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;
  }

总结一下：

  • 如果返回对象是一个局部对象或者临时对象，出了当前函数作用域就析构销毁了，就不能用引用返回。用引用返回是存在风险的，因为引用对象在当前函数栈帧已经被销毁了。所以虽然引用返回可以减少一次拷贝，但是出了函数作用域，返回对象还在，才能用引用返回。

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

注意：

  • 重载成全局函数时就没有this指针了。

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

注意：

  • 内置类型成员变量是直接赋值的，而自定义类型成员变量需要调用对应类的赋值运算符重载完成赋值。
文章标签：
C++
编译器
存储
关键词：
C++运算符重载
C++赋值
C++赋值运算符重载
C++拷贝构造函数
C++拷贝构造函数赋值运算符重载
24k纯甄
目录
相关文章
ephemerals__
|
2月前
|
存储 编译器 C++
【c++】类和对象（下）（取地址运算符重载、深究构造函数、类型转换、static修饰成员、友元、内部类、匿名对象）
本文介绍了C++中类和对象的高级特性，包括取地址运算符重载、构造函数的初始化列表、类型转换、static修饰成员、友元、内部类及匿名对象等内容。文章详细解释了每个概念的使用方法和注意事项，帮助读者深入了解C++面向对象编程的核心机制。
ephemerals__
111 5
可能只会写BUG
|
4月前
|
C++
C++(十五) 运算符重载
C++中的运算符重载允许对已有运算符的功能进行重新定义，从而扩展语言功能、简化代码并提升效率。重载遵循特定语法，如 `friend 类名 operator 运算符(参数)`。重载时需注意不可新增或改变运算符数量、语义、优先级、结合性和返回类型。常见示例包括双目运算符 `+=` 和单目运算符 `-` 及 `++`。输入输出流运算符 `&lt;&lt;` 和 `&gt;&gt;` 也可重载。部分运算符只能作为成员函数重载。
可能只会写BUG
79 2
笨笨小乌龟
|
6月前
|
自然语言处理 程序员 C++
C++基础知识（五：运算符重载）
运算符重载是C++中的一项强大特性，它允许程序员为自定义类型（如类或结构体）重新定义标准运算符的行为，使得这些运算符能够适用于自定义类型的操作。这样做可以增强代码的可读性和表达力，使得代码更接近自然语言，同时保持了面向对象编程的封装性。
笨笨小乌龟
79 0
百锦再@新空间代码工作室
|
6月前
|
Java 程序员 C++
C++学习之运算符重载
C++学习之运算符重载
百锦再@新空间代码工作室
79 0
东洛的克莱斯韦克
|
6月前
|
编译器 C++
【C++】详解运算符重载，赋值运算符重载，++运算符重载
【C++】详解运算符重载，赋值运算符重载，++运算符重载
东洛的克莱斯韦克
39 0
ephemerals__
|
2月前
|
存储 编译器 C语言
【c++丨STL】string类的使用
本文介绍了C++中`string`类的基本概念及其主要接口。`string`类在C++标准库中扮演着重要角色，它提供了比C语言中字符串处理函数更丰富、安全和便捷的功能。文章详细讲解了`string`类的构造函数、赋值运算符、容量管理接口、元素访问及遍历方法、字符串修改操作、字符串运算接口、常量成员和非成员函数等内容。通过实例演示了如何使用这些接口进行字符串的创建、修改、查找和比较等操作，帮助读者更好地理解和掌握`string`类的应用。
ephemerals__
60 2
ephemerals__
|
2月前
|
存储 编译器 C++
【c++】类和对象（中）（构造函数、析构函数、拷贝构造、赋值重载）
本文深入探讨了C++类的默认成员函数，包括构造函数、析构函数、拷贝构造函数和赋值重载。构造函数用于对象的初始化，析构函数用于对象销毁时的资源清理，拷贝构造函数用于对象的拷贝，赋值重载用于已存在对象的赋值。文章详细介绍了每个函数的特点、使用方法及注意事项，并提供了代码示例。这些默认成员函数确保了资源的正确管理和对象状态的维护。
ephemerals__
111 4
ephemerals__
|
2月前
|
存储 编译器 Linux
【c++】类和对象（上）（类的定义格式、访问限定符、类域、类的实例化、对象的内存大小、this指针）
本文介绍了C++中的类和对象，包括类的概念、定义格式、访问限定符、类域、对象的创建及内存大小、以及this指针。通过示例代码详细解释了类的定义、成员函数和成员变量的作用，以及如何使用访问限定符控制成员的访问权限。此外，还讨论了对象的内存分配规则和this指针的使用场景，帮助读者深入理解面向对象编程的核心概念。
ephemerals__
148 4
白子寰
|
3月前
|
存储 编译器 对象存储
【C++打怪之路Lv5】-- 类和对象（下）
【C++打怪之路Lv5】-- 类和对象（下）
白子寰
35 4
白子寰
|
3月前
|
编译器 C语言 C++
【C++打怪之路Lv4】-- 类和对象（中）
【C++打怪之路Lv4】-- 类和对象（中）
白子寰
33 4