深拷贝写法

深拷贝是指在进行复制时，不仅复制对象本身，还要复制对象内部所有的引用类型数据（如数组、对象等）所引用的对象，使得复制后的对象与原对象完全独立，互不影响。

以下是一种常见的 JavaScript 深拷贝写法：

function deepClone(obj) {
  if (obj === null || typeof obj !== 'object') {
    return obj;
  }
  
  let clone = Array.isArray(obj) ? [] : {};
  for (let key in obj) {
    clone[key] = deepClone(obj[key]);
  }
  
  return clone;
}

该函数接收一个对象作为参数，如果该对象为 null 或者不是一个对象类型，直接返回该对象。如果是一个数组，新建一个数组，否则新建一个对象。然后遍历原对象中的属性，对每个属性进行递归调用，直到属性不再是一个对象类型，将其赋值给新对象对应的属性。最后返回新对象即可。

需要注意的是，该函数在处理对象时，只会拷贝可枚举的属性，不会拷贝对象的原型链上的属性和方法。如果需要拷贝原型链上的属性和方法，可以通过 Object.create() 方法创建一个新对象，并将原对象作为其原型，然后将新对象作为拷贝对象。

相关问题

js 浅拷贝 json写法

在 JavaScript 中，浅拷贝 JSON 数据通常是指创建一个新的对象或数组，其中包含原 JSON 对象的所有属性和值，但这些属性并不是原始引用，而是新的副本。对于简单的 JSON 结构（如对象），你可以直接赋值创建浅拷贝。例如：

let originalJson = {
  name: 'John',
  age: 30,
  hobbies: ['reading', 'gaming']
};

// 浅拷贝
let shallowCopyJson = JSON.parse(JSON.stringify(originalJson));

console.log(shallowCopyJson); // 输出：{name: 'John', age: 30, hobbies: ['reading', 'gaming']}

这里我们使用 `JSON.stringify()` 将 JSON 字符串化，然后再用 `JSON.parse()` 反序列化成新对象，实现了浅复制。

然而，当原 JSON 包含复杂数据类型（如日期、正则表达式等）时，或者嵌套对象/数组，浅拷贝只是表面层次的数据复制，深层数据仍然是引用。如果要完全克隆并隔离所有子项，你需要递归处理。

如果你需要对整个 JSON 进行深度拷贝，可以考虑使用第三方库如 Lodash 的 `_.cloneDeep` 方法，或者自定义一个递归函数：

function deepClone(obj) {
  return JSON.parse(JSON.stringify(obj));
}

let deepCopyJson = deepClone(originalJson);

用c++实现：设计包含成员指针变量的类，设计该类的构造函数，拷贝构造函数，析构函数。 写一个包含这个类的参数的函数。 主函数声明该类的对象，并调用自己写的函数。 注意深拷贝和浅拷贝 2写出相应的C语言写法

在 C++ 中，你可以创建一个名为 `ReferencedObject` 的类，它包含一个指向成员的指针。下面是一个简单的实现，包括构造函数、拷贝构造函数、析构函数以及包含此类的函数：

#include <iostream>

class ReferencedObject {
private:
    // 定义一个虚指针成员变量
    int* pointer;

public:
    // 构造函数，接受一个整数并初始化指针
    ReferencedObject(int value) : pointer(new int(value)) {}

    // 拷贝构造函数，通过深拷贝实现，即复制实际数据而不是地址
    ReferencedObject(const ReferencedObject& other) : pointer(new int(*other.pointer)) {}

    // 自动执行，释放内存
    ~ReferencedObject() { delete pointer; }

    // 参数函数，显示当前引用的值
    void display() const {
        std::cout << "Value pointed by the object: " << *pointer << "\n";
    }
};

// C语言风格的函数，接收并操作ReferencedObject指针
void c_style_function(ReferencedObject* obj) {
    obj->display();
}

int main() {
    // 创建一个ReferencedObject实例
    ReferencedObject obj1(5);

    // 使用拷贝构造函数创建第二个对象，这里是深拷贝
    ReferencedObject obj2(obj1);

    // 在main函数内部调用参数函数
    c_style_function(&obj1);
    c_style_function(&obj2);

    return 0;
}

对应的 C 语言实现可能会比较复杂，因为 C 语言没有内置的类和指针自动管理机制。你需要手动分配和释放内存。以下是简化的 C 语言版本：

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

typedef struct {
    int* pointer;
} ReferenceObject;

ReferenceObject* reference_object_create(int value) {
    ReferenceObject* obj = malloc(sizeof(ReferenceObject));
    obj->pointer = malloc(sizeof(int));
    *obj->pointer = value;
    return obj;
}

void reference_object_destroy(ReferenceObject* obj) {
    free(obj->pointer);
    free(obj);
}

void display_value(ReferenceObject* obj) {
    printf("Value pointed by the object: %d\n", *obj->pointer);
}

void c_style_c_function(ReferenceObject* obj) {
    display_value(obj);
}

int main() {
    ReferenceObject obj1 = reference_object_create(5);

    ReferenceObject obj2 = *reference_object_create(obj1);  // 这里假设C能做类似深拷贝的操作

    c_style_c_function(&obj1);
    c_style_c_function(&obj2);

    // 一定要记得在main结束前销毁所有对象
    reference_object_destroy(&obj1);
    reference_object_destroy(&obj2);

    return 0;
}

请注意，C 语言中并没有明确的深拷贝概念，这里提到的“深拷贝”更像是手动复制了整个对象的内容。