---

我们之前的内存开辟方式有局限性 ：

空间开辟大小是固定的。
数组在申明的时候，必须指定数组的长度，它所需要的内存在编译时分配。

---

所以为了解决以上问题，我们需要学习动态内存开辟

动态内存函数

malloc

• malloc函数可以向内存申请一块连续可用的空间，并返回指向这块空间的指针
• 如果开辟成功，则返回一个指向开辟好空间的指针。
• 如果开辟失败，则返回一个NULL指针，因此malloc的返回值一定要做检查。
• 返回值的类型是 void* ，所以malloc函数并不知道开辟空间的类型，具体在使用的时候使用者自己
  来决定。
• 如果参数 size 为0，malloc的行为是标准是未定义的，取决于编译器。

int main()
{
	int* p = (int*)  malloc(10 * sizeof(int));
	if (p ==NULL)
	{
		perror("main");
		return 0;
	}
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i;
	}
	for (i = 0; i < 10; i++)
	{
		printf("%d ", *(p + i));
	}
	free(p);//回收空间
	p = NULL; //  防止指针指向的空间释放，而导致出现野指针  
}

free

专门是用来做动态内存的释放和回收的

• 如果参数 ptr 指向的空间不是动态开辟的，那free函数的行为是未定义的。

int main()
{
	int a = 10;
	int* p = &a;
	free(p);//err
	return 0;
}

• 如果参数 ptr 是NULL指针，则函数什么事都不做
• malloc 是申请空间，free是释放空间 ，也就是说malloc 和free 一般都是成对出现

calloc

• 函数的功能是为 num 个大小为 size 的元素开辟一块空间，并且把空间的每个字节初始化为0。
• 与函数 malloc 的区别只在于 calloc 会在返回地址之前把申请的空间的每个字节初始化为全0

int main()
{
	int* p = calloc(10, sizeof(int));
	if (p == NULL)
	{
	   perror("main");
		return 1;
	}
	int i = 0; 
	for (i = 0; i < 10; i++)
	{
		printf("%d ", *(p+i) );
	}
	free(p);
	p = NULL;
	return 0;
}

realloc

• realloc函数的出现让动态内存管理更加灵活。
• 有时会我们发现过去申请的空间太小了，有时候我们又会觉得申请的空间过大了，那为了合理的时
  候内存，我们一定会对内存的大小做灵活的调整。那 realloc 函数就可以做到对动态开辟内存大小
  的调整
• realloc 有可能找不到合适的空间来调整大小 ，这时候就返回NULL

int main()
{
	int* p = (int *)calloc(10, sizeof(int));
	if (p == NULL)  //开辟失败
	{
		perror("main");
		return 1;
	}
	//开辟成功
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i) = 5;  
	}
	//增容 
  int * ptr = (int *)realloc(p, 20*sizeof(int));
     // 增容成功
  if (ptr != NULL)
  {
	  p = ptr;
  }
      free(p); //释放
	  p = NULL;

	return 0;
}

第一种情况 ，realloc后面空间足够 ，返回原来的空间的数据（A）的地址

第二种情况 : realloc 后面的空间不足 ， realloc 会再开辟一块空间（B） , 将原来的空间的数据（A）拷贝到新开辟的空间（B）处，并且会返回新开辟的空间（B）的首地址 ，同时会将原来的空间（A）还给操作系统 。

常见的动态内存错误

对NULL指针的解引用操作

int main()
{
	int*p = (int*)malloc(1000000000);
	//对malloc函数的返回值，做判断
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i;
	}

	return 0;
}

malloc 开辟空间可能会失败 ，失败返回NULL,对空指针解引用，会导致非法访问
所以我们一般对malloc函数返回值进行判断

对动态开辟空间的越界访问

int main()
{
	int* p = (int*)malloc(10 * sizeof(int));
	if (p == NULL)
	{
		return 1;
	}
	int i = 0;
	//越界访问
	for (i = 0; i < 40; i++)
	{
		*(p + i) = i;
	}
	free( p); //释放
	p = NULL;
	return 0;
}

malloc 函数只是开辟了10 个整形空间 ，上述代码会出现越界访问

对非动态开辟内存使用free释放

int main()
{
	int arr[10] = { 0 };//栈区
	int* p = arr;
	free(p);//使用free释放非动态开辟的空间
	p = NULL;
	return 0;
}

使用free释放一块动态开辟内存的一部分

int main()
{
	int* p = malloc(10 * sizeof(int));
	//判断开辟成功
	if (p == NULL)
	{
		return 1;
	}
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		*p++ = i;
	}
	//释放
	free(p);
	p = NULL;

	return 0;
}

free 不完全释放空间
丢失了起始位置的地址，可能找不到这块空间 ，可能会导致内存泄漏

