重生之我在异世界学编程之C语言：深入动态内存管理收尾 + 柔性数组篇

大家好，这里是小编的博客频道
小编的博客：就爱学编程

很高兴在CSDN这个大家庭与大家相识，希望能在这里与大家共同进步，共同收获更好的自己！！！

本文目录

引言
正文
- 常见的动态内存管理错误
- - （1）对指针的越界访问
  - （2）free函数对非堆区的指针的释放是非法的
  - （3）使用free函数释放动态内存开辟空间的一部分
  - （4）对于同一块动态内存释放了一次以上
  - （5）内存泄漏（未使用free释放不再使用的动态内存）
- 柔性数组
- - 一柔性数组的定义与特性
  - 二柔性数组的用法
  - 三柔性数组的大小计算
  - 三柔性数组的优势与应用场景
  - 四注意事项与常见问题
  - 五总结与展望
快乐的时光总是短暂，咱们下篇博文再见啦！！！不要忘了，给小编点点赞和收藏支持一下，在此非常感谢！！！

引言

本文是小编承接上一篇——《重生之我在异世界学编程之C语言：深入动态内存管理篇》所作的收尾和补充。逻辑上存在一定的先后顺序，建议先搞懂之前的知识点再进行本章内容的学习。那现在宝子们就跟着小编的步伐一起进入本章知识的学习。Go!Go!Go!

在这里插入图片描述

那接下来就让我们开始遨游在知识的海洋！

正文

常见的动态内存管理错误

温馨提示：

本节内容所展示的代码都为错误代码，宝子们可以根据提示进行自查。

（1）对指针的越界访问

常见于：对于malloc函数的参数理解错误。

例：



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

int main(){
	int* p = (int*)malloc(100);
	if (p == NULL) {
		perror("malloc");
	}
	for (int i = 0; i < 100; i++) {
		printf("%d ", p[i]);
	}
	free(p);
	p = NULL;
	return 0;
}

（2）free函数对非堆区的指针的释放是非法的

常见于：对于free函数理解错误。

例：

#include<stdio.h>
int main() {
	int arr[10] = { 0 };
	int* p = arr;
	free(p);
	p = NULL;
}

（3）使用free函数释放动态内存开辟空间的一部分

常见于：对于free函数理解错误。

例：

#include<stdio.h>
#include<stdlib.h>
int main() {
	int* p = (int*)malloc(10 * sizeof(int));
	if (p == NULL)
	{
		perror("malloc");
		return 0;
	}	
	p++;
	free(p);
	p = NULL;
	return 0;
}

（4）对于同一块动态内存释放了一次以上

常见于：对于free函数理解错误。

例：

#include<stdio.h>
int main(){
	int* p = (int*)malloc(10 * sizeof(int));
	int i = 0;
	for (i = 0; i < 10; i++) {
		*(p + i) = i;
	}
	free(p);
	//.....
	free(p);
	p = NULL;
	return 0;
}

（5）内存泄漏（未使用free释放不再使用的动态内存）

常见于：对于free函数不会运用。

例：

void test() {
	int* p = (int*)malloc(10 * sizeof(int));
	int i = 0;
	for (i = 0; i < 10; i++) {
		*(p + i) = i;
	}
	return p;
}
#include<stdio.h>
int main() {
	int* p = (int*)malloc(10 * sizeof(int));
	int i = 0;
	for (i = 0; i < 10; i++) {
		*(p + i) = i;
	}
	//未使用free释放p指向的内存会导致内存的泄露
	p = NULL;
	return 0;
	//吃内存的程序
	while (1) {
		void* p = malloc(1);
		//未使用free释放p指向的内存会导致内存的泄露
	}

}

在C语言编程中，结构体（struct）是一种非常重要的数据类型，它允许我们将多个不同类型的数据组合在一起，形成一个复合类型。然而，在某些情况下，我们可能希望结构体的某个成员能够具有可变的大小，以适应不同的数据需求。为了满足这一需求，C99标准引入了柔性数组的概念。

柔性数组

一柔性数组的定义与特性

1. 定义

柔性数组是结构体中的一个特殊成员，它的类型是未指定大小的数组。换句话说，这个数组在定义时没有给出具体的长度，而是留待后续使用时动态确定。这种设计使得结构体可以灵活地适应不同大小的数据块。

2. 特性

