动态数组和功能化malloc

我尝试在功能上malloc一个数组，这个函数还可以检查内存是否足够

第一个代码块无法工作。 当它执行“

*pi=5

”时，编译器会显示此错误消息“

线程1:EXC\u BAD\u访问（code=1，address=0x0）”

 #include <stdio.h>
 #include <stdlib.h>

 void malloc_and_check(int *var)
 {
     if(!(var = (int*)malloc(sizeof(int))))
     {
        fprintf(stderr, "Insufficient Memory\n");
        exit(EXIT_FAILURE);
     } 
 }

 int main(int argc, const char * argv[]) 
 {
    int *pi;
    malloc_and_check(pi);
    *pi = 5;
    printf("%d", *pi);
    free(pi);
 }

#包括
#包括
无效malloc_和_检查（int*var）
{
如果（！（var=（int*）malloc（sizeof（int）））
{
fprintf（stderr，“内存不足”）；
退出（退出失败）；
} 
}
int main（int argc，const char*argv[]
{
int*pi；
malloc_和_检查（pi）；
*pi=5；
printf（“%d”，*pi）；
自由（pi）；
}

但是，以下代码可以正常工作

    #include <stdio.h>
    #include <stdlib.h>

    int main(int argc, const char * argv[])
    {
        int *pi;

        if(!(pi = (int*)malloc(sizeof(int))))
        {
            fprintf(stderr, "Insufficient Memory\n");
            exit(EXIT_FAILURE);
        }

        *pi = 5;
        printf("%d", *pi);
        free(pi);
    }

#包括
#包括
int main（int argc，const char*argv[]
{
int*pi；
如果（！（pi=（int*）malloc（sizeof（int）））
{
fprintf（stderr，“内存不足”）；
退出（退出失败）；
}
*pi=5；
printf（“%d”，*pi）；
自由（pi）；
}

他们之间有什么区别？谢谢
 您正在尝试按值传递指针（按值传递）。您需要将双指针传递给函数
malloc\u和\u check
。因此，分配给指针的值不会在调用者中反射回来

请按以下方式修改您的代码：

 #include <stdio.h>
 #include <stdlib.h>

 void malloc_and_check(int **var)
 {
     if(!(*var = malloc(sizeof(int))))
     {
        fprintf(stderr, "Insufficient Memory\n");
        exit(EXIT_FAILURE);
     } 
 }

 int main(int argc, const char * argv[]) 
 {
    int *pi;
    malloc_and_check(&pi);
    *pi = 5;
    printf("%d", *pi);
    free(pi);
 }

#包括
#包括
无效malloc_和_检查（int**var）
{
如果（！（*var=malloc（sizeof（int）））
{
fprintf（stderr，“内存不足”）；
退出（退出失败）；
} 
}
int main（int argc，const char*argv[]
{
int*pi；
malloc_和_检查（&pi）；
*pi=5；
printf（“%d”，*pi）；
自由（pi）；
}
您正在尝试按值传递指针（按值传递）。您需要将双指针传递给函数
malloc\u和\u check
。因此，分配给指针的值不会在调用者中反射回来

请按以下方式修改您的代码：

 #include <stdio.h>
 #include <stdlib.h>

 void malloc_and_check(int **var)
 {
     if(!(*var = malloc(sizeof(int))))
     {
        fprintf(stderr, "Insufficient Memory\n");
        exit(EXIT_FAILURE);
     } 
 }

 int main(int argc, const char * argv[]) 
 {
    int *pi;
    malloc_and_check(&pi);
    *pi = 5;
    printf("%d", *pi);
    free(pi);
 }

#包括
#包括
无效malloc_和_检查（int**var）
{
如果（！（*var=malloc（sizeof（int）））
{
fprintf（stderr，“内存不足”）；
退出（退出失败）；
} 
}
int main（int argc，const char*argv[]
{
int*pi；
malloc_和_检查（&pi）；
*pi=5；
printf（“%d”，*pi）；
自由（pi）；
}
当函数返回时，您对函数中的
var
所做的更改将丢失。您需要将
var
作为双指针传递，或者需要从函数返回指针

函数返回指针的示例：

 #include <stdio.h>
 #include <stdlib.h>

 int* malloc_and_check()
 {
     int *var;
     if(!(var = malloc(sizeof(int))))
     {
        fprintf(stderr, "Insufficient Memory\n");
        exit(EXIT_FAILURE);
     } 
     return var;
 }

 int main(int argc, const char * argv[]) 
 {
    int *pi;
    pi = malloc_and_check();
    *pi = 5;
    printf("%d", *pi);
    free(pi);
 }

#包括
#包括
int*malloc_和_check（）
{
int*var；
如果（！（var=malloc（sizeof（int）））
{
fprintf（stderr，“内存不足”）；
退出（退出失败）；
} 
收益var；
}
int main（int argc，const char*argv[]
{
int*pi；
pi=malloc_和_check（）；
*pi=5；
printf（“%d”，*pi）；
自由（pi）；
}
当函数返回时，您对函数中的
var
所做的更改将丢失。您需要将
var
作为双指针传递，或者需要从函数返回指针

