C语言动态内存管理malloc柔性数组示例详解

什么是动态内存管理

动态内存管理是避免预定义变量长度无法适应实际大小的常见方法。在C语言中，动态内存分配和回收函数是malloc()和free()。

malloc的基本语法和用法

malloc()的原型如下：

void *malloc(size_t size);

其中，参数size是所需内存块的字节数。该函数返回一个void指针，指向分配的内存块的起始地址。如果分配失败，则返回空指针NULL。

在使用malloc()函数时，我们通常需要将结果类型转换为我们需要的特定类型：

int *ip;
ip = (int *) malloc(sizeof(int));

这两行代码将分配一个int类型的内存块，并将其地址赋值给ip指针。sizeof()函数可以获取参数类型的字节数。

柔性数组

C99引入了柔性数组，它是指在结构体中定义的数组，而该数组的长度在运行时确定。柔性数组的书写方式很简单：在数组声明中省略数组长度，直接跟上空方括号：

struct example {
  int count[];
};

上述定义中，count是柔性数组的名称。

使用柔性数组时，分配内存的方式和利用指针访问数组元素的方式都和普通数组相同：

struct example *ptr;
int size = 10;
ptr = malloc(sizeof(struct example) + sizeof(int) * size);
ptr->count[0] = 100;

上述代码中，首先分配了一个包含柔性数组的结构体内存块。然后，记录数组大小的size变量被用来计算内存块的总大小，然后分配相应大小的内存。最后，可以将柔性数组看作常规数组一样访问。

案例分析

示例一：柔性数组应用于动态字符串

这是一个简单的例子，展示了如何使用柔性数组动态分配和管理字符串。我们将使用一个名为str的结构体来存储字符串，其中包括一个长度变量和柔性字符数组。在该结构体上插入字符串、打印字符串或释放内存非常方便。

代码如下：

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

struct str {
    int len;
    char s[];
};

struct str *new_str(const char *s) {
    size_t n = strlen(s);
    struct str *p = malloc(offsetof(struct str, s) + n + 1);
    p->len = n;
    memcpy(p->s, s, n + 1);
    return p;
}

void print_str(const struct str *p) {
    fwrite(p->s, 1, p->len, stdout);
    fputc('\n', stdout);
}

int main(void) {
    struct str *p = new_str("Hello, world!");
    print_str(p);
    free(p);
    return 0;
}

上述代码中，首先定义了一个struct str结构体，并在其中插入字符串长度变量和柔性字符数组。在接下来的new_str()函数中，使用strlen()函数计算传入字符串s的长度，并使用malloc()函数分配足够存储字符串的内存块。最后，使用memcpy()函数将字符串复制到内存块中。print_str()函数可以使用fwrite()函数打印字符串。最后，可以使用free()函数释放分配的内存。

示例二：柔性数组作为动态数组的替代方法

柔性数组还可以用来创建动态数组，也就是在程序运行时，根据需要动态调整数组大小的数组。我们将使用一个名为intArr的结构体来存储整数数组，其中包括一个长度变量和柔性整数数组。在该结构体上添加元素、打印数组或释放内存非常方便。

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

struct intArr {
    int len;
    int a[];
};

struct intArr *new_intArr(int size) {
    struct intArr *p = malloc(sizeof(struct intArr) + size * sizeof(int));
    p->len = size;
    return p;
}

void print_intArr(const struct intArr *p) {
    for (int i = 0; i < p->len; i++) {
        printf("%d ", p->a[i]);
    }
    putchar('\n');
}

int main(void) {
    struct intArr *p1 = new_intArr(5);
    for (int i = 0; i < p1->len; i++) {
        p1->a[i] = i;
    }
    print_intArr(p1);

    struct intArr *p2 = new_intArr(10);
    for (int i = 0; i < p2->len; i++) {
        p2->a[i] = i;
    }
    print_intArr(p2);

    free(p1);
    free(p2);
    return 0;
}

上述代码中，首先定义了一个struct intArr结构体，并在其中插入整数数组长度变量和柔性整数数组。然后，在new_intArr()函数中，使用malloc()函数分配足够存储大小为size整数数组的内存块，同时，将数组长度赋值到内存块中。最后，可以将可分配内存块的前size整数元素视为整数数组intArr。

在main()函数中，首先使用new_intArr()函数创建一个长度为5的int类型数组p1，并使用print_intArr()函数打印数组。接着，创建另一个长度为10的int类型数组p2，并同样使用print_intArr()函数打印数组。最后，使用free()函数释放分配的内存。

总结

本篇攻略详细讲解了动态内存管理和柔性数组在C语言中的应用。柔性数组是一个强大而灵活的编程技术，可以在结构体中创建动态大小的数组。可以用它创建动态字符串，同时也可以用它创建动态数组。不过在使用柔性数组时，需要特别注意内存的分配和使用。