Question

在C maily进行书本练习处理动态内存分配。该计划要我做以下

-read a file and open a file from stdin, for example ./program < input.txt > output.txt
-store each line by dynamically creating an array of strings
 *assume and allocate enough space to store 5 lines of type char*
  when this turns out to insufficient double the amount of space to store more/*realloc?*/ 
 *when allocatingspace to store line,allocate only enough memory to store particular line
-print lines to screen in reverse order
-print number of lines to screen
-print total characters to screen
(we can assume each line can be stored in 1000 bytes)

我试图计划我的方法来做到这一点，并希望得到一些输入。我是动态内存分配的新手，请原谅我，如果我是屠夫，但我已经阅读了它。以下将是我的psuedocode方法和问题。假设我们有文件输入行

hello world
store these lines
but only enough memory to store these particular lines
then print out these lines in reverse
make sure to keep track of the line count,and character count
this is a 6th line so double the space of the array to store 10 lines

我的伪代码短划线意味着一般指令，*更详细一些

-read file in from stdin
    begin index count for the string_array
    /*we can assume line will fit into 1000 bytes*/
      buffer[1000]
    /*allocate memory to store 5 adresses of strings*/
      char** string_array = malloc(5 * sizeof(char))
    /*begin reading file*/
      while(fgets(buffer,sizeof(buffer),stdin != NULL))
-store each line in buffer into the array
    /*allocate only enough space to store the particular line,not sure how to do this but..*/
      string_array[index] = malloc(strlen(buffer) * sizeof(char)) /*afraid buffer will be 1000 like intialized?*/
    /*add characters of line to character sum and add the line to linesum*/
      charactersum = charactersum + strlen(buffer)
      linesum = linesum + 1
    /*fill the array index with each line string*/
      strcpy(string_array[index],buffer
    increment index

我不知道的一件事是如何为string_array重新定位空间，因为最终它需要更多空间然后存储5个地址。我在想..

string_array = realloc(string_array, 2*sizeof(string_array)

但我如何检查我的数组是否没有更多的空间来存储字符串地址以便重新分配以及我将它放在哪里？这种方法可行吗？我希望我正确使用malloc和realloc没有匹配错误，因为我遇到了麻烦。印刷，我可以做得很好，但我更关心正确满足动态分配要求和正确构建阵列

Answer 1

关于您的陈述：
打印，我可以做得很好，但我更关心的是正确满足动态分配要求并正确构建阵列

以下是创建，修改和释放内存的一些步骤 char **string_array={0}; //将成为＆＃34;字符串的数组＆＃34;

注意： C实际上没有字符串类型，但是当char数组终止时一个NULL字符，（\ 0），它通常被称为 C字符串。

1）确定字符串的数量，以及每个字符串的最大长度。有关简单说明，请使用：

#define NUM_STRINGS 10
#define MAX_STR_LEN 10

2）为每个字符串创建指针（实际上只是创建了NUM_STRINGS个字符*＆＃39; s）

string_array=malloc(NUM_STRINGS * sizeof(char *));//creates 10 char *

现在你有* string_array [0]到* string_array [9]，每个都有地点在内存中但没有内存空间。（差异很大）

3）为每个char *分配内存 space ，从而创建char数组

for(i=0;i<NUM_STRINGS;i++)
{
    string_array[i]=malloc(MAX_STR_LEN +1);//+1 for null terminator
                                           //note: this could have also been 
                                           //...(MAX_STR_LEN * sizeof(char) +1)
                                           //but because sizeof(char) == 1, it is equivalent
}

4）对于string_array的内存_re_allocation，再次，您可以使用#define：

for(i=0;i<NUM_STRINGS;i++)
{
    string_array[i] = realloc(string_array, 2*MAX_STR_LEN +1);
}

<强> 注意：
realloc也可以应用于增加字符串的数字，这里只有
用于更改每个现有字符串的长度。

5）最后，当使用以这种方式创建的任何变量完成后，它的内存位于堆上而不是堆栈，而且必须是免费的

。

for(i=0;i<NUM_STRINGS;i++)
{
    free(string_array[i]);
}
free(string_array);

在摘要 中，上面讨论的所有内容（realloc除外）都包含在两个中函数创建字符串数组，然后释放它们：

//Create string arrays
char ** allocMemory(char ** a, int numStrings, int maxStrLen)
{
    int i;
    a = calloc(sizeof(char*)*(numStrings), sizeof(char*));
    for(i=0;i<numStrings; i++)
    {
      a[i] = calloc(sizeof(char)*maxStrLen + 1, sizeof(char));
    }
    return a;
}
//free string arrays
void freeMemory(char ** a, int numStrings)
{
    int i;
    for(i=0;i<numStrings; i++)
        if(a[i]) free(a[i]);
    free(a);
}

使用示例 ：

int main(void)
{
    char **str=0;
    //create array pointers and space for desired number of strings:
    str = allocMemory(str, NUM_STRINGS, MAX_STR_LEN);//create space for NUM_STRINGS strings, 
                                                     //each with space for MAX_STR_LEN + 1 characters 
                                                     //(+1 for NULL);  
    //use strings...

    //when done using:
    freeMemory(str, NUM_STRINGS);
    return 0;
}

Answer 2

    /*allocate memory to store 5 adresses of strings*/
      char** string_array = malloc(5 * sizeof(char))

那是错的;因为字符串的地址是char *类型，所以写

        char **string_array = malloc(5 * sizeof(char *));

甚至更好

        char **string_array = malloc(5 * sizeof*string_array);

（在我看来）。

我不知道的一件事是如何为此重新定位空间 string_array因为最终它需要更多空间然后存储 5个地址。我在想..
string_array = realloc(string_array, 2*sizeof(string_array)
但我如何检查我的数组是否没有更多空间来存储字符串地址以便重新分配以及我将它放在哪里？

由于string_array是char **，sizeof(string_array)不会提供所需的数组大小。我们必须以某种方式存储分配的数组大小，比如说

    int numStrings = 5;

并在需要更多空间的情况下使用它（在我们存储线之前）：

    if (index == numStrings)
        numStrings *= 2,
        string_array = realloc(string_array, numStrings * sizeof*string_array);

动态记忆分配实践

2 个答案: