（C语言）栈与堆：内存分配的初步认识

在C语言中，栈（Stack）和堆（Heap）是两种不同的内存分配区域，用于存储变量和程序数据。

1.栈(Stack)与堆（Heap）        

栈是一种遵循后进先出（LIFO, Last In First Out）原则的数据结构。它主要用于存储局部变量和函数调用的相关信息（如返回地址和参数）。当函数被调用时，它的局部变量和一些其他信息被压入栈中；当函数返回时，这些信息被从栈中弹出。栈的特点是由系统自动分配和释放内存，无需程序员手动管理。

堆是用于动态内存分配的区域。与栈不同，程序员需要显式地申请在堆上分配内存（例如，使用malloc函数），并在不再使用时释放（例如，使用free函数）。堆上的内存分配不遵循LIFO原则（后进先出，栈），程序可以以任意顺序申请和释放内存。这使得堆更加灵活，但也意味着程序员需要负责管理这部分内存的生命周期，否则可能会导致内存泄漏或其他内存管理问题。

为了更方便理解

1. 栈的视觉化：或者想象你的桌子上有一堆书。每次你需要新的书，就把它放在这堆书的顶部。需要的时候，你总是从顶部拿走最新放上去的那本书。这就是栈的工作方式：后放上去的书，先被拿走。这跟栈的“后进先出”（LIFO）原则完全一致。在程序中，每当你调用一个新的函数，它的信息（比如变量）就像是放在书堆的顶部；当函数执行完毕，这些信息就被移除。

2. 堆的视觉化： 想象一下你家里的一个储藏室。这个储藏室里可以随意放置或取出物品，没有特定的顺序。当你需要存储一些东西时，你找到一个空位，放上去；需要用到某样东西时，你就去找它，然后拿走，不管它被放置在储藏室的哪个位置。这就像是堆的工作方式：你可以在任何时间申请（放置）或释放（拿走）内存空间，而不需要遵循特定的顺序。不过，你需要记得哪里放了什么东西（即，你需要管理内存的分配和释放）。

例子

栈的例子：局部变量和函数调用

在C语言中，函数的局部变量通常存储在栈上。这意味着当函数被调用时，它的局部变量会被自动分配内存，当函数执行完毕并返回时，这些变量占用的内存会被自动释放。

#include <stdio.h>

void function() {
    int localVar = 10; // 局部变量，存储在栈上
    printf("Local variable value is: %d\n", localVar);
}

int main() {
    function(); // 调用function，localVar被创建
    // 函数返回后，localVar被销毁
    return 0;
}

localVar在function函数中定义，并在函数调用时自动分配在栈上。函数执行完成后，localVar的内存会被自动回收，无需程手动管理。

堆的例子：动态内存分配

与栈不同，堆用于动态内存分配，这意味着可以在运行时分配特定大小的内存，并在不再需要时手动释放它。使用malloc或calloc函数来分配内存，并使用free函数来释放内存。

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

int main() {
    int *ptr = (int *)malloc(sizeof(int)); // 在堆上分配内存
    if (ptr == NULL) {
        printf("Memory allocation failed\n");
        return -1;
    }
    *ptr = 10; // 使用分配的内存
    printf("Value of the allocated memory: %d\n", *ptr);

    free(ptr); // 释放内存
    ptr = NULL; // 避免野指针
    return 0;
}

2.malloc与calloc的区别与使用方法

 

在C语言中，malloc和calloc函数用于在堆上动态分配内存。尽管它们的目的相同，即为变量或数组分配内存，但它们之间存在一些关键差异。下面我们详细介绍这两个函数，包括它们的用法、区别、注意事项以及在什么情况下使用它们。

malloc函数

 

注意事项与易错点

 

 

 

• 用法：malloc函数分配一块指定大小的内存区域。它的参数是你希望分配的字节数。malloc不会初始化内存，分配的内存区域可能包含未定义的值。
• 函数原型：void* malloc(size_t size);

• int *ptr = (int *)malloc(10 * sizeof(int)); // 分配一个整型数组的内存，数组大小为10
  if (ptr == NULL) {
      // 处理内存分配失败的情况
  }
  

  calloc函数

• 用法：calloc函数分配内存，并自动初始化所有位为零。它有两个参数：需要分配的元素数量和每个元素的大小。
• 函数原型：void* calloc(size_t num, size_t size);

