c/c++ 深拷贝和浅拷贝

news2024/11/23 23:57:05

深拷贝与浅拷贝

深拷贝（Deep Copy）和浅拷贝（Shallow Copy）是对象复制的两种不同方式，它们涉及到对象成员数据的复制方式和内存管理。

浅拷贝（Shallow Copy）：
浅拷贝是指将一个对象的成员值简单地复制到另一个对象，包括指针类型的成员变量。浅拷贝只复制指针的值，而不会为指针指向的数据分配新的内存空间。这意味着原始对象和副本对象将共享同一份数据。如果其中一个对象修改了共享的数据，将影响到其他对象。
深拷贝（Deep Copy）：
深拷贝是指复制对象的每个成员，包括指针类型的成员变量。深拷贝会为每个指针类型的成员变量分配独立的内存空间，并将原始对象指针指向的数据复制到新分配的内存中。这样，原始对象和副本对象拥有各自独立的数据副本，对其中一个对象的修改不会影响到其他对象。
深拷贝和浅拷贝的选择取决于对象的成员数据类型和应用场景。对于简单的数据类型或者不涉及动态内存分配的对象，浅拷贝可能足够满足需求。但对于包含指针类型成员或动态分配内存的对象，通常需要使用深拷贝来确保对象之间的独立性。
在C++中，可以通过自定义拷贝构造函数、赋值运算符重载或使用智能指针等方式来实现深拷贝。C语言中需要手动进行内存分配和复制操作，通过手动分配内存、复制数据并管理内存释放来实现深拷贝。

c语言深拷贝和浅拷贝

在C 语言中，没有像 C++ 中那样提供内置的深拷贝和浅拷贝的机制。在 C 语言中，需要手动编写代码来实现深拷贝和浅拷贝。

浅拷贝（Shallow Copy）：
在 C 语言中，浅拷贝可以通过简单地将一个结构体或数组的成员值赋值给另一个结构体或数组来实现。这将导致两个对象共享相同的内存数据，包括指针类型的成员变量。如果其中一个对象修改了共享的数据，将影响到其他对象。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct {
    char* name;
    int age;
} Person;

int main() {
    Person person1;
    person1.name = malloc(sizeof(char) * 10);
    strcpy(person1.name, "John");
    person1.age = 25;

    Person person2 = person1;  // 浅拷贝

    // 修改 person2 的值
    person2.name = malloc(sizeof(char) * 10);
    strcpy(person2.name, "Alice");
    person2.age = 30;

    // 输出 person1 和 person2 的值
    printf("person1: name=%s, age=%d\n", person1.name, person1.age);
    printf("person2: name=%s, age=%d\n", person2.name, person2.age);

    // 释放内存
    free(person1.name);
    free(person2.name);

    return 0;
}

在上述示例中，通过将 person1 的成员值赋值给 person2，实现了浅拷贝。由于两个对象共享相同的内存数据，对其中一个对象的修改会影响另一个对象。

深拷贝（Deep Copy）：
在 C 语言中，深拷贝需要手动进行内存分配和数据复制。对于包含指针类型成员变量的结构体或数组，需要为每个指针类型的成员变量分配独立的内存空间，并将原始对象指针指向的数据复制到新分配的内存中。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct {
    char* name;
    int age;
} Person;

// 深拷贝的函数
void deepCopyPerson(Person* dest, const Person* src) {
    dest->name = malloc(sizeof(char) * (strlen(src->name) + 1));
    strcpy(dest->name, src->name);
    dest->age = src->age;
}

int main() {
    Person person1;
    person1.name = malloc(sizeof(char) * 10);
    strcpy(person1.name, "John");
    person1.age = 25;

    Person person2;
    deepCopyPerson(&person2, &person1);  // 深拷贝

    // 修改 person2 的值
    free(person2.name);
    person2.name = malloc(sizeof(char) * 10);
    strcpy(person2.name, "Alice");
    person2.age = 30;

    // 输出 person1 和 person2 的值
    printf("person1: name=%s, age=%d\n", person1.name, person1.age);
    printf("person2: name=%s, age=%d\n", person2.name, person2.age);

    // 释放内存
    free(person1.name);
    free(person2.name);

    return 0;
}

在上述示例中，通过自定义的函数 deepCopyPerson，实现了深拷贝。该函数手动为 person2 的成员变量分配独立的内存，并将原始对象的数据复制到新分配的内存中。这样，原始对象和副本对象拥有各自独立的数据副本。在使用完后，还需要手动释放内存。

c++深拷贝和浅拷贝

在 C++ 中，可以通过拷贝构造函数和赋值运算符来实现深拷贝和浅拷贝。

浅拷贝（Shallow Copy）：
（1）默认情况下，C++ 提供的拷贝构造函数和赋值运算符执行的是浅拷贝操作，即简单地复制成员变量的值。
（2）对于指针类型的成员变量，直接复制指针的值，这样两个对象将共享相同的内存数据。

class ShallowCopy {
public:
    ShallowCopy(int* data, int size) {
        this->data = data;
        this->size = size;
    }

    // 默认拷贝构造函数执行浅拷贝
    ShallowCopy(const ShallowCopy& other) {
        data = other.data;  // 复制指针的值
        size = other.size;
    }

    // 默认赋值运算符执行浅拷贝
    ShallowCopy& operator=(const ShallowCopy& other) {
        if (this != &other) {
            data = other.data;  // 复制指针的值
            size = other.size;
        }
        return *this;
    }

private:
    int* data;
    int size;
};

在上述示例中，ShallowCopy 类具有一个指针类型的成员变量 data 和一个整数 size。默认的拷贝构造函数和赋值运算符执行浅拷贝，直接复制指针的值，这样两个对象将共享相同的数据。

深拷贝（Deep Copy）：
（1）在自定义拷贝构造函数和赋值运算符时，先为新对象分配独立的内存空间。
（2）将原始对象的数据复制到新的内存空间中，确保每个对象拥有独立的数据副本。

class DeepCopy {
public:
    DeepCopy(int* data, int size) {
        this->data = new int[size];
        for (int i = 0; i < size; ++i) {
            this->data[i] = data[i];
        }
        this->size = size;
    }

    // 自定义拷贝构造函数执行深拷贝
    DeepCopy(const DeepCopy& other) {
        data = new int[other.size];
        for (int i = 0; i < other.size; ++i) {
            data[i] = other.data[i];
        }
        size = other.size;
    }

    // 自定义赋值运算符执行深拷贝
    DeepCopy& operator=(const DeepCopy& other) {
        if (this != &other) {
            delete[] data;
            data = new int[other.size];
            for (int i = 0; i < other.size; ++i) {
                data[i] = other.data[i];
            }
            size = other.size;
        }
        return *this;
    }

    ~DeepCopy() {
        delete[] data;
    }

private:
    int* data;
    int size;
};