C语言----动态内存分配(malloc calloc relloc free)超全知识点

简介: C语言----动态内存分配(malloc calloc relloc free)超全知识点

一.动态内存函数

1.栈区(stack):在执行函数时,函数内局部变量的存储单元都以在栈上创建,函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中,效率很高,但是分配的内存容量有限。栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。


2.堆区(heap):一般由程序员分配释放,若程序员不释放,程序结束时可能由OS(操作系统)回收。分配方式类似于链表。

3.数据段(静态区)(static)存放全局变量、静态数据。程序结束后由系统释放


实际上普通的局部变量是在栈区分配空间的,栈区的特点是在上面创建的变量出了作用域就销毁


但是被static修饰的变量存放在数据段(静态区),数据段的特点是在上面创建的变量,直到程序结束才销毁,所以生命周期变长


4.代码段:存放函数体(类成员函数和全局函数)的二进制代码。


动态内存分配是在堆区进行的



int val = 20;//在栈空间上开辟四个字节


char arr [ 10 ] = { 0 }; // 在栈空间上开辟 10 个字节的连续空间

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

1. 空间开辟大小是固定的。

2. 数组在申明的时候,必须指定数组的长度,它所需要的内存在编译时分配

但是对于空间的需求,不仅仅是上述的情况。有时候我们需要的空间大小在程序运行的时候才能知道,数组的编译时开辟空间的方式就不能满足了,这时候就只能试试动态内存开辟


例如


虽然C语言是可以支持变长数组--c99中增加了,但是很多编译器是不支持c99的,所以变长数组没有办法使用,即arr[n],所以已有的分配内存空间的方式是局限的,所以要进行动态内存分配

struct S
{
  char name[20];
  int age;
}
int main()
{
  int n=0;
  scanf("%d",&n);
  struct S arr[n];
  return 0;
}

1.malloc

void* malloc (size_t size)   动态内存开辟


这个函数向内存申请一块 连续可用 的空间,并返回指向这块空间的指针。

如果开辟成功,则返回一个指向开辟好空间的指针。

如果开辟失败,则返回一个 NULL 指针,因此 malloc 的返回值一定要做检查。

返回值的类型是 void* ,所以 malloc 函数并不知道开辟空间的类型,具体在使用的时候使用者自己来决定。

如果参数 size 为 0 , malloc 的行为标准是未定义的,取决于编译器。


malloc包含的几个要素


//1.
#include<stdlib.h>
int main()
{
//2.
    int* p=(int*)malloc(10*sizeof(int));//malloc是void*型,所以要进行强制类型转换,但是在Gcc环境下或者说linux环境下是不需要进行转换的
}
代码如下(还没有回收释放空间)
#include<stdio.h>
#include<stdlib.h>
#include<errno.h>
#include<string.h>
int main()
{
  int* p=(int*)malloc(10*sizeof(int));
  if(p==NULL)
  printf("%s",strerror(errno));//开辟空间失败,可以用strerror显示错误结果
  else
    {
  for(int i=0;i<10;i++)
  {
    //把每个元素打印出来 
    *(p+i)=i;
  }
  for(int i=0;i<10;i++)
  {
    printf("%d",*(p+i));
  } 
    }
  return 0; 
}

如果将其中的


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


改为


    int* p=(int*)malloc(10*sizeof(INT_MAX));


系统会报错,错误信息为not enough space


(1)INT_MAX :INT_MAX 是 C++ 中 <climits> 头文件中定义的一个宏,用于表示 int 类型的最大值。该宏在 C 和 C++ 中都可以使用,他不是数据类型。


如果想正确使用INT_MAX开辟空间,代码如下


//在C++中使用new开辟一块新的空间
#include <iostream>
#include <climits> // 包含 INT_MAX 的头文件
using namespace std; // 引入命名空间
int main() {
    int* p = new int[10]; // 使用 new 关键字动态分配内存
    for (int i = 0; i < 10; ++i) {
        p[i] = INT_MAX; // 给每个元素赋值为 INT_MAX
    }
    for (int i = 0; i < 10; ++i) {
        cout << p[i] << " ";
    }
    cout << endl;
    delete[] p; // 释放动态分配的内存
    return 0;
}


2.free

C语言提供了另外一个函数free,专门是用来做动态内存的释放和回收的(堆区),函数原型如下:


void free ( void* ptr );

free 函数用来释放动态开辟的内存。

如果参数 ptr 指向的空间不是动态开辟的,那 free 函数的行为是未定义的。

如果参数 ptr 是 NULL 指针,则函数什么事都不做。


完整代码如下:


#include<stdio.h>
#include<stdlib.h>
#include<errno.h>
#include<string.h>
int main()
{
  int* p=(int*)malloc(40);
  if(p==NULL)
  printf("%s",strerror(errno));//开辟空间失败,可以用strerror显示错误结果
  else
    {
  for(int i=0;i<10;i++)
  {
    //把每个元素打印出来 
    *(p+i)=i;
  }
  for(int i=0;i<10;i++)
  {
    printf("%d",*(p+i));
  }
    }
        //当动态申请的空间不再使用的时候
        //就应该还给操作系统
    free(p);//即使我们将p还给了操作系统,但是p依然指向这块空间,所以要进行p=NULL
    p=NULL;//使p不指向这块内存空间
  return 0; 
}


3.calloc

calloc 函数也用来动态内存分配。原型如下:

void* calloc ( size_t num , size_t size );

函数的功能是为 num 个大小为 size 的元素开辟一块空间,并且把空间的每个字节初始化为 0 。

与函数 malloc 的区别只在于 calloc 会在返回地址之前把申请的空间的每个字节初始化为全 0


calloc的几个要素


//1.
#include<stdlib.h>
#include<malloc.h>
int main()
{
//2.
//malloc(10*sizeof(int))
    int *p=(int*)calloc(10,sizeof(int));
    return 0;
}

代码如下


#include<stdio.h>
#include<stdlib.h>
#include<errno.h>
#include<string.h>
#include<malloc.h>
int main()
{
  int* p=(int*)calloc(10,sizeof(int));
  if(p==NULL)
  printf("%s",strerror(errno));//开辟空间失败,可以用strerror显示错误结果
  else
    {
  for(int i=0;i<10;i++)
  {
    //把每个元素打印出来 
    *(p+i)=i;
  }
  for(int i=0;i<10;i++)
  {
    printf("%d",*(p+i));
  } 
    }
    free(p);//free函数是用来释放动态开辟的空间的
    p=NULL;
  return 0; 
}

4.malloc和calloc的区别

1.malloc和calloc的开辟空间形式不同


2.calloc会初始化空间为0,而malloc不会初始化。所以malloc开辟空间效率更高,但不会将空间的每个字节初始化为0


5.realloc

realloc 函数的出现让动态内存管理更加灵活。

有时会我们发现过去申请的空间太小了,有时候我们又会觉得申请的空间过大了,那为了合理的时候内存,我们一定会对内存的大小做灵活的调整。那 realloc 函数就可以做到对动态开辟内存大小的调整。

函数原型如下:

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

ptr 是要调整的内存地址

size 调整之后新大小

返回值为调整之后的内存起始位置。

这个函数调整原内存空间大小的基础上,还会将原来内存中的数据移动到 新 的空间。

realloc 在调整内存空间的是存在两种情况:

情况 1 :原有空间之后有足够大的空间

对策:要扩展内存就直接原有内存之后直接追加空间,原来空间的数据不发生变化

情况 2 :原有空间之后没有足够大的空间

对策:在堆空间上另找一个合适大小的连续空间来使用。这样函数返回的是一个新的内存地址。



代码如下


