动态内存分配_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;
}