malloc向内存申请一块连续可用的空间,当然,申请完后要归还给操作系统,这时候就要使用free函数归还了;
eg:
int main()
{
//开辟一个大小为4*整型个字节的空间大小
int* p = (int*)malloc(4 * sizeof(int));
//如果开辟空间失败,p为空指针,断言判断p是否为空,为空则报错
assert(p);
int i = 0;
//赋值并打印
for (i = 0; i < 4; i++)
{
//两种都可以
//*(p + i) = i;
//printf("%d ", *(p + i));
p[i] = i;
printf("%d ", p[i]);
}
//归还空间
free(p);
//并把p置空,如果不置空,p将成为野指针
p = NULL;
return 0;
}
eg:
int main()
{
//向空间申请sizeof(int)*10个空间,并初始化为0
int* p = (int*)calloc(10, sizeof(int));
assert(p);
int i = 0;
for (i = 0; i < 10; i++)
{
printf("%d ", *(p + i));
}
free(p);
p = NULL;
return 0;
}
(1) 情况1:原有空间之后有足够大的空间
当是情况1的时候,要扩展内存就直接原有内存之后直接追加空间,原来空间的数据不发生变化;而且realloc返回的是旧地址p;
(2)情况2:原有空间之后没有足够大的空间
当是情况2的时候,原有空间之后没有足够多的空间时,扩展的方法是:在堆空间上另找一个合适大小的连续空间来使用。这样函数返回的是一个新的内存地址ptr.
eg:
int main()
{
//先开辟一块大小为10*sizeof(int)的空间
int* p = (int*)malloc(10 * sizeof(int));
assert(p);
int i = 0;
for (i = 0; i < 10; i++)
{
*(p + i) = i + 1;
printf("%d ", *(p + i));
}
//拓展p的空间,拓展后的大小为20 * sizeof(int)
int* ptr = (int*)realloc(p, 20 * sizeof(int));
assert(ptr);
p = ptr;
for (i = 10; i < 20; i++)
{
*(p + i) = i + 1;
printf("%d ", *(p + i));
}
free(p);
p = NULL;
return 0;
}
void GetMemory(char *p)
{
p = (char *)malloc(100);
}
void Test(void)
{
char *str = NULL;
GetMemory(str);
strcpy(str, "hello world");
printf(str);
}
(1)调用GetMemory函数时,str的传参为值传递,将空指针传过去(是将str变量本身传过去),p是str的临时拷贝,所以在GetMemory函数内部将动态开辟空间的地址存放在p中的时候,不会影响str。所以在GetMemory函数返回之后,str仍然是NULL指针。strcpy就会调用失败,原因是对NULL的解引用操作,程序会崩溃。 (2)GetMemory函数内向malloc申请的空间没有机会释放,造成内存泄漏。
改造1:
//返回一个指针
char* GetMemory()
{
char* p = (char*)malloc(100);
return p;
}
void Test(void)
{
char* str = NULL;
//用指针接收
str = GetMemory();
strcpy(str, "hello world");
printf(str);
free(str);
str = NULL;
}
int main()
{
Test();
return 0;
}
改造2:
//用二级指针接收
void GetMemory(char** p)
{
*p = (char*)malloc(100);
}
void Test(void)
{
char* str = NULL;
//传地址过去
GetMemory(&str);
strcpy(str, "hello world");
printf(str);
free(str);
str = NULL;
}
int main()
{
Test();
return 0;
}
返回栈空间地址问题:
GetMemory函数内部创建的数组是临时的,虽然返回了数组的起始地址给了str,但是数组的内存出了GetMemory函数就被回收了,而str依然保存了数组的起始地址,这时如果使用str,str就是野指针
char* GetMemory(void)
{
char p[] = "hello world";
return p;
}
void Test(void)
{
char* str = NULL;
str = GetMemory();
printf(str);
}
int main()
{
Test();
return 0;
}
结构中的最后一个元素允许是未知大小的数组,这就叫做『柔性数组』成员,例如:
typedef struct st_type
{
int i;
int a[0];//柔性数组成员
}type_a;
也可以写成:
typedef struct st_type
{
int i;
int a[];//柔性数组成员
}type_a;
(1)结构中的柔性数组成员前面必须至少一个其他成员。 (2)sizeof 返回的这种结构大小不包括柔性数组的内存。 (3)包含柔性数组成员的结构用malloc ()函数进行内存的动态分配,并且分配的内存应该大于结构的大小,以适应柔性数组的预期大小。
在这里举两个例子,一个是使用柔性数组,第二个是使用结构体中指针方案,两个效果一样,但是也有所差异,我们可以对比一下;
柔性数组的方案(方案1):
struct S
{
int a;
char ch;
int arr[]; //柔性数组成员
};
int main()
{
//为柔性数组开辟空间
// 8 + 40 = 48
struct S* ps = (struct S*)malloc(sizeof(struct S) + 10 * sizeof(int));
assert(ps);
int i = 0;
for (i = 0; i < 10; i++)
{
ps->arr[i] = i + 1;
printf("%d ", ps->arr[i]);
}
printf("\n");
ps->a = 10;
ps->ch = 'w';
printf("%d\n%c\n", ps->a, ps->ch);
free(ps);
ps = NULL;
return 0;
}
结构体中指针方案(方案2):
struct S
{
int a;
char ch;
int* arr;
};
int main()
{
//为结构体开辟空间
struct S* ps = (struct S*)malloc(sizeof(struct S));
assert(ps);
//为结构体中的数组指针开辟空间
struct S* ptr = (int*)malloc(10 * sizeof(int));
assert(ptr);
ps->arr = ptr;
int i = 0;
for (i = 0; i < 10; i++)
{
ps->arr[i] = i + 1;
printf("%d ", ps->arr[i]);
}
free(ptr);
free(ps);
ptr = NULL;
ps = NULL;
return 0;
}
以上两种方案的效果都一样,但是方案1,malloc一次,free一次,容易维护空间,不易出错;而且malloc次数少,内存碎片就会较少,内存的使用率就会较高一些;
方案2,malloc两次,free两次,维护难度加大,容易出错;而且malloc次数多,内存碎片就会增加,内存的使用率就下降了;