#include<stdio.h>
#include<stdlib.h>
#include<errno.h>
#include<string.h>
int main()
{
  int* p=(int*)malloc(20);
  if(p==NULL)
  printf("%s",strerror(errno));//开辟空间失败,可以用strerror显示错误结果
  else
    {
  for(int i=0;i<10;i++)
  {
    //把每个元素打印出来 
    *(p+i)=i;
  }
    }
    //假设这里20个字节的空间不够用了,我们希望使用40个字节的空间
    //这时候就可以使用realloc来调整动态开辟的空间
    int* p2=realloc(p,40);
    for(int i=5;i<10;i++)
    {
        *(p2+i)=i;
    }
    for(int i=0;i<10;i++)
    {
        printf("%d",*(p2+i));
    }
  return 0; 
}


在这里,用了p,p2两个指针指向不同的内存空间,这样p就不是统一管理所有的空间,所以这样做不对,追加空间有有以下两种情况:


1.开辟的空间后面正好有足够的空间能够追加内存,开辟内存空间后也是p指向内存首元素,返回的是p(旧的指针)



2.如果开辟的空间后没有足够的空间,那么就重新开辟一块新的空间,把原来的地址里面的数据,拷贝到新开辟的更大的空间中



第一种方法返回的是旧的地址


第二种方法返回的是不同的新开辟的内存空间地址,旧的空间free()


注意:


int* p=realloc(p,40);


如果realloc内存开辟失败,返回NULL(空指针),那么p原来开辟的空间也找不到了,所以不能赋值到原来开辟的内存空间,应该这样写:


int* ptr=realloc(p,40);//用新变量接收realloc的返回值
if(ptr!=NULL)
{
  p=ptr;//仍然用p维护新的内存
} 
int i=0;

完整代码如下


#include<stdio.h>
#include<stdlib.h>
#include<errno.h>
#include<string.h>
int main()
{
  int* p=(int*)malloc(20);
  if(p==NULL)
  printf("%s",strerror(errno));//开辟空间失败,可以用strerror显示错误结果
  else
    {
  for(int i=0;i<5;i++)
  {
    //把每个元素打印出来 
    *(p+i)=i;
  }
    }
    //假设这里20个字节的空间不够用了,我们希望使用40个字节的空间
    //这时候就可以使用realloc来调整动态开辟的空间
    int* p2=realloc(p,40);
    if(p2!=NULL)
    {
      p=ptr;
      for(i=5;i<10;i++)
      {
      *(p+i)=i;
  }
  for(i=0;i<10;i++)
  {
    printf("%d",*(p+i));
  }
  }
  free(p);
  p=NULL;
  return 0; 
}


二.动态内存分配的常见错误

1.对null进行解引用操作

int main()
{
    int *p=(int*)malloc(40);//万一解引用失败,p就被赋值为null
    *p=0//err;
   
    int i=0;
    for(int i=0;i<10;i++)
    {
        *(p+i)=i;    
    }
    free(p);
    p=NULL;
    return 0;
}

所以在解引用操作前要作出判断


int main()
{
    int *p=(int*)malloc(40);//万一解引用失败,p就被赋值为null
    if(p!=NULL)
    {
        *p=0//err;
   
        int i=0;
        for(int i=0;i<10;i++)
        {
            *(p+i)=i;    
        }
        free(p);
        p=NULL;
        return 0;
    }
}


2.对动态开辟空间的越界访问

int main()
{
    int *p=(int*)malloc(5*sizeof(int));
    if(p==NULL)
        return 0;
    else 
    {
        for(int i=0;i<10;i++)//本来只有5个整型元素,访问10个的话会越界
        {
            *(p+i)=i;
        }
    }
    //
    free(p);
    p=NULL;
    return 0;
}


3.对非动态开辟内存使用free释放

int a=10;
int* p=&a;
*p=20;
free(p);
p=NULL;

a的空间是在栈区存放的,程序会出错


4.使用free释放动态开辟内存的一部分