函数返回指针的示例：

 #include <stdio.h>
 #include <stdlib.h>

 int* malloc_and_check()
 {
     int *var;
     if(!(var = malloc(sizeof(int))))
     {
        fprintf(stderr, "Insufficient Memory\n");
        exit(EXIT_FAILURE);
     } 
     return var;
 }

 int main(int argc, const char * argv[]) 
 {
    int *pi;
    pi = malloc_and_check();
    *pi = 5;
    printf("%d", *pi);
    free(pi);
 }

#包括
#包括
int*malloc_和_check（）
{
int*var；
如果（！（var=malloc（sizeof（int）））
{
fprintf（stderr，“内存不足”）；
退出（退出失败）；
} 
收益var；
}
int main（int argc，const char*argv[]
{
int*pi；
pi=malloc_和_check（）；
*pi=5；
printf（“%d”，*pi）；
自由（pi）；
}
当您将
int*var
传递到
malloc\u和\u check
时，您正在更新指针的本地副本，以使原始指针保持不变。您可以通过两种方式解决此问题：

（a） 从malloc和check返回指针

int * malloc_and_check()
{
    int * var = 0;
    if(!(var = (int*)malloc(sizeof(int))))
    {
        fprintf(stderr, "Insufficient Memory\n");
        return 0;
    } 
    return var;
}  

那你就称它为

pi = malloc_and_check();

（b） 传入指向该指针的指针

void malloc_and_check(int ** var)
{
    if(!( *var = (int*)malloc(sizeof(int))))
    {
        fprintf(stderr, "Insufficient Memory\n");
        exit(EXIT_FAILURE);
    } 
}  

然后你会把它作为

 malloc_and_check(&pi);

当您将
int*var
传递到
malloc\u和\u check
中时，您正在更新指针的本地副本，以便原始指针保持不变。您可以通过两种方式解决此问题：

（a） 从malloc和check返回指针

int * malloc_and_check()
{
    int * var = 0;
    if(!(var = (int*)malloc(sizeof(int))))
    {
        fprintf(stderr, "Insufficient Memory\n");
        return 0;
    } 
    return var;
}  

那你就称它为

pi = malloc_and_check();

（b） 传入指向该指针的指针

void malloc_and_check(int ** var)
{
    if(!( *var = (int*)malloc(sizeof(int))))
    {
        fprintf(stderr, "Insufficient Memory\n");
        exit(EXIT_FAILURE);
    } 
}  

然后你会把它作为

 malloc_and_check(&pi);

指针变量是动态分配的内存，但它是函数malloc_和_check的本地变量。函数main中的指针pi无法知道分配给var的内存地址。这是一种错误的访问，有时也可能导致崩溃

请尝试以下代码以获得预期结果：

#include <stdio.h>
 #include <stdlib.h>

 void malloc_and_check(int **var)
 {
     int *var1;
     if(!(var1 = (int*)malloc(sizeof(int))))
     {
        fprintf(stderr, "Insufficient Memory\n");
        exit(EXIT_FAILURE);
     } 
     else 
        *var = var1;
 }

 int main(int argc, const char * argv[]) 
 {
    int *pi;
    malloc_and_check(&pi);
    *pi = 5;
    printf("%d", *pi);
    free(pi);
 }

#包括
#包括
无效malloc_和_检查（int**var）
{
int*var1；
如果（！（var1=（int*）malloc（sizeof（int）））
{
fprintf（stderr，“内存不足”）；
退出（退出失败）；
} 
其他的
*var=var1；
}
int main（int argc，const char*argv[]
{
int*pi；
malloc_和_检查（&pi）；
*pi=5；
printf（“%d”，*pi）；
自由（pi）；
}
指针变量是动态分配的内存，但它是函数malloc\u和\u check的本地变量。函数main中的指针pi无法知道分配给var的内存地址。这是一种错误的访问，有时也可能导致崩溃

请尝试以下代码以获得预期结果：

#include <stdio.h>
 #include <stdlib.h>

 void malloc_and_check(int **var)
 {
     int *var1;
     if(!(var1 = (int*)malloc(sizeof(int))))
     {
        fprintf(stderr, "Insufficient Memory\n");
        exit(EXIT_FAILURE);
     } 
     else 
        *var = var1;
 }

 int main(int argc, const char * argv[]) 
 {
    int *pi;
    malloc_and_check(&pi);
    *pi = 5;
    printf("%d", *pi);
    free(pi);
 }

#包括
#包括
无效malloc_和_检查（int**var）
{
int*var1；
如果（！（var1=（int*）malloc（sizeof（int）））
{
fprintf（stderr，“内存不足”）；
退出（退出失败）；
} 
其他的
*var=var1；
}
int main（int argc，const char*argv[]
{
int*pi；
malloc_和_检查（&pi）；
*pi=5；
printf（“%d”，*pi）；
自由（pi）；
}
您必须通过
无效malloc\u和\u检查（int**var）
并使用
malloc\u和\u检查（&pi）调用它也不要使用
perror（“malloc”）返回
malloc
Use；退出