0


【动态内存管理】malloc&calloc和realloc和笔试题和柔性数组

0 为什么存在动态内存管理?

char str[20]={0];
int arr[20]={0};

上述的空间开辟的方式有两个特点:

  1. 空间开辟空间的大小是固定的
  2. 数组在申明的时候必须指定数组空间的大小,它在编译时分配所需要的内存

但是如果我们所需要的空间大小在程序编译时并不确定,而是到程序运行起来的时候才能知道,那上述的空间开辟的方式就不适合了,动态内存管理就应运而生。

定义局部变量开辟的内存和动态内存开辟的内存的区别:

  • 开辟空间的位置:
  • 定义局部变量开辟的空间:栈上随机位置
  • 动态申请的空间: 堆上连续位置
  • 释放:
  • 定义局部变量开辟的空间:出代码块自动销毁
  • 动态申请的空间:最好是程序员手动释放

1 malloc函数

函数原型:void malloc(size_t size)*

参数说明:size为要分配内存空间的大小,单位是字节


#include<stdio.h>
#include<stdlib.h>
#include<limits.h>
int main()
{
    //函数原型:void* malloc(size_t size)
    //向内存申请了40个字节的空间:
    //如果申请成功返回这块空间的首地址
    //如果申请失败返回空指针NULL
    int* p1 = (int*)malloc(40);//这个开辟成功
    int* p2 = (int*)malloc(INT_MAX+1);//这个开辟失败
    //后面使用这块空间时会改变p的指向,所以用ptr保留这块空间的起始地址
    int* ptr = p1;
    //检验指针p的有效性:检测内存申请结果的返回值是否为NULL
    if (p· == NULL)
    {
        perror("malloc");//malloc: Not enough space
        exit(-1);
    }
    //开辟了40个字节,也就是10个int类型变量的大小
    for (int i = 0; i < 10; i++)
    {
        *(p·++) = 0;
    }
    //释放ptr指针所指向的那块空间,但是ptr仍然保留着动态申请的那块空间的起始地址
    free(ptr);
    //让ptr指向空,使他失去对动态申请的那块空间的起始地址的记忆
    ptr = NULL;

    p=NULL;
    return 0;
}

当我们不手动释放动态内存开辟的空间:

  • 如果程序结束,动态申请的内存由OS自动回收
  • 但是如果程序始终不结束,动态内存申请的那块空间不会自动释放,就会造成内存泄漏问题。 (程序结束肯定会自动释放动态申请的内存,不然内存肯定会越写越少,谁还敢写代码;但是当这块空间占用的时间太长,而且这块空间开辟的比较大,就会比较吃内存)

2 calloc函数

函数原型:void calloc(size_t num,size_t size)*

参数说明:num是要分配size字节大小的空间的元素个数

malloc 和 calloc 的区别: calloc在申请内存空间的同时将这块空间初始化为0了


int main()
{
    //函数原型: void* calloc(size_t num,size_t size)
    //元素个数:10
    //每个元素所占的字节数:sizeof(int)
    int* p = (int*)calloc(10, sizeof(int));
    int* ptr = p;
    if (p == NULL)
    {
        perror("calloc");
        exit(-1);
    }
    for (int i = 0; i < 10; i++)
    {
        printf("%d\t", *(p++));
    }
    free(ptr);
    ptr = NULL;
    p = NULL;
}

3 realloc函数

有了realloc函数,我们就可以已经malloc或calloc开辟好且对容量不满意的空间进行重新调整。(调整:调大调小均可)

重新分配内存空间函数:void realloc(void ptr,size_t size)**

参数说明:ptr为指向那块需要重新分配内存空间的那块空间,size为需要重新分配的空间大小,单位是字节。

下面以扩容为例:

int main()
{
    int* p = (int*)malloc(40);
    if (p == NULL)
    {
        perror("malloc");
        exit(-1);
    }
    for (int i = 0; i < 10; i++)
    {
        *(p + i) = i;//p没有改变指向
    }
    //希望放20个元素,空间不够,考虑用realloc扩容
    int p = (int*)realloc(p, 80);//error,万一realloc扩容失败,p接收到的是空指针,把原来p的指向覆盖(弄丢)了

    //函数原型:void* realloc(void* ptr,size_t size)
    //ptr:一个指针,指针指向的是扩容的空间的起始地址
    //size:扩容成功后希望得到的字节数
    int* temp = (int*)realloc(p, 80);//bingo
    if (temp != NULL)
    {
        p = temp;
    }
    free(p);
    p = NULL;

    return 0;
}

realloc调整空间:

  1. 如果要缩小空间:则在原空间上截取相应长度的空间,并返回原的首地址(也就是等于p)
  2. 如果是扩大空间,分以下3种情况:
  • 如果原空间在内存中的位置能够开辟出扩容后的所需要的空间大小,就相应开辟,并返回新空间的起始地址。
  • 如果原空间在内存中的位置不能够开辟出扩容后所需要的空间大小,OS就会在堆内存中找一块足够容纳所需空间大小的一块新空间,将原空间里的值复制到新空间,并返回新空间的起始地址
  • 如果在堆内存中的任意位置都不够开辟所需要的内存空间大小,则返回空指针。

