写一段深拷贝数组的代码

以下是深拷贝数组的代码：

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

int* deepCopy(int* arr, int size) {
    int* copy = (int*) malloc(size * sizeof(int));
    memcpy(copy, arr, size * sizeof(int));
    return copy;
}

int main() {
    int arr[] = {1, 2, 3, 4, 5};
    int size = sizeof(arr) / sizeof(int);
    int* copy = deepCopy(arr, size);
    for (int i = 0; i < size; i++) {
        printf("%d ", copy[i]);
    }
    free(copy);
    return 0;
}

以上代码使用了 `memcpy` 函数来实现深拷贝，可以复制整个数组到新的内存空间中，避免了浅拷贝可能带来的问题。

相关问题

js的数组深拷贝代码

以下是 JavaScript 中实现数组深拷贝的一种方式：

function deepCopyArray(arr) {
  // 首先判断传入的参数是否为数组
  if (!Array.isArray(arr)) {
    throw new Error("传入的参数不是一个数组");
  }
  
  // 创建一个空数组用于存储拷贝后的元素
  let copiedArray = [];  
  // 遍历原数组
  for (let i = 0; i < arr.length; i++) {
    // 如果当前元素是一个数组，则递归调用 deepCopyArray 函数进行深拷贝
    if (Array.isArray(arr[i])) {
      copiedArray[i] = deepCopyArray(arr[i]);
    } else {
      // 如果当前元素不是数组，则直接赋值给新数组
      copiedArray[i] = arr[i];
    }
  }
  
  return copiedArray;
}

// 示例用法
const originalArray = [1, 2, [3, 4]];
const copiedArray = deepCopyArray(originalArray);

console.log(originalArray); // [1, 2, [3, 4]]
console.log(copiedArray);   // [1, 2, [3, 4]]

这段代码定义了一个名为`deepCopyArray`的函数，它接受一个数组作为参数，并返回该数组的深拷贝结果。在函数内部，我们首先判断传入的参数是否为数组，然后创建一个空数组`copiedArray`用于存储拷贝后的元素。接着，我们遍历原数组，并判断每个元素的类型。如果当前元素是一个数组，我们递归调用`deepCopyArray`函数进行深拷贝，否则直接将元素赋值给新数组。最后，返回深拷贝后的数组。

用一维数组的深拷贝实现二维数组深拷贝，使用c++

下面是一段C语言代码，使用一维数组的深拷贝实现了二维数组的深拷贝：

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

int main() {
  int rows = 3;
  int cols = 4;
  int** arr2d = (int**)malloc(rows * sizeof(int*));
  for (int i = 0; i < rows; i++) {
    arr2d[i] = (int*)malloc(cols * sizeof(int));
    for (int j = 0; j < cols; j++) {
      arr2d[i][j] = i * cols + j;
    }
  }

  int* arr1d = (int*)malloc(rows * cols * sizeof(int));
  for (int i = 0; i < rows; i++) {
    for (int j = 0; j < cols; j++) {
      arr1d[i * cols + j] = arr2d[i][j];
    }
  }

  int** arr2d_copy = (int**)malloc(rows * sizeof(int*));
  for (int i = 0; i < rows; i++) {
    arr2d_copy[i] = (int*)malloc(cols * sizeof(int));
    for (int j = 0; j < cols; j++) {
      arr2d_copy[i][j] = arr1d[i * cols + j];
    }
  }

  printf("original 2d array:\n");
  for (int i = 0; i < rows; i++) {
    for (int j = 0; j < cols; j++) {
      printf("%d ", arr2d[i][j]);
    }
    printf("\n");
  }

  printf("copied 2d array:\n");
  for (int i = 0; i < rows; i++) {
    for (int j = 0; j < cols; j++) {
      printf("%d ", arr2d_copy[i][j]);
    }
    printf("\n");
  }

  // free memory
  for (int i = 0; i < rows; i++) {
    free(arr2d[i]);
    free(arr2d_copy[i]);
  }
  free(arr2d);
  free(arr2d_copy);
  free(arr1d);

  return 0;
}

这段代码首先创建一个二维数组`arr2d`，然后使用嵌套的for循环对其进行初始化。接下来，创建一个一维数组`arr1d`，使用另一个嵌套的for循环将`arr2d`的元素复制到`arr1d`中。最后，再创建一个二维数组`arr2d_copy`，并使用嵌套的for循环将`arr1d`的元素复制到其中。这样就完成了二维数组的深拷贝。

需要注意的是，这里使用了动态内存分配函数`malloc`来分配数组的内存空间，在使用完毕后需要使用`free`函数释放这些内存空间，以免出现内存泄漏的问题。