#include<stdio.h>
{
int *p=(int*)malloc(40);
if(p==NULL)
{
    return 0;
}
int i=0;
for(i=0;i<10;i++)
{
    *p++=i;
}
free(p);
p=NULL;//在这里p已经变化了,不是最初指向的空间了
return 0;
}



代码应该改为


for(i=0;i<10;i++)
{
    *(p+i)=i;
}
5.对同一块动态内存多次释放
int *p=(int*)malloc(40);
if(p==NULL)
    return 0;
else{
    ....
    free(p);
    free(p);
    p=NULL;
    return 0;
}

或者这样,这样不会报错(每次释放完后,p所指向的地址置为空指针)


free(p);
p=NULL;
free(p);

6.动态开辟内存忘记释放(内存泄漏)

while(1)
{
    malloc(1);
    sleep(1000);    
}
return 0;

三.习题讲解

1.代码找错

(1)内存泄漏


这里有几个错误


(1)调用完GetMemory之后,p是GetMemory中的一个形参变量,p在这个函数内有效,出了这个函数之后就无效了,等GetMemory函数返回之后,动态开辟内存尚未释放并且无法找到,所以会造成内存泄漏,所以在这里str还是空指针,不是有效的地址,所以


strcpy(str,"hello world");//str并没有指向有效的地址,而是一块空指针


(2)没有free(),会出现内存泄露问题


void GetMemory(char **p)//对char *的地址解引用就是**p,p中存放的是str的地址,那么*p就是str
{
    *p=(char *)malloc(100);
}
void Test(void)
{
    char *str=NULL;
    GetMemory(&str);
    strcpy(str,"hello world");
    printf(str);
    free(str);
    str=NULL;
}
int main()
{
    Test();
    return 0;
}


或者


char* GetMemory(char *p)//对char *的地址解引用就是**p,p中存放的是str的地址,那么*p就是str
{
    p=(char *)malloc(100);
    return p;
}
void Test(void)
{
    char *str=NULL;
    str=GetMemory(str);
    strcpy(str,"hello world");
    printf(str);
    free(str);
    str=NULL;
}
int main()
{
    Test();
    return 0;
}


(2)返回栈空间地址的问题


(1)str=GerMemory();//确实将返回值放到了str中,但是执行完该代码后,p的空间就还给操作系统了,所以当printf(str)打印时,str指向哪块空间就不清楚了,同理


int *test()
{
    int a=10;
    return &a;
}
int main()
{
    int *p=test();//非法访问内存空间
    *p=20;
    return 0;
}

可以改为


int *test()
{
    //int a=10;//栈区
    static int a=10;//将a放在静态区中,栈空间的地址返回存在风险,但是静态区不会
    return &a;
}
int main()
{
    int *p=test();
    *p=20;
    return 0;
}

也可以写为


int* test()
{
    int *ptr=malloc(100);//在堆区,如果不free依然存在
    return ptr;
}
int main()
{
    int *p=test();
    return 0;
}

(3)非法访问内存

篡改动态内存区的内容,后果难以预料,非常危险。

因为free(str);之后,str成为野指针if(str!=NULL)语句不起作用


void test(void)
{
    char *str=(char*)malloc(100);
    strcpy(str,"hello");
    free(str);//虽然str开辟的区域已经还给操作系统了,但是str还是指向这块区域
    if(str!=NULL)//这里判断为真,world覆盖hello,打印了world,但是这块空间已经被释放了,不能使用了,但是还是打印了world,非法访问
    {
        strcpy(str,"world");
        printf(str);
    }
}
int main()
{
    test();
    return 0;
}


代码修改为


void test(void)
{
    char *str=(char*)malloc(100);
    strcpy(str,"hello");
    free(str);//虽然str开辟的区域已经还给操作系统了,但是str还是指向这块区域
    str=NULL;//这样下面的判断(str!=NULL)才有意义
    if(str!=NULL)
    {
        strcpy(str,"world");
        printf(str);
    }
}
int main()
{
    test();
    return 0;
}


