【C语言】静动态内存的跨函数访问malloc、free

多指针初认识：

#include <stdio.h>
#include <stdlib.h>
int main()
{
	int i = 100;
    int *p = &i;
    int **q = &p;
    int ***r = &q;
    
    //r = &p;   //error 因为r是 int*** 类型，r只能存放 int** 类型变量的地址
    printf("i = %d\n",***r);	
    
	system("pause");
	return 0;
}

输出结果：

i = 100

动态内存和多级指针的跨函数访问

#include <stdio.h>
#include <stdlib.h>
 
void f(int **p)
{
	*p = 10;
}
 
int main()
{
	
	int *p = (int *)malloc(4);
 
	f(&p);	
    
    printf("*p = %d\n",p);
    
	system("pause");
	return 0;
}

输出结果：

*p = 10

动态内存和静态内存的比较：

静态内存是由系统自动分配，由系统自动释放

静态内存是在栈分配的

动态内存由程序员手动分配，手动释放

动态内存是在堆分配的

静态内存不可以跨函数访问：

通俗说就是:当被调用的函数结束后，被调用函数里面的静态内存不能被其他函数访问。

#include <stdio.h>
#include <stdlib.h>
 
void f(int **q)
{
	int i = 10;
	//*q等价于p  q和**q都不等价于p
    //*q =i;//error 因为*q = i等价于p = i;这样写是错误的
	
    *q = &i;   //等价于 p = &i;
}
	
int main()
{
	int *p;
    
    f(&p);
    
    printf("%d\n",*p);	//本语句语法没有问题，但是逻辑上有问题
      
	system("pause");
	return 0;
}

输出结果：

10

这个程序运行是能正常输出的，但是程序是错误的，逻辑上有错误。

因为当 f( ) 函数执行完毕之后，函数终结（也就是函数的出栈），此时函数静态分配的变量的空间会被全部释放，静态变量的空间访问权限会还给操作系统，我们不能再对他进行读写操作。具体到这个 f( ) 函数就是 ，变量 q 没了，变量 i 没了， i 的值 10 也没有了。也可以说 p 指向 的 变量 i 的空间没了。

那么main 函数 就不能访问 i 的值，也就是 printf("%d\n",*p) 中的 *p 逻辑上是不可以的。

但是 指针P 可以存放着 i 的地址。但是不能访问 i 的空间，没有权限进行读写操作。

动态内存跨函数访问：

malloc堆分配的动态内存，不会随着函数的结束而被释放，只有手动free才会被释放

#include <stdio.h>
#include <stdlib.h>
 
void f(int **q)
{
	*q = (int *)malloc(sizeof(int));  //等价于 p=(int *)malloc(sizeof(int)) 
    
    //q = 10;    //error
    //*q = 10;   //等价于  p = 10;
    **q = 10;    //等价于 *p = 10;
}
 
int main()
{	
	int *p = (int *)malloc(4);
 
	f(&p);    
 
    printf("*p = %d\n",*p);
        
	system("pause");
	return 0;
}

输出结果：

*p = 10

malloc和free示例

malloc

malloc（Memory Allocation）是一个C语言中的标准库函数，用于动态分配内存空间。它的声明在 <stdlib.h> 头文件中。

void *malloc(size_t size);

• 参数： size 表示要分配的字节数，即所需的内存空间大小。
• 返回值： 返回一个指向新分配内存的指针。如果分配失败，返回 NULL。

动态内存分配可以帮助你在程序运行时根据需要动态地分配内存，而不是在编译时确定固定的内存大小。这在处理不确定数量的数据或在运行时动态生成数据结构时非常有用。

使用 malloc 的基本示例：

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

int main() {
    int *arr;
    int size = 5;

    // 分配内存空间，大小为 size * sizeof(int) 字节
    arr = (int *)malloc(size * sizeof(int));

    if (arr == NULL) {
        // 内存分配失败
        printf("Memory allocation failed\n");
        return 1;
    }

    // 在分配的内存中进行操作
    for (int i = 0; i < size; i++) {
        arr[i] = i * 2;
    }

    // 打印结果
    for (int i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }

    // 释放内存
    free(arr);

    return 0;
}

在使用 malloc 后，务必使用 free 函数释放已分配的内存，以避免内存泄漏。如果你的程序使用了动态分配的内存，确保在不再需要这些内存块时释放它们。否则，可能会导致内存占用过多，最终导致程序崩溃。

free

在C语言中，free 是一个用于释放动态分配内存的标准库函数，声明在 <stdlib.h> 头文件中。它的使用非常简单，通常与 malloc、calloc 或 realloc 配合使用。

void free(void *ptr);

• 参数： ptr 是一个指向先前由 malloc、calloc 或 realloc 返回的指针，该指针指向要释放的内存块。

示例：

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

int main() {
    int *arr;

    // 分配内存空间
    arr = (int *)malloc(5 * sizeof(int));

    if (arr == NULL) {
        printf("Memory allocation failed\n");
        return 1;
    }

    // 在分配的内存中进行操作
    for (int i = 0; i < 5; i++) {
        arr[i] = i * 2;
    }

    // 打印结果
    for (int i = 0; i < 5; i++) {
        printf("%d ", arr[i]);
    }

    // 释放内存
    free(arr);

    // 将指针置为 NULL，以避免野指针
    arr = NULL;

    return 0;
}

在上述例子中，malloc 被用来分配一个包含 5 个整数的内存块。使用完这块内存后，我们通过调用 free(arr) 来释放这块内存。在释放后，为了避免野指针的问题，我们将指针 arr 置为 NULL。

记住，在使用 free 之后，被释放的内存块不再属于程序，因此在后续的代码中尽量避免使用已经释放的内存。释放内存的好习惯可以防止内存泄漏，提高程序的健壮性。