Question

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

原文如下，以下答案。

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

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

看了一下后，似乎我应该使用指针指针，所以我试过这个，但是遇到了“左值作为一元'和'操作数'错误。”

我从：

开始

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

这些初始化给我一个“左值作为一元'＆''操作数'的错误，我不确定是否应该用

替换它

*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-1）更新size（n）数组。然后我想释放大小数组（n-1）的内存，设置'oldarray'指向我刚创建的数组，然后设置'newarray'指向一个新的大小块（n + 1））双打。

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

我已经检查了C dynamically growing array和其他一些堆栈问题，并且已经使用Google搜索指针，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));

是错误的，因为您正在取消引用一个单一化指针。当您使用oldarray声明double** 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*，因此int *foo = malloc(sizeof(*foo))是完全有效的C，但在C ++中不合法。但是，在C ++中你不会使用{ {1}}首先。）

C中两个动态增长阵列的指针复制

1 个答案: