为双指针分配内存？

Question

我无法理解如何分配内存 到双指针。 我想读取一个字符串数组并存储它。

    char **ptr;
    fp = fopen("file.txt","r");
    ptr = (char**)malloc(sizeof(char*)*50);
    for(int i=0; i<20; i++)
    {
       ptr[i] = (char*)malloc(sizeof(char)*50);
       fgets(ptr[i],50,fp);
    }

相反，我只是分配一大块内存，然后 存储字符串

  char **ptr;
  ptr = (char**)malloc(sizeof(char)*50*50);

会出错吗？如果是这样，为什么呢？

Answer 1

您的第二个示例是错误的，因为从概念上讲，每个内存位置都不会保存 char* ，而是保存 char 。如果您稍微改变一下您的想法，它会对此有所帮助：

char *x;  // Memory locations pointed to by x contain 'char'
char **y; // Memory locations pointed to by y contain 'char*'

x = (char*)malloc(sizeof(char) * 100);   // 100 'char'
y = (char**)malloc(sizeof(char*) * 100); // 100 'char*'

// below is incorrect:
y = (char**)malloc(sizeof(char) * 50 * 50);
// 2500 'char' not 50 'char*' pointing to 50 'char'

因此，您的第一个循环将是您在 C 中执行字符数组/指针数组的方式。对字符数组数组使用固定的内存块是可以的，但是您可以使用单个 char* 而不是 char**，因为您不会有任何内存中的指针，只是char。

char *x = calloc(50 * 50, sizeof(char));

for (ii = 0; ii < 50; ++ii) {
    // Note that each string is just an OFFSET into the memory block
    // You must be sensitive to this when using these 'strings'
    char *str = &x[ii * 50];
}

Answer 2

 char **ptr;
    fp = fopen("file.txt","r");
    ptr = (char**)malloc(sizeof(char*)*50);
    for(int i=0; i<50; i++)
    {
       ptr[i] = (char*)malloc(sizeof(char)*50);
       fgets(ptr[i],50,fp);
    }

fclose(fp);

可能是你的拼写错误，但如果你正在寻找 50 x 50 矩阵，你的循环应该是 50 而不是 20。此外，在分配上述内存之后，您可以以 ptr[i][j] 的形式访问缓冲区，即以 2D 格式。

Answer 3

双指针只是指向另一个指针的指针。所以你可以这样分配它：

char *realptr=(char*)malloc(1234);
char **ptr=&realptr;

你必须记住你的指针存储在哪里（在这个例子中，双指针指向堆栈上的指针变量，所以它在函数返回后无效）。

Answer 4

我举一个例子，也许可以消除疑虑，

char **str;                              // here its kind a equivalent to char *argv[]
str = (char **)malloc(sizeof(char *)*2)  // here 2 indicates 2 (char*)
str[0]=(char *)malloc(sizeof(char)*10)   // here 10 indicates 10 (char)
str[1]=(char *)malloc(sizeof(char)*10)   // <same as above>

strcpy(str[0],"abcdefghij");   // 10 length character 
strcpy(str[1],"xyzlmnopqr");   // 10 length character

cout<<str[0]<<endl;    // to print the string in case of c++
cout<<str[1]<<endl;    // to print the string in case of c++

or

printf("%s",str[0]);
printf("%s",str[1]);  

//finally most important thing, dont't forget to free the allocated mem
free(str[0]);
free(str[1]);
free(str);

Answer 5

其他更简单的方法来记住

Case -1 :

step-1 : char *p;

步骤-2：
请像下面这样阅读

char (*p); ==> p 是一个指向 char 的指针，

现在您只需对不带大括号的类型（步骤 2）进行 malloc

，即 p = malloc(sizeof(char) * some_len);

情况-2：

步骤 1：char **p；

步骤-2：

请像下面这样阅读

char* (* p); ==> p 是一个指向 char * 的指针，

现在您只需要对不带大括号的类型进行 malloc （步骤 2）

，即 p = malloc(sizeof(char *) * some_len);

情况-3：

没有人使用这个，只是为了解释

char ***p;

读作

char** (*p); ==> p 是指向 char** 的指针（对于上面的检查情况 2）

p = malloc(sizeof(char**) * some_len);

Answer 6

添加到 Pent 的答案中，正如他正确指出的那样，一旦函数返回，您将无法使用此双指针，因为它将指向堆栈上函数激活记录上的内存位置，该内存位置现在已过时（一旦函数具有返回）。如果你想在函数返回后使用这个双指针，你可以这样做：

char * realptr = (char *) malloc(1234);
char ** ptr = (char **) malloc(sizeof(char *));
*ptr = realptr;
return ptr;

为此，函数的返回类型显然必须是char **。

Answer 7

好吧，这就是我的做法：

#include <stdlib.h>

int main(void)
{
    int i = -1; // just a counter
    int j = 5; // how many strings
    char *s[j];
    while(++i < j)
        s[i] = malloc(sizeof(char*)); // allocating avery string separately
    return (0);
}

这也有效：

char **allocate(int lines)
{
    int i = -1;
    char **s = malloc(sizeof(char *) * lines); // allocating lines
    while (++i < lines)
    {
        s[i] = malloc(sizeof(char*)); // alicating line
        scanf("%s", s[i]);
    }
    return (s);
}

int main(int ac, char *av[])
{
    int lines = 5; // how many lines
    char **s = allocate(lines);
    return (0);
}

Answer 8

双指针，简单来说就是一个指向指针的指针，
在许多情况下，它被用作其他类型的数组。

例如，如果您想创建一个字符串数组，您可以简单地执行以下操作：

char** stringArray = calloc(10, 40);

这将创建一个大小为 10 的数组，每个元素将是长度为 40 的字符串。

因此您可以通过 stringArray[5] 访问它并获取一个字符串在第6位。

这是一种用法，其他用法如上所述，是指向指针的指针，并且可以简单地通过以下方式分配：

char* str = (char*)malloc(40);
char** pointerToPointer = &str //Get the address of the str pointer, valid only in the current closure.

在此处阅读更多内容：
很好的数组教程