灵活性：柔性数组允许结构体根据实际需要动态调整大小，从而提高了代码的灵活性和可重用性。

内存连续性：由于柔性数组紧跟在结构体的其他成员之后，因此可以保证数据的内存连续性，这对于某些需要连续访问数据的算法来说是非常有利的。

限制：柔性数组必须是结构体的最后一个成员，且只能有一个柔性数组成员。这是因为编译器需要在编译时知道结构体的大小，以便进行内存分配和访问。如果柔性数组不是最后一个成员或者存在多个柔性数组成员，那么编译器将无法确定结构体的大小。

二柔性数组的用法

1. 基本用法

下面是一个简单的例子，展示了如何使用柔性数组来创建一个可变大小的结构体：

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

typedef struct {
    int id;
    char name[20];
    // 柔性数组，用于存储可变长度的数据
    char data[];
} MyStruct;

MyStruct* create_mystruct(const char* name, const char* data) {
    size_t datalen = strlen(data) + 1; // 包括终止符'\0'
    size_t structsize = sizeof(MyStruct) - sizeof(char) + datalen; // 计算结构体总大小

    // 使用malloc分配内存
    MyStruct* p = (MyStruct*)malloc(structsize);
    if (!p) {
        perror("Failed to allocate memory");
        exit(EXIT_FAILURE);
    }

    p->id = 1; // 设置ID
    strncpy(p->name, name, sizeof(p->name)); // 复制名称到结构体中
    strncpy(p->data, data, datalen); // 复制数据到柔性数组中

    return p;
}

void free_mystruct(MyStruct* p) {
    free(p);
}

