在C中复制指针（矩阵）值的指针

Question

问题如下： 我创建了一个动态矩阵，使用指向指针5504

的指针

我想将此矩阵的副本创建为另一个，matrix1

我想这样做，所以我可以惹恼matrix2而不会弄乱matrix2 所以我尝试做以下事情：

matrix1

但是程序会中断并显示以下内容：

我理解，按照它看起来的方式，对于int main() { int **matrix1, **matrix2, size1 = 10, size2 = 2; matrix1 = create_matrix(size1, size2); //I want to copy the value of matrix1 into matrixq2 and NOT the index **matrix2 = **matrix1 } 和create_matrix使用函数matrix1两次会更容易。但是在我的原始程序的方式是太多的工作，因为我做了很多东西来完成矩阵。 哦，顺便说一下，我想避免使用C ++，有没有办法不使用它？对我来说会更好。

代码'create_matrix'如下：

matrix2

Answer 1

这是怎么回事 -

matrix2 = (int**)malloc(sizeof(int*)*size1);
for(int idx = 0; idx < size1; ++idx) {
    matrix2[idx] = (int*)malloc(sizeof(int)*size2);
    for(int idx2 = 0; idx2 < size2; ++idx2) {
        matrix2[idx][idx2] = matrix1[idx][idx2];
    }
}

Answer 2

matrix1指向行指针数组，*matrix1是指向保存第一行实际数据的数组的指针，**matrix1是第一行的第一行元素的值行。 matrix1及其每个元素都是动态分配的数组。

matrix2是您显示的代码中未初始化的（垃圾）指针。它既没有分配行指针也没有分配数据缓冲区。

要获得所需的结果，您需要先分配matrix2的元素，然后只复制matrix1的数据部分。

int **copy_matrix(int **mat, int size1, int size1)
{
    int row;

    int **res = malloc(size1 * sizeof(int *));
    for(row = 0; row < size1; row++) {
        res[row] = malloc(size2 * sizeof(int));
        memcpy(res[row], mat[row], size2 * sizeof(int));
    }
    return res;
}

...

matrix2 = copy_matrix(matrix1, size1, size2);

另一种方法是为副本分配一个缓冲区。虽然这可能是一般存储矩阵的更好方法，但它可能对您没那么有用，因为您将无法像matrix2那样释放matrix1的内存：

int **copy_matrix(int **mat, int size1, int size2)
{
    int row;
    int **res = malloc(size1 * sizeof(int *));
    res[0] = malloc(size1 * size2 * sizeof(int));

    for(row = 0; row < size1; row++) {
        res[row] = res[0] + row * size2;
        memcpy(res[row], mat[row], size2 * sizeof(int));
    }
    return res;
}

Answer 3

您需要了解复制指针，获取浅拷贝和获取深拷贝之间的区别。 考虑一下这个

struct employee
{
   char *name;
   float salary;
   int payrollid;
}

现在有三种复制员工的方法

struct employee * emp1;  // points to an employee, set up somehow
struct employee * emp2;  // empty pointer, null or whatever

emp2 = emp1;  // copy pointers. emp1 and emp2 now point to the same object.

指针复制

struct employee  employee1;  // employee, set up
struct employee  employee2;  // uninitalised emplyee

memcpy(&employee2, &employee1, sizeof(struct employee)); // shallow copy

浅拷贝

struct employee * emp1;  // points to an employee, set up somehow
struct employee * emp2;  // empty pointer, null or whatever

emp2 = copyemployee(emp1);

struct employee *copyemployee(struct employee *e)
{
   struct employee *answer = malloc(sizeof(struct employee));
   if(!answer)
     goto error_exit;
   answer->name = malloc(strlen(e->name) + 1);
   if(!answer->name)
      goto error_exit;
   strcpy(answer>name, e->name);
   answer->salary = e->salary;
   answer->payroolid = e->payrollid;
   return answer;
error_exit:
   /* out of memory handle somehow, usually by returning null
}

深层复制

正如您所看到的，即使对于只有一个可变长度字段的简单结构，采用深度复制也是相当多的工作。 所有这些都有它们的用途，虽然浅拷贝可能是最不实用的，并且最容易出错。

您可能只需要指定一个指针。