《Effective C++》《构造/析构/赋值运算——12、复制对象时勿忘记其每一个成分》

最新推荐文章于 2024-11-11 20:45:30 发布
最新推荐文章于 2024-11-11 20:45:30 发布
阅读量744 收藏 25
点赞数 18
分类专栏： # 《Effective C++》 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zwh1298454060/article/details/137403514
版权
本文详细探讨了C++中对象复制的机制，包括浅拷贝与深拷贝的区别，复制构造函数和赋值运算符的实现，以及如何正确处理资源管理以避免切片问题。作者通过示例代码展示了正确的复制策略和潜在的陷阱，以及推荐使用智能指针进行资源管理。
摘要由CSDN通过智能技术生成

文章目录

1、Terms12:Copy all parts of an object

先给出结论：

  • ①Copying函数应该确保复制“对象内的all的成员变量”and“all的base class的成分”
  • ②不要尝试以某一个copying函数来实现另外一个copying函数，若想消除重复的代码，具体做法就是建立一个新的成员函数给copy构造和copy assignment函数来调用，而这样的函数往往是private的且常常被命名为init。这个策略可以安全地消除copy构造函数和copy assignment操作符之间的重复代码。

示例代码1:

这是一个正常的，简单的函数，也没有继承。此时自定义他的copying函数，运行下来是没有问题的。

#include <iostream>  
#include <string>  
using namespace std;

// logCall 函数的实现  
void logCall(const std::string& funcName) {  
    std::cout << "Logging call to: " << funcName << std::endl;  
}  
  
class Customer {  
public:  
    // 默认构造函数  
    Customer() = default;  
  
    // 复制构造函数  
    Customer(const Customer& rhs)  
        : name(rhs.name) {  
        logCall("Customer copy constructor");  
    }  
  
    // 复制赋值运算符  
    Customer& operator=(const Customer& rhs) {  
        if (this != &rhs) { // 检查自赋值  
            logCall("Customer copy assignment operator");  
            name = rhs.name;  
        }  
        return *this;  
    }  
  
    // 析构函数（可选，但通常是好的做法）  
    ~Customer() = default;  
  
    // 其他成员函数...  
  
private:  
    std::string name;  
};  
  
int main() {  
    Customer customer1;             // 使用默认构造函数  
    Customer customer2(customer1);  // 使用复制构造函数  
    Customer customer3;  
    customer3 = customer1;          // 使用复制赋值运算符  
    return 0;  
}

示例代码2:

在示例代码2中，在原先的Customer类中新增加了一个成员变量，因为是自定义的，在无明显语法错误的情况下，他并不会提示你代码不完整。毕竟自定义在提供一定“自主权”的前提下，编码者也要承担一定的责任。

#include <iostream>  
#include <string>  
using namespace std;  
  
// logCall 函数的实现  
void logCall(const std::string& funcName) {  
    std::cout << "Logging call to: " << funcName << std::endl;  
}  
  
// Date 类的简单实现  
class Date {  
public:  
    Date() {  
        // 初始化代码，如果有的话  
    }  
  
    // 假设这里还有其他的成员函数，比如设置日期、获取日期等  
    // ...  
  
private:  
    // 日期成员变量，比如年、月、日  
    int year;  
    int month;  
    int day;  
};  
  
class Customer {  
public:  
    // 默认构造函数  
    Customer() = default;  
  
    // 复制构造函数  
    Customer(const Customer& rhs)  
        : name(rhs.name) {  
        logCall("Customer copy constructor");  
    }  
  
    // 复制赋值运算符  
    Customer& operator=(const Customer& rhs) {  
        if (this != &rhs) { // 检查自赋值  
            logCall("Customer copy assignment operator");  
            name = rhs.name;  
        }  
        return *this;  
    }  
  
    // 析构函数（可选，但通常是好的做法）  
    ~Customer() = default;  
  
    // 其他成员函数...  
  
private:  
    std::string name;  
    Date lastTransaction; // 使用 Date 类型的成员变量  
};  
  
int main() {  
    Customer customer1; // 使用默认构造函数  
    Customer customer2(customer1); // 使用复制构造函数  
    Customer customer3;  
    customer3 = customer1; // 使用复制赋值运算符  
    return 0;  
}

如果一个类拥有基类，那么在拷贝复制的时候不仅要复制派生类的部分，还要复制基类的部分。举出正反两个例子。

示例代码3:

class PriorityCustomer :public Customer
{
public:
...
PriorityCustomer(const PriorityCustomer& rhs);
PriorityCustomer& operator=(const PriorityCustomer& rhs);
...
private:
	int priority;
};
反面示例：
 // 复制构造函数
   
    PriorityCustomer(const PriorityCustomer& rhs)  
        : priority(rhs.priority) {  
        logCall("PriorityCustomer copy constructor");  
    }  
  
    // 复制赋值运算符  
    PriorityCustomer& operator=(const PriorityCustomer& rhs){  
     logCall("PriorityCustomer copy assignment operator");
        if (this != &rhs) { // 检查自赋值  
            priority = rhs.priority;  
        }  
        return *this;  
    }  
正面示例：
    // 复制构造函数  
    PriorityCustomer(const PriorityCustomer& rhs)  
        : Customer(rhs), // 调用基类的拷贝构造函数  
        priority(rhs.priority) {  
        logCall("PriorityCustomer copy constructor");  
    }  
  
    // 复制赋值运算符  
    PriorityCustomer& operator=(const PriorityCustomer& rhs) {  
        if (this != &rhs) { // 检查自赋值  
            Customer::operator=(rhs); // 对基类部分进行赋值操作  
            priority = rhs.priority;  
        }  
        return *this;  
    }

在反面例子中，派生类的成员函数好像复制了派生类的每一样东西。但是派生类的copy构造函数并没有指定实参给其基类的构造函数，因此派生类对象的基类成份会被不带实参的基类构造函数初始化，default构造函数将会对name和lastTransaction执行缺省的初始化动作。

示例代码4:

这是一个完整的可以编译的代码。

#include <iostream>  
#include <string>  
using namespace std;  
  
// logCall 函数的实现  
void logCall(const std::string& funcName) {  
    std::cout << "Logging call to: " << funcName << std::endl;  
}  
  
// Date 类的简单实现  
class Date {  
public:  
    // 构造函数，接受年、月、日作为参数  
    Date(int y, int m, int d) : year(y), month(m), day(d) {  
        // 可以在这里添加一些验证逻辑，确保日期是有效的  
    }  
  
    // 默认构造函数  
    Date() = default;  
  
    // 访问器方法  
    int getYear() const {  
        return year;  
    }  
  
    int getMonth() const {  
        return month;  
    }  
  
    int getDay() const {  
        return day;  
    }  
  
    // 可能还需要添加设置日期的方法、比较日期的方法等  
  
private:  
    // 日期成员变量，比如年、月、日  
    int year;  
    int month;  
    int day;  
};  
  
class Customer {  
public:  
    // 默认构造函数  
    Customer() = default;  
    // 添加一个新的构造函数，接受一个字符串和一个Date对象  
    Customer(const std::string& name, const Date& lastTransaction)   
        : name(name), lastTransaction(lastTransaction) {}  
  
    // 复制构造函数  
    Customer(const Customer& rhs)  
        : name(rhs.name), lastTransaction(rhs.lastTransaction) { // 初始化 lastTransaction  
        logCall("Customer copy constructor");  
    }  
  
    // 复制赋值运算符  
    Customer& operator=(const Customer& rhs) {  
        if (this != &rhs) { // 检查自赋值  
            logCall("Customer copy assignment operator");  
            name = rhs.name;  
            lastTransaction = rhs.lastTransaction;  
        }  
        return *this;  
    }  
  
    // 析构函数（可选，但通常是好的做法）  
    ~Customer() = default;  
    std::string getName()
	{
		return this->name;
	}
	// 获取最后交易日期的年份  
    int getLastTransactionYear() const {  
        return lastTransaction.getYear();  
    }  
  
    // 获取最后交易日期的月份  
    int getLastTransactionMonth() const {  
        return lastTransaction.getMonth();  
    }  
  
    // 获取最后交易日期的日  
    int getLastTransactionDay() const {  
        return lastTransaction.getDay();  
    }  
    virtual void showInfo() {}
  
private:  
    std::string name;  
    Date lastTransaction; // 使用 Date 类型的成员变量  
};  
  
// PriorityCustomer 类继承自 Customer 类  
class PriorityCustomer : public Customer {  
public:  
    // 默认构造函数  
    PriorityCustomer() = default; 
    // 原始的构造函数，接受名字、最后交易日期和优先级 
    PriorityCustomer(const std::string& name, const Date& lastTransaction, int priority)  
        : Customer(name, lastTransaction), priority(priority) {}  
    // 新的构造函数，接受一个 Customer 对象和一个优先级参数  
    PriorityCustomer(const Customer& baseCustomer, int priority)  
        : Customer(baseCustomer), priority(priority) {} // 委托给基类的拷贝构造函数 
    