int main() {
    const char* name = "Alice";
    const char* data = "This is a test string.";

    MyStruct* s = create_mystruct(name, data);

    printf("ID: %d
", s->id);
    printf("Name: %s
", s->name);
    printf("Data: %s
", s->data);

    free_mystruct(s);

    return 0;
}

在这个例子中，MyStruct结构体包含了一个柔性数组data，用于存储可变长度的字符串数据。create_mystruct函数根据输入的名称和数据计算结构体所需的总大小，并使用malloc函数分配相应的内存空间。然后，它将输入的数据复制到结构体中并返回指向该结构体的指针。最后，在main函数中，我们创建了一个MyStruct实例并打印出其内容。使用完毕后，通过调用free_mystruct函数释放分配的内存。

2.与指针的比较

虽然柔性数组看起来类似于在结构体中使用字符指针来指向动态分配的数据块，但它们之间有一些重要的区别：

内存连续性：如前所述，柔性数组保证了数据的内存连续性，而指针则不一定。当使用指针时，数据块可能位于内存的任何位置，这可能导致缓存未命中率的增加和性能下降。
内存管理：使用柔性数组时，整个结构体（包括柔性数组部分）通常是通过单个malloc或类似函数一次性分配的。这意味着我们可以更容易地管理内存，因为只需要一个free调用就可以释放整个结构体。相比之下，如果使用指针来指向动态分配的数据块，则需要分别管理这些块的内存分配和释放。

例：

柔性数组实现柔性：

typedef struct stu {
	int a;
	char arr[0];    
    //char arr[];   这两种写法都是C99语法规定内的，编译器会支持至少一种写法
}stu;
int main() {
	stu* p = (stu*)malloc(4 * sizeof(int) + 10 * sizeof(char));
	if (p == NULL) {
		perror("malloc::");
		return 1;
	}
	//使用
	int i = 0;
	//赋值
	for (i = 0; i < 10; i++) {
		(p->arr)[i] = i;
	}
	//打印
	for (i = 0; i < 10; i++) {
		printf("%d ", p->arr[i]);
	}
	//释放内存
	free(p);
	p = NULL;
}

非柔性数组实现柔性：

typedef struct stu {
		int a;
		//char arr[0];    
		char* arr;
	}stu;
	int main() {
		//第一次申请动态内存
		stu* p = (stu*)malloc(sizeof(int));
		if (p == NULL) {
			perror("malloc::");
			return 1;
		}
		p->a = 100;
		//第二次申请动态内存
		char* pa = (char*)realloc(NULL, 10);
		if (pa == NULL) {
			perror("realloc->arr");
			return 1;
		}
		p->arr = pa;
		pa = NULL;
		//使用
		int i = 0;
		//赋值
		for (i = 0; i < 10; i++) {
			p->arr[i] = 'a';
		}
		//打印
		for (i = 0; i < 10; i++) {
			printf("%c ", p->arr[i]);
		}
		//第一次释放内存
		free(p->arr);
		p->arr = NULL;
		//第二次释放内存
		free(p);
		p = NULL;
	}

所以我们通过对比可以得出使用柔性数组的好处有：

1.方便释放内存。
2.减少系统碎片，加快访问速度。

三柔性数组的大小计算

基本规则：

计算含有柔性数组（成员）的结构体的大小不包括柔性数组成员的大小，所以含有柔性数组（成员）的结构体至少有除了柔性数组外的1个成员

例：

typedef struct stu {
	int a;
	char arr[0];    
    //char arr[];   这两种写法都是C99语法规定内的，编译器会支持至少一种写法
}stu;
int main() {
	printf("%zd\n", sizeof(stu));   
}

运行结果：

在这里插入图片描述

由此我们就能验证以上规则的正确性。

三柔性数组的优势与应用场景

1. 优势

简化内存管理：通过使用柔性数组，我们可以将数据和结构体一起分配和管理，从而简化了内存管理的复杂性。

提高性能：由于柔性数组保证了数据的内存连续性，因此可以提高某些算法的性能。例如，在处理需要连续访问数据的操作时（如字符串处理、图像处理等），使用柔性数组可以减少缓存未命中率并提高访问速度。

增强代码可读性：通过将数据和结构体结合在一起，我们可以使代码更加清晰易懂。这有助于维护和理解复杂的程序结构。

2. 应用场景

柔性数组在许多领域都有广泛的应用，包括但不限于以下几个方面：

网络通信：在网络通信中，数据包的大小通常是可变的。通过使用柔性数组，我们可以轻松地创建可变大小的数据包结构体来处理不同类型的网络消息。

文件处理：在处理文件时，文件的内容大小和格式可能是未知的或可变的。柔性数组可以用于创建可变大小的文件头或记录结构体来读取和处理文件中的数据。

图像处理：在图像处理中，图像的大小和分辨率可能是不同的。通过使用柔性数组，我们可以创建可变大小的图像数据结构来存储和处理不同尺寸的图像。

数据库操作：在数据库操作中，记录的长度和内容可能是变化的。柔性数组可以用于创建可变大小的记录结构体来存储和操作数据库中的数据。

四注意事项与常见问题

1. 注意事项

确保柔性数组是最后一个成员：如前所述，柔性数组必须是结构体的最后一个成员。否则，编译器将无法确定结构体的大小并进行正确的内存分配。

避免多次分配内存：在使用柔性数组时，应尽量避免对结构体进行多次内存分配。最好是一次性分配足够的内存来容纳所有成员（包括柔性数组部分）。这样可以减少内存碎片和提高性能。

正确处理内存释放：在使用完柔性数组后，应确保正确释放分配的内存以避免内存泄漏。这通常是通过调用free函数来实现的。但是需要注意的是，如果结构体中还包含了其他动态分配的资源（如指针指向的字符串或其他数据结构），则需要分别释放这些资源。

2. 常见问题

编译器支持问题：尽管柔性数组是C99标准的一部分，但并不是所有的编译器都完全支持这一特性。因此，在使用之前请检查您的编译器是否支持柔性数组以及相关的语法和功能。

跨平台兼容性：由于不同平台和编译器之间的实现差异可能会导致柔性数组的行为有所不同。因此，在进行跨平台开发时请谨慎使用柔性数组并确保在不同平台上进行测试和验证。

安全性问题：在使用柔性数组时需要注意安全性问题。例如，在将数据复制到柔性数组中时要确保不会超出分配的内存范围导致缓冲区溢出等问题。此外还需要注意防止内存泄漏和其他常见的安全问题。

五总结与展望

柔性数组是C语言中一个非常有用的特性，它允许开发者创建可变大小的结构体以适应不同的数据需求。通过使用柔性数组，我们可以简化内存管理、提高性能和增强代码可读性。然而，在使用柔性数组时也需要注意一些问题和限制，如确保它是结构体的最后一个成员、避免多次分配内存以及正确处理内存释放等。随着技术的不断发展，未来可能会有更多的优化和改进来提高柔性数组的性能和可靠性。同时我们也期待看到更多创新的应用场景出现以充分利用这一强大的特性。