一. 传统数组的缺点:
1. 数组的长度事先指定,且只能是常整数,不能是变量。例如:
int a[5]; //这行代码正确
int len =5; int a[len]; //这个代码error
2.
传统形式定义的数组,该数组的内存程序员无法手动释放。
数组一旦定义,系统为该数组分配的存储空间就会一直存在,
除非数组所在的函数运行结束。
在一个函数运行期间,系统为该函数中数组所分配的空间会一直存在,直到
该函数运行完毕时,数组的空间才会释放。
3.
数组的长度一旦定义,其长度就不能更改。数组的长度不能再函数运行的过程中动态的扩充或缩小。(传统数组的问题是静态内存的问题)
4.
A
函数定,在
A
函数运行期间可以被其
义的数组
他函数使用,但
A
函数运行完毕之后,
A
函数中的数组将无法再被其他函数使用。
传统方式定义的数组不能跨函数使用,例如:
#include <stdio.h>
#include <stdlib.h>
void g(int * pArr, int len) {
pArr[2] = 88;//pArr[2] = a[2]
}
void f(void) {
int a[5] = {1,2,3,4,5};
//数组名a 就是首地址
g(a,5);
printf("%d\n", a[2]);
/*
20个字节的存储空间程序员无法手动编程释放,
它只能在本函数运行完毕时由系统自动释放
*/
}
int main(void) {
f();
printf("Hello world!\n");
return 0;
}
二. 为什么需要动态分配内存
动态数组很好的解决了传统数组的缺陷。传统数组也叫静态数组。
三. 动态内存分配举例_动态数组的构造, 代码说明:
//malloc 是memory allocate的缩写
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#include<malloc.h>
int main(void) {
time_t t;//定义一个时间变量
t=time(NULL);
char *time;//定义一个字符串用来保存获取到的日期和时间
time=ctime(&t);//赋值
printf("%s\n",time);//输出就可以了
//getch();
printf("Hello world!\n");
int i = 5;//分配了4个字节,静态分配
int * p = (int *)malloc(4);//强制类型转换,为什么??
//因为malloc只能返回第一个字节的地址,而p指向的地址不知道所占几个字节。
*p = 5;
// *p 代表的就是一个int变量,
//只不过*p这个整形变量的内存分配方式和int i= 5;内存分配方式不同。
free(p);//free(p)表示把p所指向的内存释放掉。
//p本身的内存是静态的,无法由程序员释放。
//p本身的内存只能在p变量所在的函数运行终止时由系统自动释放
printf("同志们好!\n")
return 0;
}
使用 malloc函数的注意事项:
1. 要使用malloc函数,必须添加malloc.h这个头文件。
2. malloc函数只有一个形参,并且形参是整数类型。
3. malloc(4)中的4表示请求系统为本程序分配4个字节。
4. malloc函数只能返回第一个字节的地址,
5. 12行分配了8个字节,p变量占4个字节,p指向的内存也占4个字节。
6. p本身所占的内存是静态分配的, p所指向的内存是动态分配的。
代码说明2:
#include<stdio.h>
#include<stdlib.h>
void f(int * q)//q 是p的copy
{
//*p =200;//error
//q = 200;// error
//**q =200; error
*q = 200;
free(q);//把q所指向的内存释放掉
}
int main(void)
{
int * p = (int*)malloc(sizeof(int));
//sizeof(int)返回值是int所占的字节数
*p = 10;
printf("%d\n", *p);//结果是10
f(p); //p 是int *类型,
printf("%d\n", *p);//结果是200
printf("Hello world!\n");
return 0;
}
int a[5];//如果int占4个字节,则本数组总共包含了20个字节, 每四个字节被当做了一个int变量来使用
代码说明3:
#include<stdio.h>
#include<stdlib.h>
int main(void) {
int a[5];//如果int占4个字节,则本数组总共包含了20个字节,
a[0]=1;
printf("%d\n",a[0]); //每四个字节被当做了一个int变量来使用
int len;
int * pArr;
int i;
printf("请输入你要存放的元素的个数:");
scanf("%d", &len);
pArr = (int *)malloc(4*len);
//其功能类似定义了 intpArr[len];
//动态的构造了一维数组。该一维数组的长度是len,该数组名是pArr,
//该数组每个元素的类型是int类型
//假定len=5,则分配20个字节,但是pArr 指向了前四个字节
//*pArr 代表了前四个字节的变量的内容
//对一维数组进行操作,对动态一维数组进行赋值
for(i = 0; i<len; ++i)
scanf("%d", &pArr[i]); //对一维数组进行输出
printf("一维数组的内容是:\n");
for(i = 0; i<len; ++i)
printf("%d\n", pArr[i]);
free(pArr);//释放掉动态分配的数组
printf("Hello world!\n");
return 0;
}
运行的结果为:
这个程序体现不出动态内存的跨函数使用。
四. 静态内存和动态内存的比较
静态内存是由系统自动分配,由系统自动释放。静态内存是在栈(可以学“组成原理”)中分配的。
动态内存是由程序员手动分配,手动释放。
动态内存是在堆分配的,所以可以跨函数使用。
多级指针(为了讲跨函数使用内存):例
#include<stdio.h>
#include<stdlib.h>
int main(void) {
int i=10;
int * p = &i;
int ** q = &p;
int *** r = &q;
printf("%d,%d,%d,%d\n", i, *p,**q, ***r);
//结果是 10 10 10 10
printf("\nHello world!\n");
return 0;
}
五. 跨函数使用内存的问题
1. 静态函数不能跨函数内存
#include<stdio.h>
#include<stdlib.h>
void f(int ** q)
//q也是个指针变量,无论q是什么类型的指针变量,都只占4个字节
{
int i=5;
//*q 等价于p, q和**q都不等价于p
*q = &i;
}
int main(void) {
int * p = NULL;
f(&p);
printf("%d\n",*p);//本语句语法没有问题,但是逻辑有问题
printf("Hello world!\n");
return 0;
}
注释:当
main
函数调用
f
函数时,里面有
i
变量,但是
f
函数一旦执行结束,
i
变量的地址便释放,因此不能再对其进行读写,但是红色字体标出的
*p
,还是对
i
变量进行了读的操作。
2. 动态内存跨函数使用
#include <stdio.h>
#include <stdlib.h>
void f(int ** q) {
*q= (int*)malloc(sizeof(int));//这样写可移植性较强
//动态内存在堆里面分配,执行完毕没有出栈的概念。所以内存还在
//sizeof(数据类型)返回值是该数据类型所占的字节
//等价于 p =(int *)malloc(sizaof(int));
//q= 5;
//*q = 5;//*q 就是p,p存放的是整型变量的地址,该语句错误
**q =5;//正确
}
int main(void) {
int* p;
f(&p);
printf("%d\n", *p);//*p指向的内存还存在
printf("\n该例子说明在f函数中造出的一块空间,在main函数中可以使用.");
return 0;
}