    // 复制构造函数  
    PriorityCustomer(const PriorityCustomer& rhs)  
        : Customer(rhs), // 调用基类的拷贝构造函数  
        priority(rhs.priority) {  
        logCall("PriorityCustomer copy constructor");  
    }  
  
    // 复制赋值运算符  
    PriorityCustomer& operator=(const PriorityCustomer& rhs) {  
        if (this != &rhs) { // 检查自赋值  
            Customer::operator=(rhs); // 对基类部分进行赋值操作  
            priority = rhs.priority;  
        }  
        return *this;  
    }  
  
    // 析构函数（可选，但通常是好的做法）  
    ~PriorityCustomer() = default;  
    
    // 获取优先级的方法  
    int getPriority() const {  
        return priority;  
    }  
    
    // 其他成员函数...  
    virtual void showInfo(){
         cout << " customer name: " << this->getName()
         << "\t transaction year: " << this->getLastTransactionYear() 
         << "\t  transaction month: " << this->getLastTransactionMonth() 
         << "\t  transaction day: " << this->getLastTransactionDay() << std::endl; 
    }
  
private:  
    int priority; // PriorityCustomer 特有的成员变量  
};  
void test(){
    Date date1(2024,3,11);
    Customer customer1("Alice",date1);
    PriorityCustomer priorityCustomer1(customer1,1);
    PriorityCustomer priorityCustomer2;
    priorityCustomer2 = priorityCustomer1;
    PriorityCustomer priorityCustomer3(priorityCustomer1);
    cout << "priorityCustomer1 info" <<endl;
    priorityCustomer1.showInfo();
    cout << "priorityCustomer2 info" <<endl;
    priorityCustomer2.showInfo();
    cout << "priorityCustomer3 info" <<endl;
    priorityCustomer3.showInfo();
}
int main() {  
    test();
    return 0;  
}

编译输出结果：

Logging call to: Customer copy constructor
Logging call to: Customer copy assignment operator
Logging call to: Customer copy constructor
Logging call to: PriorityCustomer copy constructor
priorityCustomer1 info
 customer name: Alice    transaction year: 2024   transaction month: 3    transaction day: 11
priorityCustomer2 info
 customer name: Alice    transaction year: 2024   transaction month: 3    transaction day: 11
priorityCustomer3 info
 customer name: Alice    transaction year: 2024   transaction month: 3    transaction day: 11

示例代码5

正面教材：
PriorityCustomer(const PriorityCustomer& rhs)  
        : Customer(rhs), // 调用基类的拷贝构造函数  
        priority(rhs.priority) {  
        logCall("PriorityCustomer copy constructor");  
    }  
反面教材1：
PriorityCustomer(const PriorityCustomer& rhs):priority(rhs.priority){  
        logCall("PriorityCustomer copy constructor"); 
    }
    
反面教材2：
    //反面教材
     PriorityCustomer(const PriorityCustomer& rhs):priority(rhs.priority){ 
         Customer::Customer(rhs);//在一个copying函数中去调用另一个copying函数
         logCall("PriorityCustomer copy constructor"); 
     }

反面教材1:
输出结果：

Logging call to: Customer copy constructor
Logging call to: Customer copy assignment operator
Logging call to: PriorityCustomer copy constructor
priorityCustomer1 info
 customer name: Alice    transaction year: 2024   transaction month: 3    transaction day: 11
priorityCustomer2 info
 customer name: Alice    transaction year: 2024   transaction month: 3    transaction day: 11
priorityCustomer3 info
 customer name:          transaction year: 0      transaction month: 0    transaction day: 0

在正面例子中用初始化列表来给派生类的对象rhs中的Base class成分赋值，这就是良好的codes！如果你不这样干的话当你使用 PriorityCustomer priorityCustomer3
(priorityCustomer1);类似这样拷贝的操作的时候就没法把Base class中的成分赋值过来，这样的话你再输出PriorityCustomer priorityCustomer3的all属性的话，其中priorityCustomer3的Base class 成员属性就会乱码！因为你没有给它们初始化！！！

反面2:
输出结果

main.cpp: In copy constructor ‘PriorityCustomer::PriorityCustomer(const PriorityCustomer&)’:
main.cpp:125:27: error: cannot call constructor ‘Customer::Customer’ directly [-fpermissive]
  125 |         Customer::Customer(rhs);//在一个copying函数中去调用另一个copying函数
      |         ~~~~~~~~~~~~~~~~~~^~~~~
main.cpp:125:27: note: for a function-style cast, remove the redundant ‘::Customer’

