动态内存管理2+柔性数组

于 2025-05-19 00:00:00 发布
阅读量754 收藏 7
点赞数 8
文章标签： c语言 柔性数组
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Zzzzmo_/article/details/148031209
版权

一、动态内存经典笔试题分析

分析错误并改正

题目1

void GetMemory(char *p)
{
    p = (char *)malloc(100);
}
void Test(void)
{
    char *str = NULL;
    GetMemory(str);
    strcpy(str, "hello world");
    printf(str);
}
int main()
{
    Test();
    return 0;
}

错误的原因：

1.str传给p的时候（值传递），p是str的临时拷贝，有自己独立的空间，当GetMemory函数内部申请了空间后，地址放在p中时，str依然是NULL。当GetMemory函数返回之后，strcpy拷贝的时候，形成了非法访问内存
2.在GetMemory函数内部，动态申请了内存，但是没有释放，会内存泄露
3.添加对 malloc 返回值的检查，避免分配失败时操作空指针。

改正（采用传址调用）：

void GetMemory(char** p)
{
    *p = (char *)malloc(100);
}
void Test(void)
{
    char *str = NULL;
    GetMemory(&str);// 传递指针的地址
    if(str != NULL)
    {
        strcpy(str, "hello world");
        printf(str);
    }
    free(str);
    str = NULL;
}
int main()
{
    Test();
    return 0;
}

或者返回动态分配的指针:

char* GetMemory()
{
    char* p = (char *)malloc(100);
    return p;
    //return (char*)malloc(100);
}
void Test(void)
{
    char *str = NULL;
    str = GetMemory();
    if(str != NULL)
    {
        strcpy(str, "hello world");
        printf(str);
    }
    free(str);
    str = NULL;
}
int main()
{
    Test();
    return 0;
}

题目2

返回栈空间地址的问题

char *GetMemory(void)
{
    char p[] = "hello world";// 局部数组，存储在栈内存
    return p;// 函数结束后，栈内存被释放，p的地址失效
}
void Test(void)
{
    char *str = NULL;
    str = GetMemory();//函数返回后，局部变量 p 的内存被系统回收，但 str 仍指向该地址，形成悬挂指针。
    printf(str);// 可能输出乱码或崩溃
}
int main()
{
    Test();
    return 0;
}

错误的原因：

GetMemory 函数内部定义了一个局部数组 char p[] = "hello world";，并返回其指针。
问题：局部数组存储在栈内存中，函数结束后栈内存被释放，此时返回的指针指向无效内存（悬挂指针）。后续通过 str 访问会导致未定义行为（如输出乱码或程序崩溃）。
悬空指针：是指向已经被释放或无效内存区域的指针。这种指针虽然保留了之前的内存地址，但地址中的内容可能已被系统回收或重新分配，访问它会导致 未定义行为（如程序崩溃、数据错误、输出乱码等）。

改正：
1.返回字符串常量的指针:

char *GetMemory(void)
{
    char* p = "hello world";
    return p;// 字符串常量存储在只读区，生命周期为整个程序
    //return "hello world";
}
void Test(void)
{
    char *str = NULL;
    str = GetMemory();
    printf(str);
}
int main()
{
    Test();
    return 0;
}

2.使用动态内存分配:

char *GetMemory(void)
{
    char* p = (char*)malloc(strlen("hello world")+1);// +1 用于容纳 '\0'
    if(p != NULL)
    {
        strcpy(p,"hello world");
    }
    return p;
}
void Test(void)
{
    char *str = NULL;
    str = GetMemory();
    if(str != NULL)
    {
        printf("%s\n",str);
    }
    free(str);
    str = NULL;
}
int main()
{
    Test();
    return 0;
}

3.使用静态变量:

char *GetMemory(void)
{
    static char p[] = "hello world";// 静态变量生命周期为整个程序
    return p;
}
void Test(void)
{
    char *str = NULL;
    str = GetMemory();
    printf(str);
}
int main()
{
    Test();
    return 0;
}

