C++进阶之路:何为拷贝构造函数,深入理解浅拷贝与深拷贝(类与对象_中篇)

简介: C++进阶之路:何为拷贝构造函数,深入理解浅拷贝与深拷贝(类与对象_中篇)


拷贝构造函数

概念 :

在创建对象时,可否创建一个与已存在对象一某一样的新对象呢?

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

特征:

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

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

#include <iostream>
 
class MyClass {
private:
    int* data;
 
public:
    // 默认构造函数
    MyClass() {
        data = new int(0);
    }
 
    // 拷贝构造函数
    MyClass(const MyClass& other) {
        data = new int(*other.data);
    }
 
    // 析构函数
    ~MyClass() {
        delete data;
    }
 
    // 设置数据
    void setData(int value) {
        *data = value;
    }
 
    // 获取数据
    int getData() const {
        return *data;
    }
};
 
int main() {
    MyClass obj1;
    obj1.setData(42);
 
    // 使用拷贝构造函数创建新对象
    MyClass obj2(obj1);
 
    std::cout << "obj1 data: " << obj1.getData() << std::endl;
    std::cout << "obj2 data: " << obj2.getData() << std::endl;
 
    return 0;
}

在上述示例中,MyClass 类拥有一个指针 data,在默认构造函数中为其分配内存,并在析构函数中释放内存。拷贝构造函数通过使用 new 运算符,在堆上分配新的内存,并将原对象的数据复制到新内存中。

运行示例代码,输出结果为:

obj1 data: 42
obj2 data: 42

可以看到,通过拷贝构造函数创建的新对象 obj2 具有与原对象 obj1 相同的数据。


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

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

注意:在编译器生成的默认拷贝构造函数中,内置类型是按照字节方式直接拷贝的,而自定义类型是调用其拷贝构造函数完成拷贝的。

4. 编译器生成的默认拷贝构造函数已经可以完成字节序的值拷贝了,还需要自己显式实现吗?

如果一个类没有指针或引用等需要特别注意的成员变量,那么编译器生成的默认拷贝构造函数已经可以完成字节序的值拷贝了,不需要自己显式实现。这是因为默认拷贝构造函数会逐个复制对象的所有非静态成员变量,包括简单类型(如 int、double 等)和数组等。

然而,当一个类拥有指针或引用等需要特别注意的成员变量时,编译器生成的默认拷贝构造函数不能保证正确的深拷贝,会导致浅拷贝问题和内存泄漏等问题。此时,需要手动定义一个拷贝构造函数来进行深拷贝操作,从而避免这些问题的出现。

因此,需要根据具体情况来决定是否需要自己显式实现拷贝构造函数。如果类中只有简单类型的成员变量,就可以使用编译器生成的默认拷贝构造函数;如果类中有指针或引用等需要特别注意的成员变量,就需要手动实现一个深拷贝的拷贝构造函数。

这里会发现下面的程序会崩溃掉?这里就需要我们用深拷贝去解决。

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

注意:类中如果没有涉及资源申请时,拷贝构造函数是否写都可以;一旦涉及到资源申请时,则拷贝构造函数是一定要写的,否则就是浅拷贝。

对象拷贝

在C++中,对象拷贝指的是将一个对象的值复制到另一个对象中。常见的对象拷贝方法包括拷贝构造函数赋值运算符

拷贝构造函数是用来创建一个对象,该对象与另一个对象具有相同的值。它通常用于实现深拷贝,并且可以从其他对象中创建一个新对象。拷贝构造函数的语法如下:

class MyClass {
public:
  MyClass(const MyClass& other); // 拷贝构造函数
};

其中 other 是要拷贝的对象的引用。

赋值运算符是用于将一个对象的值复制到另一个对象中的运算符。通常使用 = 符号进行赋值操作。赋值运算符的语法如下:

class MyClass {
public:
  MyClass& operator=(const MyClass& other); // 赋值运算符
};

其中 other 是要拷贝的对象的引用。注意赋值运算符返回值为当前对象的引用,以支持链式赋值操作。

需要注意的是,对象拷贝可能涉及浅拷贝和深拷贝的概念,因此需要根据情况选择适当的拷贝方法。如果类中包含指针或资源管理的成员变量,则需要手动实现深拷贝,以确保正确的对象复制和资源释放。否则,在执行浅拷贝时,两个对象将共享同一块内存,可能会导致悬挂指针、内存泄漏等问题。

在使用对象拷贝时,还需要注意对象的生命周期和内存管理,避免出现悬挂指针、内存泄漏等问题。

浅拷贝:

浅拷贝是指简单地将一个对象的值复制给另一个对象,包括对象中的所有成员变量。这意味着拷贝后的对象和原始对象共享同一块内存,当其中一个对象修改了内存中的值时,另一个对象也会受到影响。这种情况下,如果两个对象的析构函数试图同时释放同一块内存,会导致内存错误。

深拷贝:

深拷贝是指创建一个对象的独立副本,其中包括对象中的所有成员变量。这意味着拷贝后的对象拥有自己的内存空间,对其中一个对象的修改不会影响另一个对象。这种情况下,每个对象的析构函数可以安全地释放自己拥有的内存。

为了实现深拷贝,通常需要手动分配内存并将原始对象中的数据复制到新对象中,例如使用 new 运算符来动态分配内存,并通过拷贝构造函数或赋值运算符将数据复制到新对象中。而浅拷贝则可以使用默认的拷贝构造函数和赋值运算符,由编译器自动生成。