这里虽然也调用了Base class 的copy 构造函数，但是这里是把PriorityCustomer的copy构造函数内去调用的Customer::Customer(rhs);中的rhs当做是一个已经存在了的对象，把它里面的Base class 成分赋值给自己的Base class 成分，这不就是自己赋值 给自己嘛，本来自己PriorityCustomer3就没初始化，还有用自己的Base class成分给自己赋值一遍，这显然不会如你所愿！
或者，你可以这样理解，因为这里PriorityCustomer的copy 构造函数中，传入的参数是const PriorityCustomer& rhs有引用的类型，因此你不能再让rhs赋值为别人（也包括rhs赋值为自己），也即对于引用类型而言，因为为引用必须在定义的时候初始化，并且不能重新赋值，所以必须要写在初始化列表中，也即调用Base的copy构造函数初始化PriorityCustomer类对象的Base class类成分（成员属性）时，必须要写在派生类的copy构造函数中的初始化列表中 ！

2、面试相关

2.1 浅拷贝与深拷贝：

  • 浅拷贝：只是简单地复制对象的指针或引用，而不是实际的数据。这可能导致两个对象共享相同的资源，从而引发问题（如悬挂指针、数据不一致等）。
  • 深拷贝：创建对象的一个新副本，包括所有动态分配的内存或其他资源。这样可以确保每个对象都有自己独立的资源。

2.2 复制构造函数：

  • 当使用=操作符赋值或传递对象给函数时，C++会调用复制构造函数来创建一个新的对象副本。如果没有显式定义复制构造函数，编译器会生成一个默认的复制构造函数。
  • 复制构造函数应确保对象的所有成员都被正确复制，包括动态分配的内存。

2.3 赋值运算符重载：

  • 与复制构造函数类似，赋值运算符operator=也需要正确处理对象的所有成分。
  • 在实现赋值运算符时，通常需要处理自赋值的情况（即对象赋值给自己），并考虑资源管理和异常安全性。

2.4 资源管理：

  • 当对象包含动态分配的内存或其他资源时，复制操作必须确保这些资源也被正确复制。
  • 使用智能指针（如std::unique_ptr和std::shared_ptr）可以简化资源管理，因为它们会自动处理资源的复制和删除。
  1. 避免切片问题：
    • 当基类指针或引用指向派生类对象，并通过复制操作传递给函数或赋值给另一个基类对象时，可能会丢失派生类特有的部分，只保留基类部分。这称为切片问题。

3、总结

天堂有路你不走，地狱无门你自来。

4、参考

4.1 《Effective C++》

