C中两个动态增长数组的指针复制

Question

更新：我想我已经回答了我自己的问题，除了一些可能的内存泄漏问题。

这里是原始问题，下面是答案。

背景：我正在做一些数值计算，但我几乎从不使用需要我自己管理内存的语言。我现在正在向 C 输出一些东西，并且遇到了（我认为）指针引用问题。

我有两个在 while 循环中增长的双精度数组，在每次迭代中，我想为更小、更旧的数组释放内存，将“旧”设置为指向较新的数组，然后设置 ' new' 指向更大的内存块。

看了一圈之后，似乎我应该使用指向指针的指针，所以我尝试了这个，但遇到了“需要左值作为一元‘&’操作数”错误。

我开始：

double ** oldarray;
oldarray = &malloc(1*sizeof(double));
double ** newarray;
newarray = &malloc(2*sizeof(double));

这些初始化给了我一个“lvalue required as unary ‘&’operand”错误，我不确定是否应该用

替换它

*oldarray = (double *) malloc(1*sizeof(double));

当我这样做时，我可以编译一个简单的程序（它只有上面的行并返回 0）但我得到了一个 seg 错误。

程序的其余部分如下：

while ( <some condition> ) {

// Do a lot of processing, most of which is updating
// the values in newarray using old array and other newarray values. 

// Now I'm exiting the loop, and growing and reset ing arrays.
free(*oldarray)        // I want to free the memory used by the smaller, older array.
*oldarray = *newarray  // Then I want oldarray to point to the larger, newer array.
newarray = &malloc( <previous size + 1>*sizeof(double))
}

因此，我希望在每次迭代时，使用自身更新一个大小为 (n) 的数组和一个大小为 (n-1) 的旧数组。然后我想释放大小为（n-1）的数组的内存，设置'oldarray'指向我刚刚创建的数组，然后设置'newarray'指向一个新的大小块（n+1 ) 双打。

我真的需要使用指向指针的指针吗？我认为我的主要问题是，当我将 old 设置为 new 时，他们共享一个指针，然后我不知道如何将 new 设置为新数组。我认为使用指向指针的指针可以让我摆脱这种情况，但是，我不确定，我仍然有指向指针的左值错误。

我已经检查了C dynamically growing array 和其他一些堆栈问题，并且已经用谷歌搜索指针、malloc 和复制了大约半天。

谢谢！

这是我自己的答案

我现在有了一个可行的解决方案。我唯一担心的是它可能包含一些内存泄漏。

使用 realloc() 有效，我还需要小心确保我只释放使用 malloc 或 realloc 初始化的指针，而不是使用 double * oldarray; 初始化的指针。

工作版本是这样的：

double * olddiagonal = (double *) malloc(sizeof(double));
olddiagonal[0] = otherfunction(otherstuff);
int iter = 1;

// A bunch of other stuff
while (<error tolerance condition>) {

  double * new diagonal = (double *) malloc((iter+1)*sizeof(double));
  newdiagonal[0] = otherfunction(moreotherstuff);

  // Then I do a bunch of things and fill in the values of new diagonal using
  // its other values and the values in olddiagonal.

  // To finish, I free the old stuff, and use realloc to point old to new.    
  free(olddiagonal);
  olddiagonal = (double *) realloc(newdiagonal, sizeof(double) * (iter+1));

  iter++
}

这似乎适用于我的目的。我唯一担心的是可能的内存泄漏，但就目前而言，它表现良好并获得了正确的值。

Answer 1

这里有一些解释：

---

double ** oldarray;
oldarray = &malloc(1*sizeof(double));

是错误的，因为您没有将malloc() 的结果存储在任何地方，并且由于它没有存储在任何地方，因此您无法获取其地址。您可以通过添加一个中间变量来获得您似乎已经想到的效果：

double* intermediatePointer;
double** oldarray = &intermediatePointer;
intermediatePointer = malloc(1*sizeof(*intermediatePointer);

oldarray现在是指向intermediatePointer的内存位置的指针，依次指向分配的内存slap。

---

*oldarray = (double *) malloc(1*sizeof(double));

是错误的，因为您正在取消引用一个未初始化的指针。当您使用double** oldarray; 声明oldarray 时，您只是为一个指针保留内存，而不是为指针应该指向的任何内容（内存保留与指针指向的内容无关！）。您在该指针变量中找到的值是未定义的，因此当您将某些内容分配给 *oldarray 时，您完全无法控制要写入的内存地址。

每当你声明一个指针时，你必须在取消引用它之前初始化指针：

int* foo;
*foo = 7;    //This is always a bug.

int bar;
int* baz = &bar;   //Make sure the pointer points to something sensible.
*baz = 7;    //OK.

---

您的答案代码确实正确。但是，在风格方面可以改进：

组合

int iter = 1;
while (<error tolerance condition>) {
    ...
    iter++
}

调用for()循环的使用，将循环变量的定义和递增封装到循环控制语句中：

for(int iter = 1; <error tolerance condition>; iter++) {
    ...
}

---

在 C 中，malloc() 的返回值的强制转换完全是多余的，它只会使您的代码变得混乱。 （但是请注意，C++ 不允许像 C 那样隐式转换 void*s，因此 int *foo = malloc(sizeof(*foo)) 是完全有效的 C，但在 C++ 中不合法。但是，在 C++ 中，您不会在第一名。）