温故C语言内存管理完整攻略

C语言的内存管理是编写高质量、高性能软件的关键。C语言程序员必须掌握内存分配、释放、传递等过程，以避免内存泄漏等问题。本文将介绍一些内存管理的基础知识和高级技巧，并带您通过两个示例了解C语言内存管理的实际应用。

内存管理基础知识

C语言提供了几种内存管理函数，包括malloc()、calloc()、realloc()和free()。让我们先来了解一下这些函数的作用。

malloc()

malloc()是C语言中最常用的内存分配函数。它用于分配指定字节数的内存，如果分配成功，则返回指向新分配内存的指针，否则返回NULL。函数声明如下所示：

void *malloc(size_t size);

下面是使用malloc()函数分配内存的示例代码：

int *p = (int*) malloc(sizeof(int));
if (p != NULL) {
   *p = 42;
} else {
   printf("内存分配失败！\n");
}

calloc()

calloc()函数用于分配内存空间，与malloc()类似，但有一个区别。malloc()只分配内存空间，而未初始化分配空间的值，而calloc()不仅分配内存空间，而且将分配的空间清零。函数声明如下所示：

void *calloc(size_t n, size_t size);

下面是使用calloc()函数分配内存的示例代码：

int *p = (int*) calloc(1, sizeof(int));
if (p != NULL) {
   *p = 42;
} else {
   printf("内存分配失败！\n");
}

realloc()

realloc()函数用于重新分配内存空间。它通常用于扩大或缩小已经分配的空间。如果分配成功，则返回指向新分配内存的指针，否则返回NULL。函数声明如下所示：

void *realloc(void *ptr, size_t size);

下面是使用realloc()函数重新分配内存的示例代码：

int *p = (int*) malloc(sizeof(int));
if (p != NULL) {
   *p = 42;
   p = (int*) realloc(p, sizeof(int)*2);
   if (p != NULL) {
      *(p+1) = 13;
   } else {
      printf("内存分配失败！\n");
   }
} else {
   printf("内存分配失败！\n");
}

free()

free()函数用于释放已经分配的内存空间。函数声明如下所示：

void free(void *ptr);

下面是使用free()函数释放内存空间的示例代码：

int *p = (int*) malloc(sizeof(int));
if (p != NULL) {
   *p = 42;
   free(p);
} else {
   printf("内存分配失败！\n");
}

高级内存管理技巧

预分配缓存

在某些情况下，您可能需要频繁分配和释放大块内存，以保持性能。在这种情况下，通常使用一个称为"内存池"的技术来处理。实际上，这是一组预分配的内存块，在程序执行期间重复使用。这种方法不仅能减少内存分配和释放带来的开销，而且能更好地控制内存使用。

下面是一个预分配缓存的示例：

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

#define DEFAULT_BUFFER_SIZE 4096

typedef struct {
   char *buffer;
   size_t size;
   size_t offset;
} cache_t;

cache_t *cache_init(size_t size) {
   cache_t *c = (cache_t*) malloc(sizeof(cache_t));
   if (c != NULL) {
      c->buffer = (char*) malloc(size);
      if (c->buffer != NULL) {
         c->size = size;
         c->offset = 0;
         memset(c->buffer, 0, size);
      } else {
         free(c);
         c = NULL;
      }
   }
   return c;
}

int cache_write(cache_t *c, char *data, size_t size) {
   if (c->offset + size > c->size) {
      return -1;
   }
   memcpy(c->buffer + c->offset, data, size);
   c->offset +=size;
   return size;
}

void cache_clear(cache_t *c) {
   c->offset = 0;
   memset(c->buffer, 0, c->size);
}

void cache_free(cache_t *c) {
   free(c->buffer);
   free(c);
}

int main() {
   cache_t *c = cache_init(DEFAULT_BUFFER_SIZE);
   if (c != NULL) {
      char *data = "hello world";
      if (cache_write(c, data, strlen(data)) > 0) {
         printf("%s\n", c->buffer);
      }
      cache_clear(c);
      cache_free(c);
   } else {
      printf("内存分配失败！\n");
   }
   return 0;
}

