全国计算机等级考试二级教程-C语言程序设计_第13章_编译预处理和动态存储分配

free(p);//释放内存
p = NULL;//软件工程规范，释放内存以后，指针应该赋值为空

 #define _CRT_SECURE_NO_WARNINGS

 #include<stdio.h>
 #include<stdlib.h>
 //内存不可以反复释放，内存释放以后不可以引用，否则会出现垃圾数据
 //内存释放以后，指针应该赋值为空，就可以规避再次引用，以及反复释放的问题

 void check(int *px)
 {
     int i;
     for (i = ;i < ;i++)//循环遍历
     {
         if (px[i] < )//抓不及格
         {
             printf("%d\n", px[i]);
         }
     }
 }

 main()
 {
     int num;
     int i;
     scanf("%d", &num);
     printf("num=%d\n", num);

     int *p = (int *)malloc(sizeof(int)*num);

     if (p == NULL)
     {
         printf("fail");
     }
     else
     {
         printf("succes\n");
         for (i = ;i < num;i++)
         {
             p[i] = i;
             printf("%d\n", p[i]);
         }
         printf("p=%x\n", p);

         free(p);//释放内存
         p = NULL;//软件工程规范，释放内存以后，指针应该赋值为空

         printf("p=%x\n", p);//内存释放以后，指针的值并不发生变化
         printf("%d\n", p[]);//如果再次引用指针，就会出现垃圾数值
         //如果指针为空，软件测试的时候就可以快速定位错误，否则的话，就会留下软件故障的隐患
     }

     system("pause");
 }

建立动态数组，输入5个学生的成绩，另外用一个函数检查其中有无低于60，输出不及格的成绩

 #define _CRT_SECURE_NO_WARNINGS

 #include<stdio.h>
 #include<stdlib.h>

 void check(int *px)
 {
     int i;
     for (i = ;i < ;i++)//循环遍历
     {
         if (px[i] < )//抓不及格
         {
             printf("%d\n", px[i]);
         }
     }
 }

 main()
 {
     int *p = (int *)malloc(sizeof(int) * );
     int i;

     for (i = ;i < ;i++)
     {
         scanf("%d", &p[i]);
     }

     printf("\n");
     check(p);

     system("pause");
 }

malloc，calloc都是分配内存，malloc根据大小，calloc根据元素大小还有个数

malloc分配后不会初始化，calloc会自动初始化为0

realloc就是内存不够用的情况下，拓展内存。如果原来的内存后部无人使用，就直接拓展。有人使用，就重新分配，并且先复制原来内存的内容，然后回收原来的内存

malloc函数

malloc函数返回值的类型为void *，函数的调用形式为：malloc(size);

 #define _CRT_SECURE_NO_WARNINGS

 #include<stdio.h>
 #include<stdlib.h>

 main()
 {
     int num;
     int i;
     scanf("%d", &num);
     printf("num=%d\n", num);

     int *p = (int *)malloc(sizeof(int)*num);

     printf("%x\n", p);

     if (p == NULL)
     {
         printf("fail");

     }
     else
     {
         printf("succes\n");
         for (i = ;i < num;i++)
         {
             p[i] = i;
             printf("%d\n", p[i]);
         }
         free(p);
     }

     system("pause");
 }

calloc函数

calloc函数返回值的类型为void *，函数的调用形式为：calloc(n, size);

通过调用calloc函数所分配的存储单元，系统自动置初值为0

 #define _CRT_SECURE_NO_WARNINGS

 #include<stdio.h>
 #include<stdlib.h>

 main()
 {
     int num;
     int i;
     scanf("%d", &num);
     printf("num=%d\n", num);

     int *p = (int *)calloc(num, sizeof(int));

     printf("%x\n", p);

     if (p == NULL)
     {
         printf("fail");

     }
     else
     {
         printf("succes\n");
         for (i = ;i < num;i++)
         {
             p[i] = i;
             printf("%d\n", p[i]);
         }
         free(p);
     }

     system("pause");
 }

realloc函数

 #define _CRT_SECURE_NO_WARNINGS

 #include<stdio.h>
 #include<stdlib.h>

 main()
 {
     int num, addnum;
     int i;
     scanf("%d %d", &num, &addnum);
     printf("num=%d,addnum=%d\n", num, addnum);

     int *p = (int *)malloc(sizeof(int)*num);

     if (p == NULL)
     {
         printf("fail");
     }
     else
     {
         printf("succes\n");
         for (i = ;i < num;i++)
         {
             p[i] = i;
             printf("%d\n", p[i]);
         }
         //重新分配内存，如果可以拓展就拓展，否则就重新分配
         //拓展就是原来地址后面增加内存
         //不够的情况下，就回收原来的内存，并在回收之前分配一片内存，将原来的内存复制过来
         int *px = realloc((void *)p, sizeof(int)*(addnum + num));
         for (i = num;i < num + addnum;i++)
         {
             px[i] = i;
             printf("%d\n", px[i]);
         }
         free(px);
     }

     system("pause");
 }

define和const区别

 #define _CRT_SECURE_NO_WARNINGS

 #include<stdio.h>
 #include<stdlib.h>

 #define N 20

 main()
 {
     int a[N];

     //printf("%x", &N);编译器放在常量区，没有地址，无从修改

     const int num = ;//可变的常量，可以强制去掉常量的属性

     printf("%x", &num);

     system("pause");
 }

传统数组的缺点：

1 数组长度必须事先制定，且只能是常整数，不能是变量。

 #include<stdio.h>
 main()
 {
     int a[];        /* OK */

     int len = ;        /* error */
     int a[len];
 }

2 传统形式定义的数组，该数组的内存程序员无法手动释放。

在一个函数运行期间，系统为该函数中数组所分配的空间会一直存在，直到该函数运行完毕时，数组的空间才会被系统释放。

3 数组的长度一旦定义，其长度就不能再更改。

数组的长度不能在函数运行的过程中动态的扩充或缩小。

4 A函数定义的数组，在A函数运行期间可以被其他函数使用，但A函数运行完毕之后，A函数中的数组将无法再被其他函数使用。

传统方式定义的数组不能跨函数使用。

 #include<stdio.h>
 main()
 {
     int i = ;        /* 分配了4个字节，静态分配 */

     int * p = (int *)malloc();
     /*
     malloc函数只有一个形参，并且形参是整型
     4表示请求系统为本程序分配4个字节
     malloc函数只能返回第一个字节的地址
     上述语句分配了8个字节，p变量占4个字节，p所指向的内存也占4个字节
     p本身所占的内存是静态分配的，p所指向的内存是动态分配的
     */

     free(p);
     /*
     表示把p所指向的内存给释放掉
     p本身的内存是静态的，不能由程序员手动释放，p本身的内存只能在p变量所在的函数运行终止时由系统自动释放
     */
 }

动态一维数组

 #include<stdio.h>
 main()
 {
     int i;
     int len;
     int * parr;

     printf("请输入你要存放的元素的个数：\n");
     scanf("%d", &len);

     parr = (int *)malloc( * len);

     printf("请输入你要存放的元素：\n");
     for (i = ;i < len;++i)
     {
         scanf("%d", &parr[i]);
     }

     printf("一维数组的内容是：\n");
     for (i = ;i < len;++i)
     {
         printf("%d ", parr[i]);
     }
 }

动态内存和静态内存的比较：

静态内存是有系统自动分配，由系统自动释放。

静态内存是在栈分配的。

动态内存是由程序员手动分配，手动释放。

动态内存是在堆分配的。