C语言基础 动态内存分配

一.为什么需要动态内存分配

• 本质上是传统内存分配方式的缺点,此处以数组为例

变长数组的限制参见:https://www.cnblogs.com/asasooo998/p/9462968.html

传统数组被称为静态数组

//####################################################################################################################

①传统数组的长度必需事先确定,且只能是常整数,不能是变量

//注:在C99中提出变长数组,即允许使用变量指定数组长度
//但是变长数组的长度在创建后就是不可变的,即仍遵循③
int len=5;
int a[len]={1,2,3,4,5};
printf("%d\n",a[2]);
//报错:[Error] variable-sized object may not be initialized
int len=5;
int a[len];
a[0]=1,a[1]=2,a[2]=3,a[3]=4,a[4]=5;
printf("%d\n",a[2]);//结果:3
//变长数组的定义和赋值必需分成2个命令,不能1次完成
//变长数组还有很多其他限制,因此较少被使用

//####################################################################################################################

②传统数组占用的内存不能手动释放,只能等到函数运行完毕再由系统自动释放

//

③数组的长度一旦确定,就不能更改

//####################################################################################################################

④由A函数定义的数组,在A函数运行期间可以被其他函数使用
但A函数运行完毕后,其中的数组就无法被其他函数使用(因为已被释放)
即静态数组无法跨函数调用

//####################################################################################################################

动态数组很好地解决了静态数组的这4个缺陷

二.语法

• malloc()和free()这2个库函数都在<malloc.h>中

1.动态分配内存:

• 意思是m(emory) alloc(ate)(内存分配)

请求操作系统分配指定字节数的内存给本程序:void * <ip>=malloc(<i>);
  //参数说明:
    i:请求操作系统分配的内存的字节数
    ip:如请求成功,返回请求的首字节的内存地址(俗称"干地址");如请求不成功,返回NULL
	  /*应进行强制类型转换(见下)以提高可读性,不过实际上无进行转换也合法
	  不过,C++要求必须进行强制转换,因此如果希望兼容C++,就需要进行强制转换
	  返回的内存是匿名的,即不会为这些内存赋名,只能通过首字节地址访问
	  从ANSI C开始,返回指向void的指针;之前通常返回指向char的指针(因为char类型占用1B)*/

请求分配内存并进行强制类型转换:<type>* <a>=(<type>*)malloc(<i>);
  /*右侧的<type>*表示把malloc()返回的地址强制转换成type类型变量的地址
  即malloc()返回第1个字节的地址,由<type>*进行强制转换告知实际每个元素占用的字节数x
  同时i确定总共数组的字节数,即得i/x为数组中元素数
  或者说,<type>*把返回的1B的地址转换成xB的地址,这样a就指向第1个xB,a+i指向第i+1个xB...
  a[0]就是第1个元素,a[i]是第i+1个元素
  这样就生成了1个包含i/x个type类型元素的数组,但实际上a中只有第1个内存地址
  左侧定义了1个指针变量
  这样1条指令将分配8+i个字节的内存,其中8B给a,iB给a指向的数组
    这里的数组实质上就是分配到的iB的连续内存空间
    a占用的8B是静态分配的,数组占用的iB是动态分配的*/

//实例:
#include <malloc.h>
#include <stdio.h>
int main(void) {
	int i=5;//静态分配,分配了4B内存
	int len;
	scanf("%d",&len);//输入:100
	int* p=(int*)malloc(len);//动态分配,分配了100B
	//强制转换成int*类型,故每个元素占4B,总共25个元素
	//再加上p占用的8B(这8B是静态分配的),本行共分配了108B内存
    p[0]=11,p[1]=3,p[2]=10,p[3]=5;
	printf("%d,%d,%d\n",p[0],*p,p);//结果:11,11,1774560
	printf("%d\n",p[3]);//结果:5
	printf("%d,%d\n",p+3,*(p+3));//结果:1774572,5
    return 0;
}

2.释放内存:

free(<a>):释放指定变量指向的内存
  //注:a本身占用的内存不会被释放
  //每动态分配了1次内存,就必需有对应的1次free()
  //一些操作系统会在程序结束时自动释放动态分配的内存,另一些则不会,为谨慎起见,应统一使用free()手动释放
  //只能释放动态分配的内存(malloc()/calloc()分配的内存),不能释放其他内存
  //参数说明:
    a:用于指定变量的指针
      //和malloc()返回的指针可以不同,但二者必须指向同一位置

//实例:
#include <malloc.h>
#include <stdio.h>
int main(void) {
	int * p=(int*)malloc(20);
	p[0]=11,p[1]=22;
	printf("%d,%d,%d\n",p[0],*p,p);//结果:11,11,9901024
	printf("%d\n",p+1);//结果:9901028
	free(p);//仅释放掉p指向的20B内存
	        //p本身占用的8B是静态分配的,无法手动释放
	printf("%d,%d,%d,%d\n",p[0],p,p[1],p+1);//结果:9896272,9901024,0,9901028
	return 0;
}

//####################################################################################################################

如果某次malloc()后没有进行free(),这部分动态分配的内存将不会被释放,当指向这部分内存的指针变量因超过存储期而被销毁后,程序将无法再
访问这部分内存,这种情况称为"内存泄漏"(Memory Leaking).如果大量发生内存泄漏,就可能耗尽内存

三.动态内存与静态内存
1.静态内存与动态内存的比较:

静态内存由操作系统分配/释放,是在栈分配的
动态内存是手动分配/释放的,是在堆分配的

2.静态变量与动态变量的比较:

//动态变量可以跨函数调用:
#include <stdio.h>
#include <malloc.h>

int* f(void) {
	int* p=(int*)malloc(12);
	p[0]=5;
	return p;
}

int main(void) {
	int* q;
	q=f();
	printf("%d\n",*q);//结果:5
	free(q);
    return 0;
}
//结果正确,并且返回的地址是安全的,因为使用时该内存空间还未被释放

//####################################################################################################################

//静态变量不能跨函数使用:
#include <stdio.h>

int* f(void) {
	int p[3];
	p[0]=5;
	return p;
}

int main(void) {
	int* q;
	q=f();
	printf("%d\n",*q);//结果:5
    return 0;
}
//报错:[Warning] function returns address of local variable [-Wreturn-local-addr]
//虽然结果是正确的,但返回的地址是不安全的,如果该内存空间已被其他程序使用,结果就可能错误

//####################################################################################################################

//更准确的说法是:
函数中的静态变量,在该函数运行期间可被其他函数使用
但该函数运行完毕后,其中的静态变量就无法被其他函数使用
  //或者说:在所在的函数运行完毕后,静态变量的地址是不安全的
  //因为该内存空间已被释放,所以其中的内容可能已被其他程序修改
  //不过从语法上,仍可通过地址范围该内存空间
而动态变量在所在的函数执行完毕后仍可被其他函数使用