C语言中如何进行内存管理

​

C语言是一种强大而灵活的编程语言，但与其他高级语言不同，它要求程序员自己负责内存的管理。正确的内存管理对于程序的性能和稳定性至关重要。

一、引言

C 语言是一门广泛使用的编程语言，它为程序员提供了对内存的直接控制能力。这种对内存的控制使得 C 语言非常灵活，但也带来了更大的责任。在 C 语言中，程序员需要负责内存的分配和释放，否则可能会导致内存泄漏和其他内存管理问题。本文将深入探讨 C 语言的内存管理机制，包括内存分配、内存释放、内存泄漏等问题。

二、内存分配

C语言中有三种内存分配方式：

• 静态内存分配
• 栈内存分配
• 动态内存分配

静态内存分配

静态内存分配：静态内存分配是在程序编译时进行的，它将内存分配给全局变量和静态变量。全局变量和静态变量的内存空间在程序运行期间一直存在，直到程序结束。静态内存分配的优点是内存分配和释放的效率高，缺点是内存使用不灵活，无法根据需要动态调整内存大小。

当我们创建变量的时候，系统将会自动的为变量分配空间：

//创建变量a
int a = 0;

可以观察到当创建变量a后系统会为a分配一块内存，这就是静态内存的分配。

栈内存的分配

栈内存分配是在程序运行时进行的，它将内存分配给函数内部的局部变量。栈内存的空间是有限的，当函数执行完毕后，栈内存会自动释放。栈内存分配的优点是内存管理简单，缺点是内存空间有限，不适合分配大内存。

例如：

当创建一个函数，在函数中创建一个变量local_num，和local_name

void test()
{
	int local_num = 17;
	char local_name = "Kevin";

}

int main()
{
	test();

	return 0;
}

当调试时走过这两个局部变量但没有走出函数时可以观察到这两个变量成功的创建了：

当走出函数后刷新即可发现两个变量变成了未标识变量：

这就是在函数中的栈内存分配，随用随分配，在用过后就销毁。

动态内存分配

动态内存分配是在程序运行时根据需要进行的内存分配。它使用 malloc() 函数或 calloc() 函数来分配内存空间，使用 free() 函数来释放内存空间。动态内存分配的优点是内存使用灵活，可以根据需要动态调整内存大小，缺点是内存管理复杂，容易出现内存泄漏等问题。

具体函数的使用可以翻阅博主这篇博客进行查阅

C/C++ (stdio.h)标准库详解-CSDN博客

icon-default.png?t=N7T8

https://cloud.tencent.com/developer/article/2398153

1. malloc

malloc() 函数用于分配指定大小的内存块

int main() 
{
    int* ptr;

    // 分配 10 个整数的内存块
    ptr = (int*)malloc(10 * sizeof(int));

    if (ptr == NULL) 
    {
        printf("内存分配失败\n");
        exit(1);
    }

    // 访问分配的内存
    for (int i = 0; i < 10; i++) 
    {
        ptr[i] = i + 1;
    }

    // 输出分配的内存中的值
    for (int i = 0; i < 10; i++) 
    {
        printf("%d ", ptr[i]);
    }
    printf("\n");

    // 释放内存
    free(ptr);

    return 0;
}

在上述示例中，malloc() 函数用于分配 10 个整数的内存块。如果内存分配成功，ptr 将指向分配的内存块，否则输出错误信息并退出程序。然后，可以通过 ptr 访问和修改分配的内存。最后，使用 free() 函数释放分配的内存块。

2. calloc

calloc() 函数用于分配指定数量的元素，并将它们初始化为 0

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

int main() 
{
    int* ptr;

    // 分配 10 个整数的内存块，并将它们初始化为 0
    ptr = (int*)calloc(10, sizeof(int));

    if (ptr == NULL) 
    {
        printf("内存分配失败\n");
        exit(1);
    }

    // 访问分配的内存
    for (int i = 0; i < 10; i++) 
    {
        printf("%d ", ptr[i]);
    }
    printf("\n");

    // 释放内存
    free(ptr);

    return 0;
}

在上述示例中，calloc() 函数用于分配 10 个整数的内存块，并将它们初始化为 0。如果内存分配成功，ptr 将指向分配的内存块，否则输出错误信息并退出程序。然后，可以通过 ptr 访问和修改分配的内存。最后，使用 free() 函数释放分配的内存块。

3. free

free() 函数用于释放之前分配的内存块，在上文malloc和calloc中均用到了free函数，目的就是在使用完分配的内存块后进行释放，避免内存泄漏。

三、内存释放

在 C 语言中，内存释放是非常重要的。如果忘记释放不再使用的内存，就会导致内存泄漏。内存泄漏会导致程序的性能下降，甚至可能导致程序崩溃。在 C 语言中，有两种常见的内存释放方式：手动释放和自动释放。

1. 手动释放

手动释放是指程序员使用 free() 函数来释放不再使用的内存空间。在使用动态内存分配时，程序员需要在不再使用内存空间时手动调用 free() 函数来释放内存。

#include <stdlib.h>

int* allocate_memory(int size) 
{
    int* memory = (int*)malloc(size * sizeof(int));
    if (memory == NULL) 
    {
        printf("内存分配失败\n");
        exit(1);
    }
    return memory;
}

void free_memory(int* memory) 
{
    if (memory != NULL) 
    {
        free(memory);
    }
}

int main() 
{
    int* dynamic_memory = allocate_memory(10);
    for (int i = 0; i < 10; i++) 
    {
        dynamic_memory[i] = i + 1;
    }

    for (int i = 0; i < 10; i++) 
    {
        printf("%d ", dynamic_memory[i]);
    }
    printf("\n");

    free_memory(dynamic_memory);
    return 0;
}

1. allocate_memory 函数用于动态分配一块大小为 size 个整数的内存空间，并返回指向该内存空间的指针。如果内存分配失败，程序会输出提示信息并调用 exit(1) 来退出程序。
2. free_memory 函数用于释放动态分配的内存空间，首先检查指针是否为空，然后调用 free 函数进行内存释放。
3. 在 main 函数中，首先调用 allocate_memory 函数分配了包含 10 个整数的内存空间，并将返回的指针赋值给 dynamic_memory。然后使用循环给动态分配的内存赋值，并输出每个元素的值。
4. 最后，通过调用 free_memory 函数释放动态分配的内存空间，避免内存泄漏。

2. 自动释放

自动释放是指在某些情况下，C 语言的编译器会自动释放不再使用的内存空间。例如，当函数执行完毕后，编译器会自动释放函数内部的栈内存。

#include <stdio.h>

void function() 
{
    int local_variable = 30;
    printf("局部变量的值：%d\n", local_variable);
}

int main() 
{
    function();
    return 0;
}

四、内存泄漏

内存泄漏指程序在不再需要使用内存时未将其释放，导致系统内存资源浪费。内存溢出则是指程序访问超出了已分配内存块的范围（例如数组越界访问）。

五、指针和内存

在C语言中，指针与内存密切相关。我们可以通过指针指向目标地址来直接操作内存，包括访问、修改和释放内存。

指针数组

int *ptrArray[10]; // 声明一个包含10个整型指针的数组

二级指针

int **pptr; // 声明一个二级整型指针
int value = 100;
int *ptr = &value;
pptr = &ptr; // 将ptr的地址赋给pptr

指针与结构体

结构体和指针的结合也是C语言中常见的用法，可以方便地操作复杂的数据结构（例如链表）。