防止内存泄漏策略

c策略

在 C 语言中，内存管理是一个重要而且容易出错的部分，因为程序员需要手动分配和释放内存。内存泄漏会导致程序占用的内存不断增加，最终可能导致系统资源耗尽。

1. 一一对应的分配和释放

确保每个 malloc、calloc 或 realloc 调用都有对应的 free 调用。保持一个清晰的分配和释放逻辑，避免遗漏。

#include 

void example() {
    int *ptr = (int *)malloc(10 * sizeof(int));
    if (ptr == NULL) {
        // 处理分配失败
        return;
    }

    // 使用 ptr

    free(ptr); // 确保释放内存
}

2. 初始化指针

在声明指针时，将其初始化为 NULL。这可以帮助在释放内存时检查指针是否有效，并防止重复释放。

int *ptr = NULL;

void example() {
    ptr = (int *)malloc(10 * sizeof(int));
    if (ptr == NULL) {
        // 处理分配失败
        return;
    }

    // 使用 ptr

    free(ptr);
    ptr = NULL; // 释放后将指针设置为 NULL
}

3. 检查内存分配结果

每次调用 malloc、calloc 或 realloc 时，检查返回值是否为 NULL，以确保内存分配成功。

int *ptr = (int *)malloc(10 * sizeof(int));
if (ptr == NULL) {
    // 处理内存分配失败
    fprintf(stderr, "Memory allocation failed\n");
    exit(EXIT_FAILURE);
}

4. 使用自定义内存管理函数

创建自定义的内存分配和释放函数，以便更好地跟踪内存使用情况。这些函数可以记录分配和释放操作，帮助检测内存泄漏。

#include 
#include 

void *customMalloc(size_t size) {
    void *ptr = malloc(size);
    if (ptr == NULL) {
        fprintf(stderr, "Memory allocation failed\n");
        exit(EXIT_FAILURE);
    }
    printf("Allocated %zu bytes\n", size);
    return ptr;
}

void customFree(void *ptr) {
    free(ptr);
    printf("Memory freed\n");
}

void example() {
    int *ptr = (int *)customMalloc(10 * sizeof(int));
    // 使用 ptr
    customFree(ptr);
}

5. 避免内存泄漏的常见场景

• 函数返回前释放内存：在函数返回之前，确保释放在函数内部分配的任何动态内存。
• 错误处理路径：在处理错误时，确保释放已分配的内存。
• 循环中的内存分配：在循环中分配内存时，确保每次迭代后释放不再需要的内存。

c++策略

在 C++ 中，虽然内存管理比 C 更加灵活，但仍然需要小心处理以防止内存泄漏。C++ 提供了一些强大的工具和惯用法来帮助开发者管理内存。以下是一些详细的策略来防止内存泄漏：

1. 使用智能指针

智能指针是 C++ 标准库提供的一种用于自动管理动态内存的工具。它们可以确保在不再需要对象时自动释放内存。

• std::unique_ptr：用于独占所有权的智能指针，确保一个对象只能由一个指针拥有。

  #include 
  
  void example() {
      std::unique_ptr<int> ptr = std::make_unique<int>(10);
      // 无需手动 delete，ptr 超出作用域时会自动释放内存
  }
  

• std::shared_ptr：用于共享所有权的智能指针，多个指针可以共享同一个对象。当最后一个 shared_ptr 被销毁时，内存会被释放。

  #include 
  
  void example() {
      std::shared_ptr<int> ptr1 = std::make_shared<int>(10);
      std::shared_ptr<int> ptr2 = ptr1; // 共享所有权
      // 内存会在 ptr1 和 ptr2 都超出作用域时释放
  }
  

• std::weak_ptr：用于避免循环引用的智能指针，不能直接访问对象，但可以提升为 shared_ptr。

  #include 
  
  struct Node {
      std::shared_ptr<Node> next;
      std::weak_ptr<Node> prev; // 使用 weak_ptr 打破循环引用
  };
  
  void example() {
      auto node1 = std::make_shared<Node>();
      auto node2 = std::make_shared<Node>();
      node1->next = node2;
      node2->prev = node1; // 使用 weak_ptr 避免循环引用
  }
  

2. 遵循 RAII 原则

RAII（Resource Acquisition Is Initialization）是 C++ 中的一种资源管理惯用法。通过将资源管理与对象生命周期绑定，可以自动控制资源的释放。

#include 

void example() {
    std::ofstream file("example.txt"); // 打开文件，构造函数中获取资源
    if (!file.is_open()) {
        // 处理文件打开失败
        return;
    }

    file << "Hello, World!"; // 使用文件资源

    // 文件在超出作用域时自动关闭，析构函数中释放资源
}

3. 避免手动管理动态内存

标准库容器自动管理其内部元素的内存分配和释放。当容器对象被销毁时，它的析构函数会自动释放所有元素的内存。这意味着开发者不需要手动管理容器元素的内存，减少了内存泄漏的风险。所以尽量避免使用 new 和 delete，而是使用标准库容器（如 std::vector, std::string）和智能指针来管理动态内存。

4. 使用标准库容器

标准库容器（如 std::vector, std::list, std::map 等）自动管理其包含的对象的内存。使用这些容器可以减少手动管理内存的复杂性。

#include 

void example() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};
    // 自动管理内存，无需手动 delete
}