4 常见的动态内存错误


    int main()
    {
        //way1:对NULL指针进行解引用
        int* p = (int*)malloc(INT_MAX + 1);
        //直接使用//error

        //way2:越界访问
        int* p = (int*)malloc(40);
        if (p == NULL)
        {
            perror("malloc");
            exit(-1);
        }
        for (int i = 0; i < 11; i++)//error
        {
            *(p + i) = i;
        }

        //way3:使用free函数释放非动态申请的内存
        int a = 10;
        int* p = &a;
        free(p);//error
        p = NULL;

        //way4:使用free函数释放动态申请的内存的一部分
        int* p = (int*)malloc(40);
        if (p == NULL)
        {
            perror("malloc");
            exit(-1);
        }
        for (int i = 0; i < 11; i++)//error
        {
            *p = i;
            p++;
        }
        free(p);//error
        p = NULL;

        //way5:对同一块动态申请的内存多次释放
        free(p);
        free(p);
        p = NULL;

       //way6:忘记释放动态申请的内存

        return 0;
    }

5 2道经典的笔试题:

笔试题1:下面代码能打印出hello world吗?------>传值和传址

//错误代码:
void Getmory(char* p)
{
    p = (char*)malloc(100);
}

void test(void)
{
    char* str = NULL;
    Getmory(str);
    strcpy(str, "hello world");
    printf(str);
}

int main()
{
    test();
    return 0;

}

答案:不能,按照代码本意:想通过Getmory函数给str动态开辟一段100个字节的空间,然后使用strcpy函数拷贝字符串‘hello world’并打印出来。

问题在于:Getmory函数的函数参数只是字符指针str的一份临时拷贝,形参的改变p不影响实参str,而且这样的话,p指向的那段空间在p所在的代码块内都没有得到释放,出Getmory函数代码块后,局部变量p被销毁,这段动态申请的空间也就没有得到销毁,也无法再销毁。

另外,连锁反应,str还是指向空,strcpy函数执行的时候由于源空间不够容纳"hello world“

,就会出现第二个问题。

正确代码:

//正确代码:
void Getmory(char** p)
{
    *p = (char*)malloc(100);
}

void test(void)
{
    char* str = NULL;
    Getmory(&str);
    strcpy(str, "hello world");
    printf(str);
}

int main()
{
    test();
    return 0;

}

笔试题2:下面的代码能打印出"hello world“吗”-------->“返回栈空间地址问题”

//错误代码:
char* Getmory(void)
{
    char p[] = "hello world";
    return p;
}

void test()
{
    char* str = NULL;
    str = Getmory();
    printf(str);
}

int main()
{
    test();

    return 0;
}

答案:不能,Getmory函数中,"hello world”被放在了一个字符数组里,返回时返回的是数组名,也就是这个数组首元素的地址,Getmory函数结束时字符数组所占用的空间自动销毁,但是返回了栈空间的地址,一旦在test函数内对这地址解引用进行访问,那就是非法的,未知的,上述代码的错误原因和下述代码的错误类似。

//错误代码
int* test()
{
    int a = 10;
    return &a;
}

int main()
{
    int* p=test();
    *p = 10;
    printf("%d\n", *p);
    printf("%d\n", *p);
    return 0;

}

6 柔性数组

柔性数组:结构中的最后一个元素允许是未知大小的数组,这就和叫做【柔性数组】成员。


struct s
{
    int num;
    double e;
    int arr[0];
    //或int arr[0];
};

柔性数组的特点:

  1. 结构体中柔性数组成员前必须包含至少一个其他非柔性数组成员。
  2. 包含柔型数组的结构体的内存大小不包含柔型数组的内存大小。
  3. 包含柔性数组的结构体在开辟内存时得使用malloc函数动态内存开辟,且开辟的空间大小必须大于结构体的大小,以适应柔型数组的预期大小。
struct s
{
    int num;
    int arr[0];
    //或int arr[0];
};

int main()
{
    printf("sizeof(struct s):>%d\n", sizeof(struct s));
    struct s* ps = (struct s*)malloc(sizeof(struct s) + 40);

    ps->num = 100;
    for (int i = 0; i < 10; i++)
    {
        ps->arr[i] = i;
    }

    for (int i = 0; i < 10; i++)
    {
        printf("%d\t", ps->arr[i]);
    }
    return 0;
}

struct s
{
    int num;
    int arr[0];
    //或int arr[0];
};

int main()
{
    printf("sizeof(struct s):>%d\n", sizeof(struct s));
    struct s* ps = (struct s*)malloc(sizeof(struct s) + 40);
    if (ps == NULL)
    {
        perror("malloc");
        exit(-1);
    }
    ps->num = 100;
    for (int i = 0; i < 10; i++)
    {
        ps->arr[i] = i;
    }

    for (int i = 0; i < 10; i++)
    {
        printf("%d\t", ps->arr[i]);
    }

    //柔性数组的柔性含义:可以realloc扩容
    struct s* temp = (struct s*)realloc(ps, sizeof(struct s) + 80);
    if (temp != NULL)
    {
        ps = temp;
    }

    for (int i = 0; i < 20; i++)
    {
        ps->arr[i] = i;
    }
    for (int i = 0; i < 20; i++)
    {
        printf("%d\t", ps->arr[i]);
    }
    free(ps);
    ps = NULL;
    return 0;
}

标签: c++ c语言 蓝桥杯

本文转载自: https://blog.csdn.net/qq_64428099/article/details/125119428
版权归原作者 每天都要坚持刷题 所有, 如有侵权,请联系我们删除。

“【动态内存管理】malloc&amp;calloc和realloc和笔试题和柔性数组”的评论:

还没有评论