#include<stdio.h>
int main()
{
  int num = 10;//向内存申请了4个字节的空间
  int arr[10];//向内存申请了40个字节的空间
  return 0;
}

void* malloc (size_t size);

#include<stdlib.h>//malloc
#include<errno.h>//errno
#include<string.h>//streror
int main()
{
    // 返回值的类型是void，所以malloc函数并不知道开辟空间的类型，具体在使用的时候使用者自己来决定。
  //存放10个字节，用指针来维护，而如果是void类型，向后移动几个字节是不能确定的，所以一般不这样写，
    //通常要进行强制类型转换，这样如果对指针进行++，或者解引用操作，就知道指针向后移动几个字节和取几个字节的空间。
  int* p =(int*)malloc(INT_MAX);// INT_MAX是有符号整数最大值
    //检查
  if (p == NULL)//如果开辟失败，则返回一个NULL指针，因此malloc的返回值一定要做检查。
  {
    printf("%s\n", strerror(errno));/*打印错误信息*/
    return 1;
  }

void free (void* ptr);

#include<stdlib.h>//malloc
#include<errno.h>//errno
#include<string.h>//streror
int main()
{
  //void* p = malloc(40);//向内存申请了40个空间
  int* p = (int*)malloc(40);
  int* ptr = p;//若不进行此步，后面的free(p);是错误的，因为p本来指向的是空间的起始位置，但是前面的循环使p指向了后半部分空间，使空间不能完全释放
  //检查
  if (p == NULL)//如果开辟失败，则返回一个NULL指针，因此malloc的返回值一定要做检查。
  {
    printf("%s\n", strerror(errno));/*打印错误信息*/
    return 1;
  }
  //使用
  int i = 0;
  for (i = 0; i < 10; i++)
  {
    *ptr = i;
    ptr++;
  }
  //释放
  free(p);
  p = NULL;//为了避免通过p非法访问已经释放的空间，这里将p置为空指针
  return 0;
}

void* calloc (size_t num, size_t size);

#include<stdio.h>//perror
#include<stdlib.h>//calloc
//calloc函数
int main()
{
  //40个字节-10个整型
  //malloc（40）
  int* p = (int*)calloc(10, sizeof(int));
  //检查
  if (p == NULL)
  {
    perror("calloc");
    return 1;
  }
  int i = 0;
  for (i = 1; i < 10; i++)
  {
    *(p + 1) = i;
  }
  //释放
  free(p);
  p = NULL;
  return 0;
}

void* realloc (void* ptr, size_t size);

#include<stdlib.h>//realloc
int main()
{
  int* p = (int*)malloc(40);
  //检查
  if (p == NULL)
    return 1;
  //使用
  int i = 0;
  for (i = 0; i < 10; i++)
  {
  *(p + i) = i;
  }
  //
  for (i = 0; i < 10; i++)
  {
    printf("%d ", *(p + i));
  }
  //增加空间
  int* ptr = (int*)realloc(p, 80);//将p开辟的空间改为80个字节
  //当realloc开辟失败的时候，返回的是NULL，所以也需要检查
  if (ptr != NULL)
  {
    p = ptr;//为了方便管理，下面还使用p，引入ptr
    ptr = NULL;
  }
  //使用
  for (i = 10; i < 20; i++)
  {
    *(p+i) = i;
  }
  //释放
  free(p);
  p = NULL;
  return 0;
}

#include<stdio.h>
#include<stdlib.h>//malloc
int main()
{
    int *p = (int *)malloc(INT_MAX);//当内存开辟失败时，malloc会返回NULL
    *p = 20;//如果p的值是NULL，就会有问题
    free(p);
}

#include<stdio.h>//perror
#include<stdlib.h>//malloc
#include<limits.h>//INT_MAX
int main()
{
    int* p = (int*)malloc(INT_MAX);//当内存开辟失败时，malloc会返回NULL
    if (p == NULL)
    {
        perror("malloc");
        return 1;
    }
    else
    {
        *p = 20;//如果p的值是NULL，就会有问题
    }
    free(p);
    p = NULL;
    return 0;
}

// 越界访问
#include<stdio.h>
#include<stdlib.h>//malloc
int main()
{
    int* p = (int*)malloc(20);//开辟20个字节的空间，相当于5个int
    if (p == NULL)
        return 1;
    //使用
    int i = 0;
    for (i = 0; i < 20; i++)//越界访问了第5个int元素（下标为4）后面的空间
    {
        *(p + i) = i;
        //p[i] = =i;
    }
    for (i = 0; i < 20; i++)
    {
        printf("%d ", p[i]);
    }
    //释放
    free(p);
    p = NULL;
    return 0;
}

int main()
{
  int num = 10;//num是非动态开辟内存
  int* p = #
  //……
  free(p);
  p = NULL;
  return 0;
}

//使用free释放一块动态开辟内存的一部分
int main()
{
  int* p = (int*)malloc(40);
  if (p == NULL)
    return 1;
  int i = 0;
  for (i = 0; i < 5; i++)
  {
    //*(p + i) = i;
    *p = i;
    p++;//当循环了五次后，p指向了中间的元素，而不是起始位置
  }
  //在释放时p指向的不再是动态内存开辟的起始位置
  free(p);
  p = NULL;
  return 0;
}

int main()
{
  int* p = (int*)malloc(40);
  if (p == NULL)
    return 1;
  int i = 0;
  for (i = 0; i < 5; i++)
  {
    *(p + i) = i;
  }
  //释放
  free(p);
  ///p = NULL;
  free(p);//第二次释放同一块内存空间，err，
          //但如果前面的p置为空，程序可以正常运行
  return 0;
}

//函数会返回动态开辟空间的地址，记得在使用之后返回
int* get_memory()
{
  int* p = (int*)malloc(40);
  //……
  return p;
}
int main()
{
  int* ptr = get_memory();
  //使用
  //释放，调用时很可能忘记释放
  free(ptr);
  ptr = NULL;
  return 0;
}

实际上普通的局部变量是在栈区分配空间的，栈区的特点是在上面创建的变量出了作用域就销毁。
但是被static修饰的变量存放在数据段（静态区），数据段的特点是在上面创建的变量，直到程序结束才销毁
所以生命周期变长。