动态内存分配_c语言学习笔记

一. 传统数组的缺点：  

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;}