C语言学习笔记(十一) －内存管理 Storage

内存操作

/*
 void指针类型
 定义指针变量时不指定它指向哪一种类型，即它可以通过强制类型转换指向任意一种数据类型

 内存操作：将实参指向的类型忽略，全部按照字节处理
 strcpy
 memcpy(void *dest,void *src,lenth);
 memcmp()
 memset(void *dest,int ch,lenth);
 memset(str,' ',sizeof(str));
 */

#include 
#include 
int main(void)
{
    int arr1[]={1,2,3,4,5,6};
    int arr2[]={11,22};

    int len1=sizeof(arr1);
    int len2=sizeof(arr2);


    //将arr1拷贝到arr2
    memcpy(arr2,arr1,len1>len2?len2:len1);
    for (int i=0; i<sizeof(arr2)/sizeof(arr2[0]); i++) {
        printf("%d ",arr2[i]);
    }
    printf("\n");


    char str[20]={'\0'};
    memset(str,'*',sizeof(str)-1);
    puts(str);

    //将｛1，2，3，4，5，6｝变为｛1，2，0，0，0，6｝
    memset(arr1+2,0,12);//3个字节
    for (int i=0; i<sizeof(arr1)/sizeof(arr1[0]); i++) {
        printf("%d ",arr1[i]);
    }
    printf("\n");


    return 0;
}

内存回收

/*

 数组长度固定，可以定义数组时指定长度，可以通过初始化指定长度
 也可以输入整型值或定义宏指定长度

 若数组长度不确定，需要动态的内存申请
 malloc 申请
 free   释放
 void *malloc(unsigned size);参数是申请的字节数，返回值成功申请空间的首地址或NULL;
 在申请完空间后，必须判断是否申请成功，若申请失败则结束程序！

 void free(void *) 释放申请的内存
 使用步骤: 1.申请空间
 2.判断是否申请到空间
 3.回收空间
 4.置空空间
 */

#include 
#include 
#include 
int main(void)
{
    int n;
    scanf("%d",&n);

    //申请n个整型，将申请的首地址赋给整型指针变量p
    int *p= (int *)malloc(n*sizeof(int));

    //判断是否申请成功
    if (NULL== p) {
        printf("内存不足！\n");
        exit(0); //结束当前的程序
    }
    for (int i=0; i1;
    }

    //释放p指针
    free(p); //释放的是申请时的首地址，申请多少完全释放多少
    p=NULL; //释放结束将p置空NULL,更安全
    if (p!=NULL) {
        p[0]=12;
        printf("p[0]=%d\n",p[0]);
    }

    return 0;
}

申请n个字符空间，输入一个字符串，再将字符串输出

/*
   申请n个字符空间，输入一个字符串，再将字符串输出
 */

#include 
#include 
#include 
int main(void)
{
    int n;
    scanf("%d",&n);

    //申请n个整型，将申请的首地址赋给整型指针变量p
    int *p= (int *)malloc(n*sizeof(int));
    if (NULL== p) {
        printf("内存不足！\n");
        exit(0); //结束当前的程序
    }
    for (int i=0; i1;
    }

    //释放p指针
    free(p); //释放的是申请时的首地址，申请多少完全释放多少
    p=NULL;
    if (p!=NULL) {
        p[0]=12;
        printf("p[0]=%d\n",p[0]);
    }

    char *str=(char *)malloc(n*sizeof(char));
    if (NULL==str) {
        exit(0);
    }
    getchar();
    fgets(str,n,stdin);
    str[n-1]='\0';
    puts(str);
    str=NULL;
    free(str);

    return 0;
}

内存缩小

/*

 void *calloc(size_t num,size_t size)
 void *realloc(void *old,size_t newsize);
    若申请空间过大，需要缩小
 */

#include 
#include 
#include 

int main(void)
{
    char *str=(char*)calloc(20,sizeof(char));
    if (NULL==str) {
        printf("内存不足！\n");
        exit(0);
    }
    fgets(str,20,stdin);
    str[19]='\0';
    puts(str);
    //free(str);
    //str=NULL;

    //若申请空间过大，需要缩小
    realloc(str,strlen(str)+1);
    puts(str);
    free(str);
    str=NULL;
    return 0;
}

内存自动申请

/*

  申请的数组长度正好放下输入的值
  当不够用时，自动申请， 每一次申请5个空间
 */

#include 
#include 
#include 

int main(void)
{


    char *str=NULL;
    int size=5;//最少一次性申请5个空间
    char c=0;

    int i=0;
    str=(char *)realloc(NULL,size);
    if (NULL==str) {
        exit(0);
    }
    while (1) {
        c=getchar();
        str[i++]=c;
        if (i>=size) {
             str=(char *)realloc(str,size+=5);//每一次申请5个
            if (NULL==str) {
                exit(0);
            }
        }
        if ('#'==c) {
            break;
        } 
    }
    str=(char *)realloc(str,i+1);
    str[i]='\0';
    puts(str);
    free(str);
    str=NULL;
    return 0;
}

练习

/*
 编写一个函数，读取一系列整型数据，把这些值存储在一个动态分配的数组中，数组的第1个数会记录存储数据的个数。
 1 23
 10  23 43 66 1 556 23 67 46 789 43
 */


#include
#include
int main()
{
    int size = 5;
    int *arr = (int *)realloc(NULL,(size+1)*sizeof(int));
    if(NULL == arr)//将常量或表达式写在==的前面更安全
    {
        puts("Error!");
        exit(0);
    }

    puts("请输入数据，0为结束点");
    int num = 0;
    arr[0] = 0;
    while(1)
    {
        //判断申请的空间还是否够放数据
        if(size <= arr[0])
        {
            arr = (int *)realloc(arr,(size=size+6)*sizeof(int));
            if(arr == NULL)//if(i=3)
            {
                puts("Error!");
                exit(0);
            }
        }
        scanf("%d",&num);
        if(num == 0)
            break;
        arr[++arr[0]] = num;
    }
    //最后根据实际的数据个数调整空间
    arr = (int *)realloc(arr,(arr[0]+1)*sizeof(int));

    for(int i=0;i<=arr[0]; i++)
        printf("%d ",arr[i]);
    printf("\n");
    free(arr);
    arr = NULL;

    return 0;
}