C编程：另一个函数内的malloc（）

我需要malloc() 其他功能的帮助。

我正在从我的函数传递一个指针和一个大小给函数main()，我想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

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

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; 
} 

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

问问自己：是否必须编写必须返回一个 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(...);
}

如果要让函数修改指针本身，则需要将其作为指针传递给指针。这是一个简化的示例：

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);
}

您需要通过引用传递指针，而不是通过复制传递指针，该函数中的参数alloc_pixels要求＆符传回指针的地址-在C语言中通过引用调用。

主要（）
{
   无符号字符* input_image;
   无符号整数bmp_image_size = 262144;

   if（alloc_pixels（＆input_image，bmp_image_size）== NULL）
     printf（“ \ nPoint2：分配的内存：％d个字节”，_msize（input_image））;
   其他
     printf（“ \ nPoint3：未分配内存”）;     

}

有符号字符alloc_pixels（无符号字符** ptr，无符号整数大小）
{
    签名字符状态= NO_ERROR;
    * ptr = NULL;

    * ptr =（无符号字符*）malloc（size）;

    如果（（* ptr）== NULL）
    {
        状态=错误；
        / *免费（ptr）;
        printf（“ \ nERROR：内存分配未成功完成！”）; * /
    }

    printf（“ \ nPoint1：分配的内存：％d个字节”，_msize（* ptr））;

    返回状态；
}

我已经free(ptr)在alloc_pixels函数中注释了两行和“ ERROR：...”，因为这很令人困惑。free如果内存分配失败，则不需要指针。

编辑：在查看了OP提供的msdn链接后，提出了一个建议，该代码示例与我的答案中的早期示例相同....但是...在中的调用中，将格式说明符更改%u为该size_t类型。printf(...)main()

主要（）
{
   无符号字符* input_image;
   无符号整数bmp_image_size = 262144;

   if（alloc_pixels（＆input_image，bmp_image_size）== NULL）
     printf（“ \ nPoint2：分配的内存：％u个字节”，_msize（input_image））;
   其他
     printf（“ \ nPoint3：未分配内存”）;     

}

这根本不符合逻辑 ：

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

alloc_pixels返回一个signed char（ERROR或NO_ERROR），然后将其与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);

在您的初始代码中，当您将input_image传递给alloc_pixels函数时，编译器正在创建它的副本（即ptr）并将值存储在堆栈中。您将malloc返回的值分配给ptr。一旦函数返回main并且堆栈展开，该值将丢失。因此，内存仍然分配在堆上，但是内存位置从未存储在（或分配给）input_image中，因此出现了问题。

您可以更改函数alloc_pixels的签名，该签名更易于理解，并且也不需要其他“ status”变量。

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;
}

您可以在main中调用上述函数：

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;

}

仅当将值设置为其参数address时，参数的分配才有效。

在尝试解决此问题之前，应了解两点：
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，则需要了解事物及其副本之间的区别：

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

那是他们唯一的区别。

因此，在函数中更改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);

您正在做的是让数组的值等于malloc返回的地址。

看到？这是相同的问题，将值永久分配给传递给函数的参数。此时，值为address。

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

因此，代码应为：

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

这将工作。

我可以得到指向解决该问题的指针解决方案的唯一方法

    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

对于为什么直接与GlobalAlloc一起使用“ * pszBMPFile”不起作用的任何评论将不胜感激。我回答了我自己的问题。我忘了在其他代码行中通过pszBMPFile携带“ *”。所有贡献者的精彩教训。非常感谢。

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

我们需要通过指针传递值，以便能够修改值。如果要修改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;
}