四.柔性数组

C99中,结构中的最后一个元素允许是未知大小的数组,这就叫做[柔性数组]成员


运用柔性数组


struct S
{
    int n;
    int arr[];//未知大小的,柔性数组成员,数组大小是可以改变的
}
int main()
{
    struct S s;
    printf("%d\n",sizeof(s));//结果为4
    struct S* ps=(struct S*)malloc(sizeof(struct S)+5*sizeof(int));
//为arr开辟了5个int型的地址空间
    ps->n=100;
    for(int i=0;i<5;i++)
    {
        ps->arr[i]=i//0 1 2 3 4 5 
    }
    Struct *ptr=realloc(ps,44);//原来是24个字节,现在是44个字节,多个5个整型变量
    if(ptr!=NULL)
        ps=ptr;
    for(int i=5;i<10;i++)
    {
        ps->arr[i]=i;
    }
    for(int i=0;i<10;i++)
    {
         printf("%d",ps->arr[i]);  
    }
    free(ps);
    ps=NULL;
    return 0;
}


另一种写法,不适用柔性数组,开辟空间的方式有一些区别,但是总体得到的结果相同

struct S
{
    int n;
    int* arr;
}
int main()
{
    struct S*ps = (struct S*)malloc(sizeof(struct S));
    ps->arr=malloc(5*sizeof(int));
    int i=0;
    for(i=0;i<5;i++)
    {
        ps->arr[i]=i;
    }
    for(i=0;i<5;i++)
    {
        printf("%d",ps->arr[i]);      
    }
    int *ptr=realloc(ps->arr,10*sizeof(int));
    if(ptr!=NULL)
        ps->arr=ptr;
    for(int i=5;i<10;i++)
        ps->arr[i]=i;
    for(int i=0;i<10;i++)
        printf("%d",ps->arr[i]);
    //释放内存,注意先后顺序不能改变
    free(ps->arr);
    ps->arr=NULL;
    free(ps);
    ps=NULL;
   
    return 0;
}


柔性数组的优点(第一种对于第二种而言的优点)


1.第二种运用了两次malloc,就要使用两次free(),出错概率更高


2.柔性数组相当于第二种方法,内存碎片更少了,内存利用率更高


3.柔性数组开辟的空间内存是连续的,访问效率更高,而第二种方法不是连续的


目录
相关文章
|
5天前
|
程序员 C语言 C++
【C语言基础】:动态内存管理(含经典笔试题分析)-2
【C语言基础】:动态内存管理(含经典笔试题分析)
|
5天前
|
程序员 编译器 C语言
【C语言基础】:动态内存管理(含经典笔试题分析)-1
【C语言基础】:动态内存管理(含经典笔试题分析)
|
5天前
|
存储 小程序 编译器
【C语言基础】:数据在内存中的存储
【C语言基础】:数据在内存中的存储
|
5天前
|
安全 C语言
【C语言基础】:内存操作函数
【C语言基础】:内存操作函数
|
6天前
|
算法 Unix Linux
C语言随机数的产生(rand、srand、time函数细节讲解)
C语言随机数的产生(rand、srand、time函数细节讲解)
|
13天前
|
存储 C语言
C语言学习记录——动态内存函数介绍(malloc、free、calloc、realloc)
C语言学习记录——动态内存函数介绍(malloc、free、calloc、realloc)
20 1
|
5天前
|
编译器 C语言 C++
【C语言基础】:字符函数和字符串函数-2
【C语言基础】:字符函数和字符串函数
|
5天前
|
C语言
【C语言基础】:字符函数和字符串函数-1
【C语言基础】:字符函数和字符串函数
TU^
|
5天前
|
编译器 程序员 Serverless
C语言之函数
C语言之函数
TU^
4 0
TU^
|
5天前
|
机器学习/深度学习 C语言
C语言之函数递归
C语言之函数递归
TU^
10 1