C语言进阶⑰(动态内存管理)四个动态内存函数+动态通讯录+柔性数组_malloc+free（中）

 
#include <stdlib.h>
#include <stdio.h>
int main()
{
    int* p = (int*)malloc(9999999999);//开辟失败，返回空指针
    int i = 0;
    for (i = 0; i < 10; i++) 
    {
        *(p + i) = i; // 对空指针进行解引用操作，非法访问内存
    }
    return 0;
}
//解决方案：对 malloc 函数的返回值做判空处理
#include <stdlib.h>
#include <stdio.h>
int main()
{
    int* p = (int*)malloc(9999999999);
    // 对malloc函数的返回值做判空处理
    if (p == NULL) 
    {
        perror("main")
        return 1;
    }
    int i = 0;
    for (i = 0; i < 10; i++) 
    {
        *(p + i) = i;
    }
    return 0;
}

 
#include <stdio.h>
#include <stdlib.h>
int main()
{
    int* p = (int*)malloc(10 * sizeof(int)); // 申请10个整型的空间
    if (p == NULL) 
    {
        perror("main");
        return 1;
    }
    int i = 0;
    // 越界访问 - 指针p只管理10个整型的空间，根本无法访问40个
    for (i = 0; i < 40; i++)
    {
        *(p + i) = i;
    }
    free(p);
    p = NULL;
    return 0;
}

 
#include <stdio.h>
#include <stdlib.h>
int main()
{
    int arr[10] = { 0 }; // 在栈区上开辟
    int* p = arr;
    // 使用  略
    free(p); // 使用free释放非动态开辟的空间
    p = NULL;
    return 0;
}

 
#include <stdio.h>
#include <stdlib.h>
int main()
{
    int* p = malloc(10 * sizeof(int));
    if (p == NULL) 
    {
        return 1;
    }
    int i = 0;
    for (i = 0; i < 5; i++) 
    {
        *p++ = i; // p指向的空间被改变了
        //而且存在内存泄露风险
    }
    free(p);//error  p不再指向动态内存的起始位置
    p = NULL;
    return 0;
}

 
#include <stdio.h>
#include <stdlib.h>
int main()
{
    int* p = malloc(10 * sizeof(int));
    if (p == NULL) 
    {
        return 1;
    }
    int i = 0;
    for (i = 0; i < 10; i++) 
    {
        p[i] = i;
    }
    // 释放
    free(p);
    // 一时脑热或者出了函数后忘了，再一次释放（程序可能会卡死）
    free(p);//error
    return 0;
}

 
#include <stdio.h>
#include <stdlib.h>
void test()
{
    int* p = (int*)malloc(100);
    if (p == NULL)
    {
        return;
    }
    // 使用 略
    
    // 此时忘记释放了
}
int main()
{
    test();
    free(p); // 此时释放不了了，没人知道这块空间的起始位置在哪了
    p = NULL;
}

 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void GetMemory(char* p)
{
    p = (char*)malloc(100);
}
void Test() 
{
    char* str = NULL;
    GetMemory(str);
    strcpy(str, "hello world");
    printf(str);
}
int main() 
{
    Test();
    return 0;
}

 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// ↓ 修改返回类型为char*
char* GetMemory(char* p) 
{
    p = (char*)malloc(100);
    return p; // 将p带回来
}
void Test() 
{
    char* str = NULL;
    str = GetMemory(str); // 用str接收，此时str指向刚才开辟的空间
    strcpy(str, "hello world"); // 此时copy就没有问题了
    printf(str);//printf("hello world");传给printf函数的也是h的地址，所以没问题
    // 用完之后记得free，就可以解决内存泄露问题
    free(str);
    str = NULL; // 还要将str置为空指针
}
int main() 
{
    Test();
    return 0;
}

 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//              ↓ 用char**接收
void GetMemory(char** p) 
{
    *p = (char*)malloc(100);
}
 
void Test() 
{
    char* str = NULL;
    GetMemory(&str); // 址传递，就可以得到地址
    strcpy(str, "hello world");
    printf(str);
    // 记得free，就可以解决内存泄露问题
    free(str);
    str = NULL; // 还要将str置为空指针
}
int main() 
{
    Test();
    return 0;
}

 
#include <stdio.h>
#include <stdlib.h>
char* GetMemory(void) 
{
    char p[] = "hello world";
    return p;
}
void Test(void) 
{
    char* str = NULL;
    str = GetMemory();
    printf(str);
}
int main() 
{
    Test();
    return 0;
}

 
#include <stdio.h>
#include <stdlib.h>
void GetMemory(char** p, int num) 
{
    *p = (char*)malloc(num);
}
void Test(void) 
{
    char* str = NULL;
    GetMemory(&str, 100);
    strcpy(str, "hello");
    printf(str);
}
int main() 
{
    Test();
    return 0;
}

 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void Test(void) 
{
    char* str = (char*)malloc(100);
    strcpy(str, "hello");
    free(str);
    if (str != NULL) 
    {
        strcpy(str, "world");
        printf(str);
    }
}
int main() 
{
    Test();
    return 0;
}