题目3

void GetMemory(char **p, int num)
{
    *p = (char *)malloc(num);
}
void Test(void)
{
    char *str = NULL;
    GetMemory(&str, 100);
    strcpy(str, "hello");
    printf(str);
}
int main()
{
    Test();
    return 0;
}

错误的原因：malloc的返回值没有判断并且存在内存泄露（没有free）

改正：

void GetMemory(char **p, int num)
{
    *p = (char *)malloc(num);
}
void Test(void)
{
    char *str = NULL;
    GetMemory(&str, 100);
    if(str != NULL)
    {
        strcpy(str, "hello");
        printf("%s\n",str);
    }
    free(str);
    str = NULL:
}
int main()
{
    Test();
    return 0;
}

题目4

void Test(void)
{
    char *str = (char *) malloc(100);//未对malloc返回值进行判断
    strcpy(str, "hello");
    free(str);
    if(str != NULL)// str 未被置空，条件仍为真
    {
        strcpy(str, "world");// 操作已释放的内存（未定义行为）
        printf(str);// 可能崩溃或输出乱码
    }
}
int main()
{
    Test();
    return 0;
}

错误的原因：未对malloc返回值进行判断，str 未被置空，是一个悬空指针

改正：

void Test(void)
{
    char *str = (char *) malloc(100);
    if(str != NULL)
    {
        strcpy(str, "hello");
        printf("%s\n", str);
    }
    free(str);
    str = NNULL;// 置空指针，避免误用

    // 后续操作需确保指针有效
    if(str != NULL)
    {
        // 此处代码永远不会执行
        strcpy(str, "world");
        printf(str);
    }
}
int main()
{
    Test();
    return 0;
}

二、柔性数组

C99中，结构中的最后⼀个元素允许是未知大小的数组，这就叫做『柔性数组』成员

struct st_type
{
    int i;
    int arr[0];//柔性数组成员
};

有些编译器会报错⽆法编译可以改成：

struct st_type
{
    int i;
    int arr[];//柔性数组成员
};

2.1 柔性数组的特点

1.结构中的柔性数组成员前⾯必须至少⼀个其他成员。

2.sizeof返回的这种结构大小不包括柔性数组的内存。

3.包含柔性数组成员的结构用malloc()函数进行内存的动态分配，并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小。

struct st_type
{
    //1.结构中的柔性数组成员前⾯必须⾄少⼀个其他成员。
    int i;
    int arr[];//柔性数组成员
}type_a;
int main()
{
    //2.sizeof返回的这种结构⼤⼩不包括柔性数组的内存。
    printf("%d\n", sizeof(type_a));//输出的是4
    return 0;
}
//3.包含柔性数组成员的结构⽤malloc()函数进⾏内存的动态分配，并且分配的内存应该⼤于结构的⼤⼩，以适应柔性数组的预期⼤⼩。
struct S
{
    int i;
    char arr[];
};
int main()
{
    struct S* ps = (struct S*)malloc(sizeof(struct S) + 10*sizeof(char));
    if(ps == NULL)
    {
        return 1;
    }
    ps->i = 100;
    printf("%d\n", ps->i);
    int i = 0;
    for(i = 0;i < 10; i++)
    {
        ps->arr[i] = 'Q';
    }
    for(i = 0;i < 10; i++)
    {
        printf("%c ",ps->arr[i]);//Q Q Q Q Q Q Q Q Q Q
    }
    printf("\n");
    //增容
    struct S* ptr = (struct S*)realloc(ps,sizeof(struct S) + 20*sizeof(char));
    if(ptr != NULL)
    {
        ps = ptr;
    }
    else
    {
        perror("realloc");
        return 1;
    }
    for(i = 10;i < 20; i++)
    {
        ps->arr[i] = 'A';
    }
    for(i = 0;i < 20; i++)
    {
        printf("%c ",ps->arr[i]);//Q Q Q Q Q Q Q Q Q Q A A A A A A A A A A
    }
    
    free(ps);
    ps = NULL;
    return 0;
}

