C编程：Malloc（）在另一个功能中

Question

我需要有关 malloc() 在另一个函数内的帮助。

我正在将指针和大小从我的main()传递给函数，并且我想使用<动态为该指针分配内存code>malloc() 从被调用的函数内部，但我看到的是......正在分配的内存是用于我的被调用函数内声明的指针，而不是内部的指针main()。

我应该如何将指针传递给函数并从被调用函数内部为传递的指针分配内存？

---

我编写了以下代码，得到的输出如下所示。

来源：

int main()
{
   unsigned char *input_image;
   unsigned int bmp_image_size = 262144;

   if(alloc_pixels(input_image, bmp_image_size)==NULL)
     printf("\nPoint2: Memory allocated: %d bytes",_msize(input_image));
   else
     printf("\nPoint3: Memory not allocated");     
   return 0;
}

signed char alloc_pixels(unsigned char *ptr, unsigned int size)
{
    signed char status = NO_ERROR;
    ptr = NULL;

    ptr = (unsigned char*)malloc(size);

    if(ptr== NULL)
    {
        status = ERROR;
        free(ptr);
        printf("\nERROR: Memory allocation did not complete successfully!");
    }

    printf("\nPoint1: Memory allocated: %d bytes",_msize(ptr));

    return status;
}

程序输出：

Point1: Memory allocated ptr: 262144 bytes
Point2: Memory allocated input_image: 0 bytes

Answer 1

我应该如何将指针传递给
函数并为其分配内存
从被调用内部传递指针
功能？

问问自己：如果您必须编写一个必须返回 int 的函数，您会怎么做？

您可以直接返回它：

int foo(void)
{
    return 42;
}

或者通过添加间接级别通过输出参数返回它（即，使用 int* 而不是 int）：

void foo(int* out)
{
    assert(out != NULL);
    *out = 42;
}

因此，当您返回指针类型 (T*) 时，它是相同的事情：你要么直接返回指针类型：

T* foo(void)
{
    T* p = malloc(...);
    return p;
}

要么添加一个间接级别：

void foo(T** out)
{
    assert(out != NULL);
    *out = malloc(...);
}

Answer 2

您需要将一个指向指针的指针作为参数传递给您的函数。

int main()
{
   unsigned char *input_image;
   unsigned int bmp_image_size = 262144;

   if(alloc_pixels(&input_image, bmp_image_size) == NO_ERROR)
     printf("\nPoint2: Memory allocated: %d bytes",_msize(input_image));
   else
     printf("\nPoint3: Memory not allocated");     
   return 0;
}

signed char alloc_pixels(unsigned char **ptr, unsigned int size) 
{ 
    signed char status = NO_ERROR; 
    *ptr = NULL; 

    *ptr = (unsigned char*)malloc(size); 

    if(*ptr== NULL) 
    {
        status = ERROR; 
        free(*ptr);      /* this line is completely redundant */
        printf("\nERROR: Memory allocation did not complete successfully!"); 
    } 

    printf("\nPoint1: Memory allocated: %d bytes",_msize(*ptr)); 

    return status; 
} 

Answer 3

如果您希望您的功能修改指针本身，则需要将其作为指针指向指针。这是一个简化的例子：

void allocate_memory(char **ptr, size_t size) {
    void *memory = malloc(size);
    if (memory == NULL) {
        // ...error handling (btw, there's no need to call free() on a null pointer. It doesn't do anything.)
    }

    *ptr = (char *)memory;
}

int main() {
   char *data;
   allocate_memory(&data, 16);
}

Answer 4

您需要通过参考而不是通过copy 传递指针，，函数alloc_pixels中的参数需要ampersand＆amp;要退回指针的地址 - 即通过参考在c Speak中通过参考来调用。

main()
{
   unsigned char *input_image;
   unsigned int bmp_image_size = 262144;

   if(alloc_pixels(&input_image, bmp_image_size)==NULL)
     printf("\nPoint2: Memory allocated: %d bytes",_msize(input_image));
   else
     printf("\nPoint3: Memory not allocated");     

}

signed char alloc_pixels(unsigned char **ptr, unsigned int size)
{
    signed char status = NO_ERROR;
    *ptr = NULL;

    *ptr = (unsigned char*)malloc(size);

    if((*ptr) == NULL)
    {
        status = ERROR;
        /* free(ptr);
        printf("\nERROR: Memory allocation did not complete successfully!"); */
    }

    printf("\nPoint1: Memory allocated: %d bytes",_msize(*ptr));

    return status;
}

我已经评论了两行free（ptr）和“错误：...” alloc_pixels函数，这是令人困惑的。如果内存分配失败，则不需要免费指针。

编辑：查看 msdn> msdn 由OP提出的建议，代码示例与我答案的早期相同。...但是...将格式指定符更改为>％u的size_t type ，在printf（...）中在main（）中调用。