对同一块动态内存多次释放

int main()
{
	int* p = (int*)malloc(100);
	//使用
	//释放
	free(p);
	p = NULL;
	//...
	//释放
	free(p); // 如果参数 ptr 是NULL指针，则free什么事都不做
	return 0;
}

万一出现多次释放, 只要记得手动置成NULL ,如果参数 ptr 是NULL指针，则free函数什么事都不做,

动态开辟内存忘记释放（内存泄漏）

void test()
{
	int* p = (int*)malloc(100);
	if (p == NULL)
	{
		return;
	}

}

int main()
{
	test();
	//....
	return 0;
}

动态开辟空间有两种回收方式 ： 通过free函数主动释放 ， 整个程序结束

p指向malloc 开辟空间的起始地址 。
p是局部变量，在栈区上开辟空间 ， 出作用域就销毁
也就意味着丢失了malloc开辟空间的起始地址 ，就算后续再用free释放也无效
而且malloc开辟的空间并没有销毁，会一直吃内存，导致内存泄漏

练习

void GetMemory(char *p) //p是形参，是str的一份临时拷贝
{
p = (char *)malloc(100);
}
void Test(void)
{
char *str = NULL;
GetMemory(str);
strcpy(str, "hello world");
printf(str);
}
int main()
{
 Test():
 return 0 ;
}

str传给GetMemory函数的时候是值传递，所以GetMemory函数的形参p是str的一份临时拷贝
在GetMemory函数内部动态申请空间的地址，存放在p中，不会影响str
所以GetMemory函数返回之后，str还是NULL 。
所以strcpy会拷贝失败
其次 ，当GetMemory函数返回之后，形参p销毁而且随着p的销毁，malloc创建的空间也找不到了，导致了内存泄漏，后续再使用free也无法释放 。

---

char *GetMemory(void)
{
char p[] = "hello world";
return p;
}
void Test(void)
{
char *str = NULL;
str = GetMemory();
printf(str);
}

GetMemory 函数内部创建的数组是在栈区上创建的，p数组进入GetMemory函数生命周期开始，出GetMemory 函数生命周期结束
return p 返回 数组首元素地址（h)
也就意味着str里面存的是h的地址
但是此时p数组里的空间还给操作系统
printf调用str，来打印p数组里的内容 ， p数组里的内容很有可能被覆盖 ，（返回的地址是没有实际的意义，如果通过返回的地址，去访问内存就是非法访问内存的）
输出结果自然就是随机值

---

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

---

没有free函数释放malloc开辟的空间，可能会造成内存泄漏

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

malloc 开辟100个字节的内存空间，由str维护
strcpy函数将hello\0拷贝进malloc开辟的内存空间
strcpy函数将world\0拷贝进malloc开辟的空间 ，会失败
str 虽然记得malloc开辟空间的地址 ，但是此时malloc开辟的空间已经被free释放了，还给操作系统了，此时去访问内存就是非法访问内存的。

柔性数组

• 结构中的柔性数组成员前面必须至少一个其他成员。
• sizeof 返回的这种结构大小不包括柔性数组的内存。

struct S
{
	int n;
	int arr[0];
};
int main()
{
	struct S s = { 0 };
	printf("%d", sizeof(s)); // 输出4 
	return 0;
}

struct S
{
	int n;
	int arr[0];
};
int main()
{
	struct S s = { 0 };
	printf("%d", sizeof(s)); //输出4 
	return 0;
}

上述两种写法 ，看编译器支持哪一种

---

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

  struct S
{
	int n;//4
	int arr[0];//大小是未知
};

  int main()
  {
	  //期望arr的大小是10个整形
	  struct S* ps = (struct S*)malloc(sizeof(struct S) + 10 * sizeof(int));
	  return 0;
  }

柔性数组的使用

  struct S
{
	int n;//4
	int arr[0];//大小是未知
};

  int main()
  {
	  //期望arr的大小是10个整形
	  struct S* ps = (struct S*)malloc(sizeof(struct S) + 10 * sizeof(int));
	  ps->n = 10;
	  int i = 0;
	  for (i = 0; i < 10; i++)
	  {
		  ps->arr[i] = i;
	  }
	  struct S* ptr = (struct S*)realloc(ps, sizeof(struct S) + 20 * sizeof(int));
	  if (ptr != NULL)
	  {
		  ps = ptr;
	  }
	  free(ps);
	  ps = NULL;
	  return 0;
  }

柔性数组的优势

• 方便内存释放
• 这样有利于访问速度.

如果你觉得这篇文章对你有帮助，不妨动动手指给点赞收藏加转发，给鄃鳕一个大大的关注
你们的每一次支持都将转化为我前进的动力！！！