需要特别注意的是,如果类中包含指针或资源管理的成员变量(如动态分配的内存),则需要手动实现深拷贝以确保正确的对象复制和资源释放。否则,在执行浅拷贝时,两个对象将共享同一块内存,可能会导致悬挂指针、内存泄漏等问题。

因此,当类中存在指针或资源管理的成员变量时,通常需要自定义拷贝构造函数和赋值运算符,以实现深拷贝,避免出现潜在的问题。

示例理解:

假如现在你买了(构造)一个房子,开发商给你配了一个钥匙(指针成员变量)

那么,现在你的朋友也行买个和你一样的房子,也声明了另一个房子,然后(拷贝构造) 这时我们发现系统崩溃了,为什么呢?而且我们可以发现运行的出来的地址是一样的,这证明两个人的钥匙配对的是同一套“房子”,所以这是错误的!因为C++不知道你复制一把钥匙的目的是什么,所以就只是单纯的复制了一把钥匙,这就是浅拷贝!

我们要效果是,你的朋友要的是和你有一样的房子,而不是同一个,所以我们自定义一个拷贝构造函数,这时的运行结果显示,两套房子的地址不一样了~这就是深拷贝!

析构函数析构完后意味着“第一队拆迁办”已经把第一套房子拆了,而此时两个钥匙指向的同一套房子,当“第二队拆迁办”来了之后,发现,好家伙,房子已经被拆了,所以程序就报错了!!

技术总结:

C++默认生成的拷贝构造函数,他的行为就是浅拷贝,他只会复制一个一摸一样的指针,并不会操作指针指向的东西。要想实现我们的逻辑需求,就要自定义拷贝构造函数,实现深拷贝。

5. 拷贝构造函数典型调用场景:

  • 使用已存在对象创建新对象
  • 函数参数类型为类类型对象
  • 函数返回值类型为类类型对象
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;
}

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

希望对你有帮助!加油!

若您认为本文内容有益,请不吝赐予赞同并订阅,以便持续接收有价值的信息。衷心感谢您的关注和支持!

目录
相关文章
|
15天前
|
存储 编译器 C语言
【c++丨STL】string类的使用
本文介绍了C++中`string`类的基本概念及其主要接口。`string`类在C++标准库中扮演着重要角色,它提供了比C语言中字符串处理函数更丰富、安全和便捷的功能。文章详细讲解了`string`类的构造函数、赋值运算符、容量管理接口、元素访问及遍历方法、字符串修改操作、字符串运算接口、常量成员和非成员函数等内容。通过实例演示了如何使用这些接口进行字符串的创建、修改、查找和比较等操作,帮助读者更好地理解和掌握`string`类的应用。
26 2
|
21天前
|
存储 编译器 C++
【c++】类和对象(下)(取地址运算符重载、深究构造函数、类型转换、static修饰成员、友元、内部类、匿名对象)
本文介绍了C++中类和对象的高级特性,包括取地址运算符重载、构造函数的初始化列表、类型转换、static修饰成员、友元、内部类及匿名对象等内容。文章详细解释了每个概念的使用方法和注意事项,帮助读者深入了解C++面向对象编程的核心机制。
54 5
|
27天前
|
存储 编译器 C++
【c++】类和对象(中)(构造函数、析构函数、拷贝构造、赋值重载)
本文深入探讨了C++类的默认成员函数,包括构造函数、析构函数、拷贝构造函数和赋值重载。构造函数用于对象的初始化,析构函数用于对象销毁时的资源清理,拷贝构造函数用于对象的拷贝,赋值重载用于已存在对象的赋值。文章详细介绍了每个函数的特点、使用方法及注意事项,并提供了代码示例。这些默认成员函数确保了资源的正确管理和对象状态的维护。
56 4
|
29天前
|
存储 编译器 Linux
【c++】类和对象(上)(类的定义格式、访问限定符、类域、类的实例化、对象的内存大小、this指针)
本文介绍了C++中的类和对象,包括类的概念、定义格式、访问限定符、类域、对象的创建及内存大小、以及this指针。通过示例代码详细解释了类的定义、成员函数和成员变量的作用,以及如何使用访问限定符控制成员的访问权限。此外,还讨论了对象的内存分配规则和this指针的使用场景,帮助读者深入理解面向对象编程的核心概念。
67 4
|
2月前
|
存储 安全 C++
【C++打怪之路Lv8】-- string类
【C++打怪之路Lv8】-- string类
23 1
|
2月前
|
存储 编译器 对象存储
【C++打怪之路Lv5】-- 类和对象(下)
【C++打怪之路Lv5】-- 类和对象(下)
29 4
|
2月前
|
编译器 C语言 C++
【C++打怪之路Lv4】-- 类和对象(中)
【C++打怪之路Lv4】-- 类和对象(中)
25 4
|
2月前
|
存储 编译器 C++
【C++类和对象(下)】——我与C++的不解之缘(五)
【C++类和对象(下)】——我与C++的不解之缘(五)
|
2月前
|
编译器 C++
【C++类和对象(中)】—— 我与C++的不解之缘(四)
【C++类和对象(中)】—— 我与C++的不解之缘(四)
|
2月前
|
存储 编译器 C语言
【C++类和对象(上)】—— 我与C++的不解之缘(三)
【C++类和对象(上)】—— 我与C++的不解之缘(三)