• int *ptr = (int *)calloc(10, sizeof(int)); // 分配并初始化一个整型数组的内存，数组大小为10
  if (ptr == NULL) {
      // 处理内存分配失败的情况
  }
  

  malloc与calloc的区别

• 初始化：malloc仅分配内存而不初始化，分配的内存区域可能包含垃圾值。而calloc分配内存并将其初始化为零。
• 参数：malloc需要一个参数，即总的字节数。calloc需要两个参数，分别是元素数量和每个元素的大小。
• 内存泄漏：使用malloc或calloc分配的内存需要手动释放，否则会导致内存泄漏。
• 空指针检查：分配内存后，应该检查返回的指针是否为NULL，以确保内存分配成功。
• 类型转换：在C中，从void*到其他类型的指针的转换是自动的，但在C++中需要显式转换。
• 正确的大小：使用sizeof操作符来确保分配正确数量的内存，尤其是对于不同类型的数据。
• 性能：由于calloc会初始化内存，所以可能比malloc稍慢一些，特别是在分配大量内存。

 

何时使用malloc

场景一：分配单个变量的内存

当你需要为一个单独的变量分配内存时，可以使用malloc。这在你需要创建动态数据结构，如链表或树的节点时尤其有用。

 

struct Node {
    int value;
    struct Node *next;
};

// 分配一个新节点
struct Node *newNode = (struct Node *)malloc(sizeof(struct Node));
if (newNode == NULL) {
    // 错误处理: 内存分配失败
}
newNode->value = 10; // 初始化节点值
newNode->next = NULL; // 下一个节点指针初始化为NULL

在这个例子中，我们为一个链表节点分配内存。由于malloc不会自动初始化内存，我们需要手动初始化value和next字段。

场景二：分配未初始化的数组

当你需要一个数组，而数组的初始值不重要，或者你打算在之后立即填充或更新这个数组时，malloc是一个好选择。

int *array = (int *)malloc(10 * sizeof(int));//这里的10为元素的数量，实际上可以是任意数
if (array == NULL) {
    // 错误处理: 内存分配失败
}

// 填充数组
for (int i = 0; i < 10; i++) {
    array[i] = i * i; // 用值初始化数组
}

为什么需要乘以sizeof(int)

当你使用malloc或calloc分配内存时，你需要指定总共需要多少字节。由于这两个函数都不知道你打算存储什么类型的数据，所以你需要明确告诉它们一个元素需要多少内存（使用sizeof），然后再乘以你需要的元素数量。

• 对于malloc，你需要计算总的字节数，所以你将元素的数量乘以每个元素的大小：malloc(10 * sizeof(int))。这意味着“请分配足够存储10个int的内存”。
• 对于calloc，函数接受两个参数：元素的数量和每个元素的大小，分别为：calloc(10, sizeof(int))。这同样意呀着“请分配并初始化足够存储10个int的内存”。

何时使用calloc

场景一：分配并初始化数组

当你需要一个已初始化的数组时，特别是需要所有元素都初始化为零时，calloc会非常方便。

int *array = (int *)calloc(10, sizeof(int));
if (array == NULL) {
    // 错误处理: 内存分配失败
}

// 数组的每个元素都已自动初始化为0，无需额外初始化步骤

在这个例子中，我们创建了一个整数数组，并保证了所有元素在分配时都被初始化为零。这对于某些算法很有用，比如需要计数或累加操作的场景，初始值为零是一个好的开始。

场景二：清晰的代码和初始化需求

当你希望代码更清晰、更明确地表达出你的初始化需求时，calloc可以是一个明智的选择。即使性能不是主要关注点，明确地初始化内存也可以减少未定义行为的风险。

注意事项

• 性能考虑：由于calloc会初始化内存，它可能比malloc慢，特别是在分配大块内存时。如果性能是一个关键因素，并且你将立即覆盖分配的内存，那么使用malloc可能更合适。
• 安全性：使用calloc可以减少一些由未初始化内存导致的错误。如果你不确定内存是否会被正确初始化，那么使用calloc可能会更安全。
• 正确释放内存：无论是malloc还是calloc分配的内存，一旦不再需要，都应该使用free来释放。不释放内存会导致内存泄漏，可能会影响程序的性能或稳定性。