上篇文章我介绍了介绍动态内存管理 的相关内容:c语言进阶部分详解(详细解析动态内存管理)-CSDN博客
各种源码大家可以去我的github主页进行查找:唔姆/比特学习过程2 (gitee.com)
今天便接“上回书所言”,来介绍《高质量C-C++编程》经典例题讲解及柔性数组
void ToMalloc(char* p)
{
p = (char*)malloc(100);
}
void test1(void)
{
char* str = NULL;
ToMalloc(str);
strcpy(str, "hello");
printf(str);//就是printf("%s",str);
free(str);
str=NULL;
}
int main()
{
test1();
return 0;
}
运行结果是程序崩溃了:
有些读者可能遇到这样的情况
int main()
{
char* ar = "abdldsaf";
strcpy(ar,"hello");
printf(ar);
return 0;
}
编译器都会报错,这是因为:ar其实是一个字符串常量 ,我们怎么能对常量进行修改呢?应该使用字符数组来存储可修改的字符串
所以我们可以用数组或者动态开辟进行改正问题
void ToMalloc(char** p)
{
*p = (char*)malloc(100);
}
void test1(void)
{
char* str = NULL;
ToMalloc(&str);
strcpy(str, "hello");
printf(str);//就是printf("%s",str);
}
char* ToMalloc(void)
{
char p[] = "hello world";
return p;
}
void test2(void)
{
char* str = NULL;
str = ToMalloc();
printf(str);
}
int main()
{
test2();
return 0;
}
结果:
大家可以看到是乱码:这是因为我们返回了局部变量的地址。当出了ToMalloc函数后,p在栈空间上面被销毁了。此时返回的指针将指向无效的内存(内存已经还给操作系统了)
void ToMalloc(char** p, int num)
{
*p = (char*)malloc(num);
}
void test3(void)
{
char* str = NULL;
ToMalloc(&str, 100);
strcpy(str, "hello");
printf(str);
}
int main()
{
test3();
return 0;
}
大家可以看到跟问题一我们改进后的代码几乎是是一样的 ,也确实输出hello
问题便是存在内存泄漏 ,我们没有对malloc开辟的空间进行free
void test4()
{
char* str = (char*)malloc(100);
strcpy(str, "hello");
free(str);
if (str != NULL)
{
strcpy(str, "world");
printf(str);
}
}
int main()
{
test4();
return 0;
}
str已经被释放了,str成为了野指针,又对野指针进行操作(非法访问内存 )
C99 中,结构中的最后一个元素允许是未知大小的数组,这就叫做『柔性数组』成员 基本形式如下: typedef struct st_typeundefined {undefined int i ;undefined int a 0 ; // 柔性数组成员 部分编译器不能识别时换成:int a[]; } type_a ;
typedef struct s
{
char a;
int b;
int c[0];//柔性数组成员
};
int main()
{
printf("%d", sizeof(struct s));
return 0;
}
struct s
{
char a;
int b;
int c[0];//柔性数组成员
};
int main()
{
struct s* s1 = (struct s*)malloc(sizeof(struct s)+20);
if (s1 == NULL)
{
perror("malloc");
return 1;
}
//赋值
s1->a = 'a';
s1->b = 6;
for (int i = 0; i < 5; i++)
{
s1->c[i] = i;
}
//打印
for (int i = 0; i < 5; i++)
{
printf("%d ",s1->c[i]);
}
//如果不够,就扩容
struct s* s2 = (struct s*)realloc(s1, sizeof(struct s) + 40);
if (s1 != NULL)
{
s1 = s2;
}
else
{
return 1;
}
//释放
free(s1);
s1 = NULL;
return 0;
}
也许我们会想,下面的代码也有相同的作用啊,为什么还要用柔性数组呢?
struct S
{
char a;
int b;
int* c;
};
int main()
{
struct S* s1 = (struct s*)malloc(sizeof(struct s));
if (s1 == NULL)
{
perror("malloc");
return 1;
}
//赋值
s1->a = 'a';
s1->b = 6;
s1->c = (int*)malloc(20);
for (int i = 0; i < 5; i++)
{
s1->c[i] = i;
}
//打印
for (int i = 0; i < 5; i++)
{
printf("%d ", s1->c[i]);
}
//如果不够,就扩容
int p = (struct s*)realloc(s1->c,40);
if (s1 != NULL)
{
s1->c = p;
}
else
{
return 1;
}
//释放
free(s1->c); //先释放后部分,如果先释放前面的就找不到后面的了
s1->c = NULL;
free(s1);
s1 = NULL;
return 0;
}
我们可以知道还是柔性数组的代码更好:
优点一:方便内存释放 如果结构体里面做了二次内存分配,有时可能只针对结构体进行一次释放,这样就造成内存泄漏了。 如果我们把结构体的内存以及其成员要的内存一次性分配好了,并返回给用户一个结构体指针,用户做 一次free 就可以把所有的内存也给释放掉 优点二: 这样有利于访问速度 连续的内存有益于提高访问速度,也有益于减少内存碎片
好嘞!这次的内容就先到这里了,感谢大家支持!!!