柔性数组成员⽤malloc()函数进⾏内存的动态分配后获得空间，对结构体进行计算大小，还是不会算进去，只算除了柔性数组外的大小

printf("%d\n", sizeof(struct S));//4

2.2 柔性数组的优势

1.方便内存释放

2.这样有利于访问速度

代码一：

struct S
{
	int i;
	char arr[];
};
int main()
{
	int i = 0;
	struct S* p = (struct S*)malloc(sizeof(struct S) + 100 * sizeof(char));
	//业务处理 
	p->i = 100;
	for (i = 0; i < 100; i++)
	{
		p->arr[i] = i;
	}
	free(p);
	p = NULL;
	
	return 0;
}

1.malloc一次      2.free一次      3.空间连续

代码二：

struct S
{
    int i;
    char* arr;
};
int main()
{
    struct S* ps = (struct S*)malloc(sizeof(struct S));
    if(ps == NULL)
    {
        perror("malloc");
        return 1;
    } 
    ps->i = 100;
    ps->arr = (char*)malloc(sizeof(char) * 10);
    if(ps->arr == NULL)
    {
        perror("malloc->arr");
        return 1;
    }
    //使用
    int i = 0;
    for(i = 0;i < 10; i++)
    {
        ps->arr[i] = 'Q';
    }
    //释放
    free(ps->arr);
    ps->arr = NULL;
    free(ps);
    ps = NULL;

    return 0;
}

1.malloc两次      2.free两次      3.内存空间不连续（内存碎片多，浪费空间）

三、内存区域划分

C/C++程序内存分配的几个区域：

1. 栈区（stack）：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时 这些存储单元⾃动被释放。栈内存分配运算内置于处理器的指令集中，效率很⾼，但是分配的内 存容量有限。栈区主要存放运⾏函数⽽分配的局部变量、函数参数、返回数据、返回地址等。

2. 堆区（heap）：⼀般由程序员分配释放，若程序员不释放，程序结束时可能由OS回收。分配⽅ 式类似于链表。

3. 数据段（静态区）：（static）存放全局变量、静态数据。程序结束后由系统释放。

4. 代码段：存放函数体（类成员函数和全局函数）的⼆进制代码。

