内存分配（Day-9）

计算机内存划分为5个区：栈区 堆区 静态区 常量区 代码区

1. 5大区：

1. 栈区：
   1.1. 函数的参数或者是局部变量存储在栈区
   1.2. 局部变量：在函数 分支 循环的{}中定义的变量
   1.3. 栈区内存的管理方式：由系统负责分配和回收
   1.4. 定义变量时分配，函数执行结束后系统回收
   1.5. 内存被系统回收后，原来存储的数据没有被清空，只是标记回收
   1.6. 栈区存储的特点：先进后出 后进先出
   1.7. 入栈：定义变量在栈区分配存储空间，出栈： 回收内存
   1.8. 栈顶：后放进去的数据在栈顶 栈底：栈区内存起始的位置
   |_______栈顶_________| 高
   |____________________| |
   |____________________| |
   |_______栈底_________| 低

2. 常量区（文字常量区）：
   2.1. 常量区的内存管理：由系统分配和回收（程序结束运行时被回收）
   2.2. 常量区的数据只能被读取，不能被修改

3. 全局变量：
   3.1. 使用关键字static修饰的变量 以及在函数外定义的变量（全局变量或者静态变量）
   3.2. 静态区的内存管理：由系统分配和回收（程序运行结束回收）
   3.3. 静态区的变量只能初始化一次，在编译时进行初始化
   3.4. 静态区的变量没有设置初始值时，默认值为：0

4. 代码区：函数运行时存储的区域
   4.1. 代码区的内存管理机制：系统负责分配和回收
   4.2. 回收：程序运行结束后

5. 堆区：
   5.1. 堆区的内存管理：开发人员负责分配与回收
   5.2. 回收：程序员自行回收
   5.3. void *malloc(size_t)：

   指定分配的存储空间的大小（字节数）， 将分配的存储空间的起始地址返回
   堆内存是使用地址操作，地址存储在对应的指针变量中
   void *malloc(<#size_t#>)
   /*
   void *：无类型指针
   malloc = memory （内存） allocation（分配）
   size 表示分配多大的存储空间，单位是字节
   */
   malloc返回的是地址，需要用指针获取

// 1. 动态分配int的空间   然后赋值    int *p = malloc(sizeof(int));    *p = 89;// 2. 在堆中存储4个整型数    int *p = malloc(sizeof(int) * 4);    for (int i = 0; i < 4; i++) {        *(p+i) = i;    }    for (int i = 0; i < 4; i++) {        printf("%d   ",*(p+i));    }//3. 在堆中存储一个人名    char *p = malloc(sizeof(char) * 20);    strcpy(p, "zhangsanfeng") ;    printf("%s  ", p);//4. 随机产生10个30--45之间的随机数，存储在堆内存中    int *p = malloc(sizeof(int) * 10);    for (int i = 0; i < 10; i++) {        *(p+i) = arc4random() % 16 + 30;    }    for (int i = 0; i < 10; i++) {        printf("%d   ",*(p+i));    }

例1：
有一个字符串，里面包含数字，提取出里面的数字，然后动态分配内存存储

    char p[] = "BJS150936";    int len = (int)strlen(p);    int count = 0;    for (int i = 0; i < len; i++) {        if (p[i] >= '0' && p[i] <= '9') {            count++;        }    }    printf("%d ",count);    int *pi = malloc(sizeof(int) * count);    int j = 0;    for (int i = 0; i < len; i++) {        if (p[i] >= '0' && p[i] <= '9') {            pi[j] = p[i] - '0';//将字符转换为数字            j++;        }    }    for (int i = 0; i < count; i++) {        printf("%d   ", pi[i]);    }

5.4. free() 函数：内存释放是标记删除
内存泄露：分配空间之后，没有回收
野指针:指向了一个已经被回收的内存
malloc函数分配完空间之后，一定要进行释放，否则产生内存泄露的问题

    int *p = malloc(sizeof(int));    *p = 20;    free(p);    printf("%d", *p); //  <---野指针:指向了一个被回收的内存    // 刚释放的内存没有被使用，所以暂时没有报错      // 打印结果是：20

5.5 其他的内存分配函数：

// 1. void  *calloc(size_t, size_t);  第一个是申请几个   第二个是数据类型的字节/*calloc = clear allocation 1. 在堆内存分配n个size字节的空间，并返回地址 2. 会将分配的存储空间中原有的数据清空*///1.1 在堆中存储5个整型数，范围是15--35之间的随机数    int *p = calloc(5, sizeof(int));    for (int i = 0; i < 5; i++) {        p[i] = arc4random() % 21 + 15;    }    for (int i = 0; i < 5; i++) {        printf("%d  ", p[i]);    }    free(p);  //  死也不能忘记释放内存呀！！！！！！  malloc  calloc都需要程序员释放的呀// 2. void  *realloc(void *, size_t);   按给定的地址及给定的大小重新分配  释放新的内存， 旧的不用    int *p = malloc(sizeof(10));    int *ps = realloc(p, 20);    printf("p = %p,  ps = %p\n", p, ps);    /* 结果：p = 0x10020dd40,  ps = 0x10020ae70 给p重新分配20个字节，地址0x10020dd40不够20个，    所以重新开辟了一块空间，分配20个给p。    不用释放p,需要释放后来分配的空间---ps ~~~~~~~~~~    */

5.6. 内存操作函数：

**初始化内存**// 1.void *memset(void *s, int, c size_t n);  从s指向的地址开始，将n个字节初始化为int c   int *p = malloc(sizeof(int));   memset(p, 0, sizeof(int)); ** 内存拷贝 **  // 2.void   *memcpy(void *dest, const void *source, size_t n);从source开始，拷贝n个字节到dest   char str1[] = "bjS140936";   char str2[] = "15";   memcpy(str1, "BJ", 2);   memcpy(str1+3, str2, 2);   printf("%s  ", str1);   // 结果：BJS150936  ** 内存比较 **  /* 3. int memcmp(const void *buf1, const void *buf2, size_t count);比较 buf1和buf2指向的内存是否相同,比较count个字节*/// 例3.1 定义两个整型指针，分别⽤malloc、calloc对其分配空间保存3个元素，malloc分配的空间⽤用memset清零，随机对数组进⾏行赋值随机范围1-3，赋值后⽤用memcmp⽐比较两个数组。如果相同打印Good!否则打印Failed...    int *p1= malloc(sizeof(int) * 3);    memset(p1, 0, sizeof(int) * 3);    int *p2 = calloc(3, sizeof(int));    for (int i = 0; i < 3; i++) {        *(p1 + i) = arc4random() % 3 + 1;        *(p2 + i) = arc4random() % 3 + 1;     }     int a = memcmp(p1, p2, sizeof(int) * 3);     printf("%d  ",a); //  a<0  也就是Failed