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

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

分析错误并改正

题目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));//输出的是4return 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.内存空间不连续（内存碎片多，浪费空间）