main()
{
   unsigned char *input_image;
   unsigned int bmp_image_size = 262144;

   if(alloc_pixels(&input_image, bmp_image_size)==NULL)
     printf("\nPoint2: Memory allocated: %u bytes",_msize(input_image));
   else
     printf("\nPoint3: Memory not allocated");     

}

Answer 5

如其他答案中所述，我们需要指向指针的指针。但为什么？

我们需要通过指针传递该值，以便能够修改值。如果要修改int，则需要通过int*将其传递。

在这个问题中，我们要修改的值是指针int*（指针从null更改为分配内存的地址），因此我们需要传递指针到指针int **。

通过遵循，pint内部foo（int*）是参数的副本。当我们将内存分配给本地变量时，main（）中的一个是完整的。

void foo(int* pInt)
{
   pInt = malloc(...);
}
int main()
{
   int* pInt;
   foo(pInt);
   return 0;
}

因此，我们需要指针指针，

void foo(int** pInt)
{
   *pInt = malloc(...);
}
int main()
{
   int* pInt;
   foo(&pInt);
   return 0;
}

Answer 6

这是没有意义的：

if(alloc_pixels(input_image, bmp_image_size)==NULL) 

alloc_pixels返回一个signed char（ERROR或NO_ERROR），然后将其与< code>NULL （应该用于指针）。

如果您希望更改 input_image，则需要将指向它的指针传递给 alloc_pixels。
alloc_pixels 签名如下：

signed char alloc_pixels(unsigned char **ptr, unsigned int size)

您可以这样调用它：

alloc_pixels(&input_image, bmp_image_size);

内存分配

*ptr = malloc(size);

Answer 7

在您的初始代码中，当您将Input_image传递到函数Alloc_pixels时，编译器正在创建IT（即PTR）的副本并将该值存储在堆栈上。您将Malloc返回的值分配给PTR。一旦函数返回MAIN，并且堆栈放松一下，则该值就会丢失。因此，内存仍在堆上分配，但是内存位置从未存储在（或分配给）input_image中，因此问题。

您可以更改函数Alloc_pixels的签名，该函数更简单地理解，也不需要其他“状态”变量。

unsigned char *alloc_pixels(unsigned int size)
{
    unsigned char *ptr = NULL;
    ptr = (unsigned char *)malloc(size);
    if (ptr != NULL)
       printf("\nPoint1: Memory allocated: %d bytes",_msize(ptr));
    return ptr;
}

您可以在主要以上调用上述函数：

int main()
{
   unsigned char *input_image;
   unsigned int bmp_image_size = 262144;

   if((input_image = alloc_pixels(bmp_image_size))==NULL)
       printf("\nPoint3: Memory not allocated");    
   else
     printf("\nPoint2: Memory allocated: %d bytes",_msize(input_image)); 
   return 0;

}

Answer 8

参数的分配仅在将值设置为地址。

时才能工作。

在尝试解决此问题之前，您应该知道2点：
1。 c函数：传递给该函数的所有参数将是函数中的副本。

这意味着您在函数中完成的每个任务都不会影响功能之外的变量，实际上是在复制上实际上：

int i = 1;
fun(i);
printf("%d\n", i);
//no matter what kind of changes you've made to i in fun, i's value will be 1

因此，如果您想在功能中更改i，则需要知道事物与其副本之间的区别：

副本与事物共享 value ，而不是地址。

那是他们的唯一区别。

因此，更改i在功能中的唯一方法是使用i的地址。

例如，有一个新的函数fun_addr：

void fun_addr(int *i) {
    *i = some_value;
}

这样，您可以更改我的价值。

2. malloc ：

fun_addr函数的关键点是，您已将地址传递给该功能。您可以更改存储在该地址中的值。

Malloc会做什么？

Malloc将分配一个新的内存空间，返回指向该地址后面的指针。

查看此说明：

int *array = (int*) malloc(sizeof(int) * SIZE);

您正在做的是让Array的值等于Malloc返回的地址。

看？这是一个相同的问题，将值永久分配给传递给该函数的参数。此时，该值为地址。

现在，将地址（Malloc返回）分配给地址（存储旧地址）。

因此，代码应该是：

void fun_addr_addr(int **p) {
    *p = (int*) malloc(sizeof(int) * SIZE);
}

该代码将起作用。

Answer 9

我可以将指针指向指针解决方案来解决此功能的类似问题的唯一方法

    BOOL OpenBitmap2 ( LPCTSTR pszFileName, char** pszBMPFile)  

是分配一个临时指针来存储地址

    char* BMPFile;
    { BMPFile = (char*)GlobalAlloc(GPTR, dwFileSize + 1);   // allocate storage using GlobalAlloc + 1 for null term string

，然后将其重新分配给它

    {* pszBMPFile = BMPFile; return (0);} // Error = False

任何评论，以指出为什么直接使用“* pszbmpfile”直接与globalalloc didn'使用“* pszbmpfile” T工作将不胜感激。
我回答了自己的问题。我忘了在其他代码行中使用pszbmpfile携带“*”。所有贡献者的好教训。非常感谢。