Zzzzmo_
关注
【C语言】动态内存管理，及柔性数组介绍！有浅到深！
Gao123456fy的博客
04-24 868
【C语言】动态内存管理，及柔性数组介绍！有浅到深！
[C笔记]内存区域,动态内存管理,柔性数组(C99)
niokia0v0的博客
08-09 457
变量和数组等在编译时开辟空间的方式无法很好地解决要到程序运行时才知道需要多少空间的情况，因此需要动态内存开辟。在内存中，，函数形参与局部变量位于栈区，而静态变量和全局变量位于静态区。...
超详细——动态内存分配+柔性数组
fighting小泽的博客
04-05 1442
C语言提供了一个内存开辟的函数：malloc可以向内存申请一块连续的空间，并返回一个指向这块空间的指针如果开辟成功，则返回一个指向开辟好空间的指针。如果开辟失败，则返回一个NULL指针，因此malloc的返回值一定要做检查。返回值的类型是 void* ，所以malloc函数并不知道开辟空间的类型，具体在使用的时候使用者自己来决定。如果参数 size 为0，malloc的行为是标准是未定义的，取决于编译器举个例子这样我们就开辟了一个20个字节的空间。
动态内存管理+柔性数组
Jason_from_China的博客
03-30 855
malloc我们打开C语言文档，注意这里不是官方文档​我们发现在C语言文档里面的语法结构是这个样子的void* malloc (size_t size);下面我会进行讲解从C语言的文档里面我们可以看见，头文件cstdlib这里定义了一个名为Student的结构体。结构体是一种复合数据类型，可以将不同类型的数据组合在一起。在Student结构体中有两个成员：int id：用于存储学生的编号，是一个整数类型。：用于存储学生的姓名，是一个长度为 20 的字符数组。
重生之我在异世界学编程之C语言：深入动态内存管理收尾 + 柔性数组篇
z15879084549的博客
12-12 3948
本文是小编承接上一篇——《重生之我在异世界学编程之C语言：深入动态内存管理篇》所作的收尾和补充。有需要的宝子们就跟着小编的步伐一起进入本章知识的学习。Go!Go!Go!
动态内存管理+柔性数组+经典笔试题
深入解析C/C++编程技巧，带你探索高效开发之路
10-15 760
头文件均为stdlib.h忘记释放不再使用的动态开辟的空间会造成内存泄漏。切记：动态开辟的空间一定要释放，并且正确释放。只有当我们完全不再需要动态分配的内存时，才应该释放它，而且不要试图释放不属于我们的内存。
C语言：动态内存管理(动态内存+柔性数组讲解)
2301_77649794的博客
07-20 349
C语言提供了一个动态内存的开辟的函数：malloc这个函数向内存申请一块连续可用的空间，并返回指向这块空间的指针。1.如果开辟成功，则返回一个指向开辟好空间的指针。2.如果开辟失败，则返回一个NULL指针，因此malloc的返回值一定要做检查。3.返回值的类型是 void*(返回值为指针)，所以malloc函数并不知道开辟空间的类型，具体在使用的时候使用者自己来决定(强制类型转换)。4.如果参数size 为0，malloc的行为是标准是未定义的，取决于编译器。int main()
【进阶C语言】动态内存管理+柔性数组
Shun_Hua的博客
01-12 1815
动态管理+柔性数组
动态内存管理+柔性数组 图文讲解
2301_76665083的博客
12-26 590
动态内存管理+柔性数组 图文讲解
C进阶-动态内存管理+柔性数组
syh163的博客
10-20 195
动态内存管理函数有4个：malloc、calloc、realloc、free。
C语言进阶⑰(动态内存管理)四个动态内存函数+动态通讯录+柔性数组_malloc+free
热门推荐
参考书籍：《C语言程序设计》《数据结构》《C++ Primer》《Effective C++》《STL源码剖析》《现代操作系统》《UNIX环境高级编程》《图解TCP/IP》《图解HTTP》《Linux高性能服务器编程》《剑指Offer》《算法导论》
02-09 3万+
C语言进阶⑰（动态内存管理）四个动态内存函数malloc+free+calloc+reallc，动态通讯录，四道经典笔试题，柔性数组，知识点+笔试题。
柔性数组成员
09-26
2. **内存管理**：由于柔性数组成员是结构体的一部分，因此在使用完毕后需要释放整个结构体的内存，而不是仅仅释放柔性数组部分的内存。这可以通过`free`函数完成。 3. **编码风格**：虽然GCC支持零长数组成员，但...
柔性数组教程（个人总结）
年糕的博客
05-30 1116
在C99标准中，引入了柔性数组成员。柔性数组成员必须是结构体中的最后一个成员，并且数组的大小定义为空的方括号[]。// 定义带有柔性数组成员的结构体int length;// 数组长度// 柔性数组成员int n = 5;// 动态数组长度// 动态分配内存，包含结构体和柔性数组成员return 1;// 设置数组长度// 初始化柔性数组成员i < n;i++) {// 输出柔性数组成员i++) {// 释放内存free(fa);return 0;
动态内存深度刨析和柔性数组详解
qq_54626677的博客
07-17 436
这个函数向内存申请一块连续可用的空间，并返回指向这块空间的指针。如果开辟成功，则返回一个指向开辟好空间的指针。如果开辟失败，则返回一个NULL指针，因此malloc的返回值一定要做检查。返回值的类型是void*，所以malloc函数并不知道开辟空间的类型，具体在使用的时候使用者自己来决定。如果参数size为0，malloc的行为是标准是未定义的，取决于编译器。free函数用来释放动态开辟的内存。如果参数ptr指向的空间不是动态开辟的，那free函数的行为是未定义的。...
什么是函数重载？为什么 C 不支持函数重载，而 C++能支持函数重载？
谢谢大家的关注和点赞！这里只有纯纯的知识干货，没有一句废话。希望能实实在在帮到大家～要是觉得有用，别忘了给我点支持哟，你
05-14 334
在编译过程中，编译器会根据函数的参数类型、个数和顺序等信息对函数名进行修饰，生成不同的内部名称。这样，即使函数名相同，只要参数列表不同，在链接时也能正确区分不同的函数，从而实现函数重载。例如，对于函数 void func(int) 和 void func(float) ，编译器可能会将它们修饰为 _Z4funci 和 _Z4funcf ，通过不同的修饰名来区分这两个重载函数。函数重载是指在同一作用域内，可以有多个同名函数，但是这些函数的参数列表（参数的个数、类型或顺序）不同。C++支持函数重载的原因。
atcoder C - ~
2402_87686098的博客
05-18 199
波浪形序列的定义：1：长度>=4；2：仅存在一个波峰和波谷；3：序列的第一个数小于第二个数。给定一个序列p，让你求出p的所有子序列中波浪形序列的个数。
C语言复习--柔性数组
2301_80159237的博客
05-10 279
格式大概如下struct Sint a;char b;int arr[];//柔性数组也可以写成struct Sint a;char b;int arr[0];//柔性数组。
基于COMSOL有限元仿真的三相变压器多物理耦合模型：电磁-声-结构力综合分析 有限元仿真
最新发布
05-19
内容概要：本文详细介绍了如何利用COMSOL Multiphysics有限元仿真平台构建三相变压器的多物理耦合模型，涵盖电磁场、声场和结构力学三个主要方面。首先，通过构建精确的三维模型并设定材料属性，实现了对变压器各部件的物理特性定义。接着，分别进行了电磁场、声场和结构力场的分析，探讨了磁密分布、噪声产生机制及机械应力变化。最后，通过仿真结果的图表和动画展示，深入分析了变压器的能量转换效率、噪声水平和机械强度，提出了优化设计和改进措施。 适合人群：从事电气工程、电力系统设计与维护的技术人员，以及对多物理场仿真感兴趣的科研工作者。 使用场景及目标：适用于希望深入了解三相变压器工作原理及其多物理场耦合特性的研究人员和技术人员。目标是提高变压器设计的科学性和可靠性，降低能耗和噪音污染，确保设备的安全稳定运行。 阅读建议：读者可以通过本文了解COMSOL仿真软件的具体应用方法，掌握多物理场耦合建模的基本流程，并借鉴文中提供的分析思路和解决方案，应用于实际工程项目中。
MATLAB脚本工具在BP神经网络模型计算声品质研究分析中的应用
05-19
内容概要：本文介绍了MATLAB脚本工具在BP神经网络模型计算声品质研究分析中的应用。首先阐述了声品质研究的重要性及其在多个行业中的关键作用，接着详细解释了BP神经网络的工作原理及其在声品质研究中的应用。然后重点讨论了MATLAB在BP神经网络建模中的重要作用，包括数据处理、模型构建、参数设置和训练算法等方面的强大支持。最后提供了一个简单的MATLAB脚本示例，展示了如何使用MATLAB构建和训练BP神经网络模型来进行声品质研究分析。 适合人群：从事声品质研究的科研人员、工程师以及相关领域的研究生。 使用场景及目标：① 提升对声品质的理解和预测能力；② 利用BP神经网络模型提高声品质研究的准确性和可靠性；③ 掌握MATLAB脚本工具的具体使用方法，以便更好地应用于实际项目。 其他说明：本文不仅强调理论知识，还提供了实用的操作示例，有助于读者快速上手并应用于实际研究中。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值