在这个示例中，我们使用了一个带有固定大小的缓存区，称为cache_t结构体。cache_t类型具有buffer、size和offset三个变量。buffer是预分配的内存块、size是缓冲区的大小（在这个示例中设置为4kB），offset是已经写入的字节数。使用cache_init()函数初始化cache_t结构体，cache_write()函数写入数据，cache_clear()函数清除缓存（将offset设置为0且清空buffer），cache_free()函数释放缓存区。

内存对齐

在某些情况下，可能需要手动对内存进行对齐以提高程序性能，例如，缓存控制块或其他需要优化的结构。

下面是一个演示如何手动对齐内存的示例，请注意标准C库中没有固定以某个字节对齐的分配函数：

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

int main() {
   int *p;
   p = (int*) memalign(16, sizeof(int));
   if (p != NULL) {
      printf("p地址：0x%x, 对齐方式：%d\n", p, posix_memalign(&p, 16, sizeof(int)));
      free(p);
   } else {
      printf("内存分配失败！\n");
   }
   return 0;
}

在本例中，我们使用了malloc.h库中的memalign()函数，并在16字节边界上分配了整数int类型的内存块。我们还使用了posix_memalign()函数来检查内存是否正确对齐。

示例1：通过动态内存管理实现字符串拼接

现在假设我们需要实现一个函数，将两个字符串拼接在一起。我们在这里使用动态内存管理来实现。

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

char *concat(const char *str1, const char *str2) {
   size_t size1 = strlen(str1);
   size_t size2 = strlen(str2);
   char *result = (char*) malloc(size1 + size2 + 1);
   if (result != NULL) {
      memset(result, 0, size1 + size2 + 1);
      memcpy(result, str1, size1);
      memcpy(result + size1, str2, size2);
      return result;
   } else {
      printf("内存分配失败！\n");
      return NULL;
   }
}

int main() {
   char *s = concat("hello ", "world");
   if (s != NULL) {
      printf("%s\n", s);
      free(s);
   }
   return 0;
}

在这个示例中，我们使用了concat()函数来连接两个字符串。该函数先计算两个字符串的长度，然后使用malloc()函数分配内存块，将两个字符串复制到新分配内存块中，并在字符串结束时添加NULL终止符。最后，我们通过free()函数释放字符串的内存块。

示例2：动态二维数组

假设我们需要在C语言中创建动态二维数组以存储一些数据。动态数组分配可能会非常复杂，但是通过使用动态内存分配函数，我们可以轻松地创建一个动态数组。

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

int main() {
   int **matrix;
   size_t rows = 3;
   size_t cols = 4;
   size_t i, j;

   matrix = (int**) malloc(rows * sizeof(int*));
   if (matrix != NULL) {
      for (i = 0; i < rows; i++) {
         matrix[i] = (int*) malloc(cols * sizeof(int));
         if (matrix[i] == NULL) {
            printf("内存分配失败！\n");
            return -1;
         }
      }
      for (i = 0; i < rows; i++) {
         for (j = 0; j < cols; j++) {
            matrix[i][j] = i * cols + j;
            printf("%3d ", matrix[i][j]);
         }
         printf("\n");
      }
      for (i = 0; i< rows; i++) {
         free(matrix[i]);
      }
      free(matrix);
      matrix = NULL;
   } else {
      printf("内存分配失败！\n");
   }
   return 0;
}

在这个示例中，我们首先分配一个指针的数组，我们用它来存储指向每一行的指针。使用malloc()函数分配二维数组的指针（行指针数组），并在这个循环中逐一分配每一行的指针。然后使用二重循环将数据插入到数组中，最后调用free()函数释放数组的每一行和指向它们的指针，最后释放指针数组本身的内存块。

结论

C语言的内存管理是编写高质量、高性能软件的关键。在本文中，我们介绍了C语言内存管理的基本知识和高级技巧，以及两个实际应用的示例。务必要记住，正确地使用内存函数以及使用高级技巧，例如内存池或手动内存对齐，可以优化程序性能并避免常见的问题，如内存泄漏。

本站文章如无特殊说明，均为本站原创，如若转载，请注明出处：温故C语言内存管理 - Python技术站

温故C语言内存管理