zwh1298454060
关注
专栏目录
Effective C++条款12：构造/析构/赋值运算之（复制对象时勿忘其每一个成份）
董哥的黑板报
02-07 503
一、引入 我们在前面文章已经介绍了，如果类没有手动声明拷贝构造函数或拷贝赋值运算符，那么编译器会为我们自动生成这两个成员，并且它们的行为是：将被拷贝的对象的所有成员做一份拷贝 二、复制对象时确保复制所有成员 下面的类有两个成员变量，因此我们需要为每一份成员进行一份复制 Customer::Customer(const Customer& rhs) :name(rhs....
《Effective C++》《构造/析构/赋值运算——11、在operator=中处理“自我赋值”》
zwh1298454060的博客
04-04 920
11、在operator=中处理“自我赋值”
Effective C++条款12——复制对象时勿忘其每一个成分（构造/析构/赋值运算）
StudyWinter的博客
08-22 206
PriorityCustomer的copy构造函数并没有指定实参传给其base class构造函数（也就是说它在它的成员初值列(member initialization list）中没有提到Customer)，因此 PriorityCustomer对象的Customer成分会被不带实参之Customer构造函数（即default构造函数——必定有一个否则无法通过编译）初始化。对一个尚未构造好的对象赋值，就像在一个尚未初始化的对象身上做“只对已初始化对象才有意义”的事一样。,我称它们为copying函数。
《Effective C++》《构造/析构/赋值运算——8、别让异常逃离析构函数》
zwh1298454060的博客
03-31 614
8、别在析构函数中报异常
Effective C++ 1 构造/析构/赋值运算
qq_29257201的博客
02-22 205
文章目录05：了解C++默认编写并调用哪些函数06：若不想使用编译器自动生成的函数，就该明确拒绝07：为多态基类声明virtual析构函数08：别让异常逃离析构函数09： 绝不在构造和析构过程中调用virtual函数10： 令operator=返回一个reference to *this11： 在operator=中处理”自我赋值“12： 复制对象时勿忘其每个成分参考 05：了解C++默认编写并调用哪些函数 编译器可以暗自为class创建default构造函数、copy构造函数、copy assignme
Effective C++ 构造/析构/赋值运算
RolleX的博客
09-15 372
effective c++第二部分
《Effective C++》《构造/析构/赋值运算——5、了解C++默默编写并调用哪些函数》
zwh1298454060的博客
02-19 746
条款05：了解C++默默编写并调用哪些函数
《Effective C++》《构造/析构/赋值运算——7、为多态基类声明virtual析构函数》
zwh1298454060的博客
03-29 544
7、为多态基类声明virtual析构函数
Chapter 2 of Effective C++ （构造/析构/赋值运算）
Devlegal的博客
02-26 501
默认生成的copy构造函数和copy assignment操作符只是单纯的将源对象中的每一个non-static成员变量拷贝到目标对象（浅拷贝）。若一个类中存在const成员或引用成员，则不能使用默认生成的拷贝赋值操作符。
Effective C++条款06：构造/析构/赋值运算之（若不想使用编译器自动生成的函数，就该明确拒绝）
01-08
例如：我们不希望使用class的拷贝赋值运算符（那么就不能将一个对象赋值给另一个对象），那么就需要使用一些手段来禁止使用这些功能 文本介绍一些方法来禁止编译器为我们提供的这些默认函数 二、方式① 如果我们不...
Effective C++之2.构造析构赋值运算
01-20
在C++编程中，理解和掌握构造函数、析构函数、拷贝构造函数和赋值运算符的使用...以上就是《Effective C++》中关于构造析构赋值运算的部分核心概念，理解并遵循这些最佳实践将有助于编写更健壮、更易于维护的C++代码。
C++_用 using 语句继承基类的构造函数
学海无涯
11-09 241
**默认情况下**，派生类会继承基类的所有成员，包括数据成员和函数成员，但不会继承基类的**构造函数和析构函数**，因为构造函数和析构函数的作用是创建和销毁对象，派生类通常需要有自己的构造和析构的逻辑。C++11 引入了using语句，使得派生类可以通过 using 关键字使用基类的构造函数，更方便地复用基类的构造逻辑。
常用的c++特性--＞day02
m0_69093426的博客
11-06 685
C++11中为我们提供了一个模板类叫做std::enable_shared_from_this，这个类中有一个方法叫做shared_from_this()，通过这个方法可以返回一个共享智能指针，在函数的内部就是使用weak_ptr来监测this对象，并通过调用weak_ptr的lock()方法返回一个shared_ptr对象。通过打印的结果可以知道，虽然弱引用智能指针wp3、wp4、wp5监测的资源是同一个，但是它的引用计数并没有发生任何的变化，也进一步证明了weak_ptr只是监测资源，并不管理资源。
C++ string(2)实现精讲
Jason_from_China的博客
11-06 1720
C++ string的使用我们已经讲解了，接下来我们会讲解string的实现，但是并不是每一个我都会实现，比如string删除有好几个，但是我会删除只是实现一个erase，首先是使用的次数频繁，其次是都大差不差，没有必要实现那么多，我这里只是把string整体的逻辑给实现，对string有一个更深入的了解提升代码能力和思维能力。注意事项1。
2024年华为OD机试真题-查找充电设备-C++-OD统一考试（E卷）
面试高手的博客
11-08 299
某个充电站，可提供n个充电设备只，每个充电设备均有对应的输出功率任意个充电设备组合的输出功率总和，均构成功率集合P的1个元素功率集合P的最优元素，表示最接近充电站最大输出功率pmax 的元素。每一题都含有详细的解题思路和代码注释，精编c++、JAVA、Python三种语言解法。当充电设备输出功率50、20、20组合时，其输出功率总和为90，最接近充电站最大充电输出功率，因此最优元素为90。所有充电设备的输出功率组合，均大于充电站最大充电输出功率30，此时最优元素值为0。第 2 行为每个充电设备的输出功率。
【Effective C++】阅读笔记5
gma999的博客
11-07 911
Effective C++ 面向对象和模板相关章节
扫雷游戏代码分享(c基础)
最新发布
lb3636363636的博客
11-11 615
创建两个.c 一个.h。
c++ 分治算法
www_dong的博客
11-08 844
分治算法是一种重要的算法设计范式，其核心思想是将一个复杂的问题分解为多个规模较小的相同问题，逐步解决这些较小的问题，最后将这些问题的解合并成原问题的解。
Effective C++：提升C++编程技巧的核心指南
1. **视C++为一个语言联邦**：C++融合了过程化编程、面向对象编程和泛型编程等多种编程范式，因此在编程时需要理解其多元性，并灵活运用。 2. **使用const、enum、inline替换#define**：const用于声明常量，提供...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值