我要招人

去企业版

首页 > 试题广场 >

关于“深拷贝”，下列说法正确的是：

[单选题]

关于“深拷贝”，下列说法正确的是：

```
会拷贝动态分配的成员对象
```
```
会拷贝成员数据的值
```
```
会拷贝静态分配的成员对象
```
```
B和C都对
```

推荐

MonsieurWilson

选A。

B和C都算错在了一个地方，没有考虑静态成员。类的静态成员是所有类的实例共有的，存储在全局（静态）区，只此一份，不管继承、实例化还是拷贝都是一份。

B中，静态成员属于成员数据，而C中，静态成员和局部成员都是静态分配的（与动态分配对应），因此B和C中都包含了静态成员，所以不正确。

因此，D也不正确。

编辑于 2016-01-13 12:30:08 回复(0)

hustcoder

深拷贝是指源对象与拷贝对象互相独立，其中任何一个对象的改动都不会对另外一个对象造成影响。

浅拷贝是指源对象与拷贝对象共用一份实体，仅仅是引用的变量不同（名称不同）。对其中任何一个对象的改动都会影响另外一个对象。

发表于 2015-08-11 11:06:20 回复(2)

Rachy

拷贝分为浅拷贝和深拷贝。浅拷贝只是建立原来对象的引用，并不拷贝数据；深拷贝是新建一个对象，把原来对象的数据复制过来。但是有一点要注意，对含有静态成员数据的对象，静态成员属于类，被所有对象共享，所以深拷贝也不会拷贝这一份数据。只会拷贝非静态成员数据。

发表于 2017-03-22 22:34:52 回复(0)

寻#

感觉B答案是不是因为没有区分成员数据，成员数据分为静态成员和非静态成员。深拷贝只是拷贝非静态成员数据。

发表于 2015-08-19 10:12:08 回复(0)

sunshinegogo

静态成员的数据只有一份为大家共享，所以不能深拷贝

发表于 2015-08-11 15:39:05 回复(0)

十里桃林

浅拷贝是指源对象与拷贝对象共用一份实体，仅仅是引用的变量不同（名称不同）。对其中任何一个对象的改动都会影响另外一个对象。　　深拷贝是指源对象与拷贝对象互相独立，其中任何一个对象的改动都不会对另外一个对象造成影响。深拷贝不但对指针进行拷贝，而且对指针指向的内容进行拷贝，经深拷贝后的指针是指向两个不同地址的指针。

发表于 2017-05-18 21:18:27 回复(2)

吼哈哈

浅拷贝时如果构造函数里面有指针，会使新的类对象内的指针也指向旧的那个对象的指针所指向对象，容易出现野指针的现象。

深拷贝好，记得重新分配指针指向的内存。

静态数据在拷贝构造函数时不会被重新分配。

发表于 2016-01-12 20:55:13 回复(0)

风意

记得浅拷贝是只拷贝指针，不拷贝指针所指的值，深拷贝是两者都拷贝

发表于 2015-08-07 21:31:25 回复(2)

陈让然

深拷贝和浅拷贝都是指针或引用类型数据的复制方式。

浅拷贝，又称为地址拷贝，只是复制了指针或引用的地址，多个对象指向同一块内存空间，这样在一个对象中对这个内存空间进行改变时，其余的对象也会受到影响。例如，当我们定义一个类并使用浅拷贝时，如果两个类对象有指针成员，则它们将共享相同的地址，当其中一个对象释放了这段内存，另一个对象中的指针成员将指向已释放的内存，从而导致错误。因此，在包含指针或动态内存分配的类中，使用浅拷贝可能会导致不可预期的结果。

深拷贝，是指将指针或引用所指向的实际内容全部复制一份到新的内存地址中，多个对象之间的指针指向不同的内存地址，每个对象都有自己的一份数据拷贝，互相之间不会影响。例如，在包含指针或动态内存分配的类中，使用深拷贝可以确保每个对象都有自己的一份内存，互相之间不会发生冲突。

发表于 2023-10-19 16:48:40 回复(1)

晓之铭

无论是深拷贝还是浅拷贝，静态成员都只有一份，不会被拷贝，B和C都是没有考虑静态成员的情况

发表于 2021-03-22 09:19:38 回复(0)

~火车头~

考察的太细了

发表于 2017-09-02 20:09:27 回复(0)

allin校招的小辣鸡

深拷贝会复制值，但其核心在于对动态资源（如堆内存）的独立复制

1. 深拷贝的操作包含两部分：

① 复制成员数据的值（浅拷贝也做）：
例如，复制栈上的基本类型（int）、静态数组（int arr[10]），或指针的地址值（如 int* ptr 的地址）。这是所有拷贝构造函数（包括浅拷贝）的基础操作。
② 复制动态分配的资源内容（深拷贝独有）：
对于指针指向的堆内存（如 new int[10]），深拷贝会重新分配内存并复制内容，使源对象和目标对象的动态资源独立（浅拷贝仅复制指针地址，共享资源）。

2. 与浅拷贝的对比：

操作	浅拷贝	深拷贝
栈数据复制(int stackData)	✅ 复制值（如 stackData）	✅ 复制值（如 stackData）
指针地址处理(int* heapData)	✅ 复制地址（共享堆内存）	✅ 复制地址值，但指向新堆内存
动态资源内容复制(string str)	❌ 不复制（仅共享）	✅ 重新分配并复制内容

class MyClass {
private:
    int stackData;       // 栈数据（静态分配）
    int* heapData;       // 堆数据指针（动态分配）指针变量本身在栈上，指向的内存在堆上
    std::string str;     // 标准库类（内部管理动态资源）

public:
    // 构造函数
    MyClass(int stack, int size) : stackData(stack), heapData(new int[size]) {
        for (int i = 0; i < size; ++i) {
            heapData[i] = i;
        }
    }

    // 析构函数
    ~MyClass() {
        delete[] heapData;
    }

    // 浅拷贝构造函数（编译器默认生成的行为）
    MyClass(const MyClass& other) 
        : stackData(other.stackData), heapData(other.heapData), str(other.str) {}

    // 深拷贝构造函数
    MyClass(const MyClass& other) 
        : stackData(other.stackData), str(other.str) {
        // 重新分配堆内存并复制内容
        heapData = new int[10];
        for (int i = 0; i < 10; ++i) {
            heapData[i] = other.heapData[i];
        }
    }
};

int main(){
    MyClass a(10, 10);       // a.stackData=10, a.heapData指向堆内存
    MyClass b = a;           // 执行浅拷贝（调用默认拷贝构造函数）
}

发表于 2025-06-01 16:20:09 回复(0)