动态内存分配

Posted 2022-03-17 LC辞安

为什么存在内存分配

已知的内存开辟：

int a = 10;//局部变量，在栈区开辟四个字节空间的大小
int arr[10] =  0 ;//在栈空间上连续开辟40个字节的空间大小

但是上述的开辟空间的方式有两个特点：

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

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

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

变量在内存开辟内存的位置

栈区：局部变量

堆区：动态内存分配  malloc free calloc realloc

静态区：全局变量，静态变量

动态内存函数的介绍：

​​​malloc​​​

void* malloc(size_t size);

size:开辟的字节个数

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

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

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

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

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

​malloc库函数的使用​

向内存申请空间

#include<stdlib.h>//注意引头文件
#include<string.h>
#include<errno.h>
#include<stdio.h>
int main()

  //向内存申请10个整形的空间；
  int* p = (int*)malloc(10 * sizeof(int));//返回类型时void*,所以需要强制类型转换
  //返回的时开辟内存空间的地址，所以用指针接受；
  if (p == NULL)
  
    //打印错误原因
    printf("%s\\n", strerror(errno));
  
  else//正常使用
  
    int i = 0;
    for (i = 0; i < 10; i++)
    
      *(p + i) = i;//存储
    
    for (i = 0; i < 10; i++)
    
      printf("%d ", *(p + i));
    
  
  return 0;

​​​free​​​

用来释放动态开辟的内存

void free(void*ptr);

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

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

​free库函数的使用​

#include<stdlib.h>//注意引头文件
#include<string.h>
#include<errno.h>
#include<stdio.h>
int main()

  //向内存申请10个整形的空间；
  int* p = (int*)malloc(10 * sizeof(int));//返回类型时void*,所以需要强制类型转换
  //返回的时开辟内存空间的地址，所以用指针接受；
  if (p == NULL)
  
    //打印错误原因
    printf("%s\\n", strerror(errno));
  
  else//正常使用
  
    int i = 0;
    for (i = 0; i < 10; i++)
    
      *(p + i) = i;//存储
    
    for (i = 0; i < 10; i++)
    
      printf("%d ", *(p + i));
    
  
  free(p);
  p = NULL;//置成NULL,防止内存泄露；
  return 0;

​​​calloc​​​

动态内存开辟

void* calloc (size_t num, size_t size);

num:元素的个数；

size:每个元素的长度，单位是字节；

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

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

​calloc库函数的使用​

#include<errno.h>
#include<stdlib.h>//注意引头文件
#include<string.h>
#include<errno.h>
#include<stdio.h>
int main()

  int* p = (int*)calloc(10, sizeof(int));
  if (p == NULL)
  
    printf("%s\\n", strerror(errno));
  
  else
  
    int i = 0;
    for (i = 0; i < 10; i++)
    
      printf("%d ", *(p + i));
    
  
  free(p);
  p = NULL;
  return 0;

​​​realloc​​​

调整动态开辟内存空间的大小；

有时会我们发现过去申请的空间太小了，有时候我们又会觉得申请的空间过大了，那为了合理的时候内存，我们一定会对内存的大小做灵活的调整。

那realloc函数就可以做到对动态开辟内存大小的调整。

void* realloc(void* memblock,size_t size)

memblock:要调整内存的地址

size:调整后的大小

​realloc库函数的使用​

#include<errno.h>
#include<stdlib.h>//注意引头文件
#include<string.h>
#include<errno.h>
#include<stdio.h>
int main()

  int* p = (int*)malloc(20);
  if (p == NULL)
  
    printf("%s\\n", strerror(errno));
  
  else
  
    int i = 0;
    for (i = 0; i < 5; i++)
    
      *(p + i) = i;
    
  
  //假设使用malloc开辟的内存大小不够使用
  //可以使用realloc调整动态内存；
  int* p2 = realloc(p, 40);
  int i = 0;
  for (i = 0; i < 10; i++)
  
    printf("%d ", *(p2 + i));
  

  return 0;

开辟空间

打印

存在的问题：开辟的空间malloc由p指针指向，而realloc开辟的空间由p2指向，代码可能会出现问题

改进

#include<errno.h>
#include<stdlib.h>//注意引头文件
#include<string.h>
#include<errno.h>
#include<stdio.h>
int main()

  int* p = (int*)malloc(20);
  if (p == NULL)
  
    printf("%s\\n", strerror(errno));
  
  else
  
    int i = 0;
    for (i = 0; i < 5; i++)
    
      *(p + i) = i;
    
  
  //假设使用malloc开辟的内存大小不够使用
  //可以使用realloc调整动态内存；
  p2 = realloc(p, 4000);
  if(p2!=NULL)
  
       p=p2;
  
  int i = 0;
  for (i = 5; i < 10; i++)
  
    *(p + i) = i;
  
  for (i = 0; i < 10; i++)
  
    printf("%d ", *(p+ i));
  

  return 0;

realloc函数的使用注意事项

1.如果p指向的空间之后有足够的内存空间可以追加，则直接追加，后返回p;

2.如果p指向的空间之后没有足够的内存空间可以追加，则realloc会重新找一个新的内存区域开辟一块满足需求的空间，并且把原来内存中的数据拷贝回来，释放旧的内存空间，最后返回新开辟内存的地址

​​地址发生了改变​​

3.如果realloc开辟内存失败，也会丢失原来malloc开辟的内存，得用一个新的变量来接受realloc的返回值

#include<errno.h>
#include<stdlib.h>//注意引头文件
#include<string.h>
#include<errno.h>
#include<stdio.h>
int main()

  int* p = (int*)malloc(20);
  if (p == NULL)
  
    printf("%s\\n", strerror(errno));
  
  else
  
    int i = 0;
    for (i = 0; i < 5; i++)
    
      *(p + i) = i;
    
  
  //假设使用malloc开辟的内存大小不够使用
  //可以使用realloc调整动态内存；
  int*ptr = realloc(p, 4000);
  
    if (ptr != NULL)//判断开辟的是否成功开辟内存
    
      p = ptr;
      int i = 0;
      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;

​realloc也可以直接开辟内存​

int main()

  int* p = (int*)realloc(NULL, 40);

  return 0;

常见的动态内存错误

1.对NULL指针的解引用操作

int main()

  int* p = (int*)malloc(40);
  //万一malloc开辟失败了，p就被赋值为NULL  ;
  *p = 0;//err
  int i = 0;
  for (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
  
    int i = 0;
    for (i = 0; i < 10; i++)
    
      *(p + i) = i;
    
  

  return 0;

程序发生崩溃了；

3.对非动态开辟空间进行free

int main()

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

程序崩溃的原因：free释放的静态区上的而不是栈区上的；

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

int main()


  int* p = (int*)malloc(40);
  if (p == NULL)
  
    return 0;
  
  else
  
    int i = 0;
    for (i = 0; i < 10; i++)
    
      *p++ = i;
    
  
  free(p);
  p = NULL;
  return 0;

5.对同一块动态内存多次释放

int main()

  int* p = (int*)malloc(20);
  if(p==NULL)
  
     return 0;
  
  free(p);
  free(p);

  return 0;

 

6.动态开辟内存忘记释放（内存泄漏）

nt main()

  while (1)
  
    malloc(1);
  
    
  return 0;

经典的面试题

题目1

void GetMemory(char* p) 

  p = (char*)malloc(100); 

void Test(void)

  char* str = NULL;
  GetMemory(str); 
  strcpy(str, "hello world"); 
  printf(str); 

int main()


  test();
  return 0;

代码存在的问题：

1.代码运行的时候会出现程序崩溃

原因：在拷贝的时候将”hello world“拷贝到”str“但str是空指针，拷贝的时候进行解引用操作，会导致程序崩溃

2.代码运行的时候会出现内存泄漏

原因：str以值传递的形式将（NULL）传递给p,p是GetMemory的形参，只在函数内部有效，等GetMemory函数返回之后，动态开辟内存尚未释放，并且无法找到，所以会造成内存泄漏。

代码改正1.

void GetMemory(char** p) 

  *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;

代码改正2.

void GetMemory(char* p) 

  p = (char*)malloc(100); 
  return p;

void Test(void)

  char* str = NULL;
  GetMemory(str); 
  strcpy(str, "hello world"); 
  printf(str); 
  free(str);
  str=NULL;

int main()


  test();
  return 0;

题目2

#include<stdio.h>

char* GetMemory(void) 
 
  char p[] = "hello world";
  return p;

void Test(void)

  char* str = NULL;
  str = GetMemory();
  printf(str);

int main()


  Test();
  return 0;

结果：输出随机值

原因：数组在栈上开辟内存，当返回p（数组的地址）的时候，p所指向的空间可能会存放随机值，访问的时候造成非法访问内存；

代码改正：

用static修饰的时候延长了变量的生命周期，出这个函数的时候p不会被销毁，开辟的内存空间从栈区到静态区

char* GetMemory(void) 
 
  static char p[] = "hello world";
  return p;

void Test(void)

  char* str = NULL;
  str = GetMemory();
  printf(str);

int main()


  Test();
  return 0;

题目3

void GetMemory(char** p, int num) 

  *p = (char*)malloc(num);

void Test(void)

  char* str = NULL;
  GetMemory(&str, 100);
  strcpy(str, "hello");
  printf(str);

int main()


  Test();
  return 0;

结果：会输出hello,但是动态开辟内存之后没有进行free释放，造成内存泄漏

代码改正：

void GetMemory(char** p, int num) 

  *p = (char*)malloc(num);

void Test(void)

  char* str = NULL;
  GetMemory(&str, 100);
  strcpy(str, "hello");
  printf(str);
  free(str);
  str=NULL;

int main()


  Test();
  return 0;

题目4

void Test(void)

  char* str = (char*)malloc(100);
  strcpy(str, "hello");
  free(str);
  if (str != NULL)
  
    strcpy(str, "world");
    printf(str);
  

int main()


  Test();
  return 0;

结果：输出world,但是动态开辟的内存提前free释放了，并不会把str置为NULL当继续访问的时候会造成非法内存访问；

代码改正

void Test(void)

  char* str = (char*)malloc(100);
  strcpy(str, "hello");
  free(str);
  str=NULL;
  if (str != NULL)
  
    strcpy(str, "world");
    printf(str);
  

int main()


  Test();
  return 0;

柔性数组

也许你从来没有听说过柔性数组（flexible array）这个概念，但是它确实是存在的。 C99 中，结构中的最后一个元素允许是未知大小的数组，这就叫做『柔性数组』成员。

例如：

struct S

  int n;
  int arr[0];//柔性数组成员的大小是未知的，大小可以调整；
;
int main()

  struct S s;

  return 0;

柔性数组的特点： 结构中的柔性数组成员前面必须至少一个其他成员。

sizeof 返回的这种结构大小不包括柔性数组的内存。

struct S

  int n;
  int arr[0];//柔性数组成员的大小是未知的，大小可以调整；
;
int main()

  struct S s;
  printf("%d\\n", sizeof(s));
  return 0;

包含柔性数组成员的结构用malloc ()函数进行内存的动态分配，并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小。

struct S

  int n;
  int arr[0];
;
int main()
                               //柔性数组的大小是可变的，自己开辟内存；
  struct S *ps=(struct S*)malloc(sizeof(struct S) + 5 * sizeof(int));
  ps->n = 100;

  int i = 0;
  for (i = 0; i < 5; i++)
  
    ps->arr[i] = i;
  
  struct S* ptr = realloc(ps, 40);
  if (ptr != NULL)
  
    ps = ptr;
  
  for (i = 5; i < 10; i++)
  
    ps->arr[i] = i;
  
  for (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 = (int*)realloc(ps->arr, 40);
  if (ptr != NULL)
  
    ps ->arr = ptr;
  
  for (i = 5; i < 10; i++)
  
    ps->arr[i] = i;
  
  for (i = 0; i < 10; i++)
  
    printf("%d ", ps->arr[i]);
  
  free(ps->arr);
  ps->arr = NULL;
  free(ps);
  ps = NULL;
  return 0;

在内存上开辟空间的特点：

先通过malloc给结构体开辟一块空间，存放n和arr,在通过ps-->arr，给arr开辟空间；在内存上开辟空间是不连续的

相比之下柔性数组的优点：不容易出错；内存碎片少，内存利用率高；访问效率高（内存连续的）。

上述代码1和代码2可以完成同样的功能，但是方法1的实现有两个好处： 第一个好处是：方便内存释放如果我们的代码是在一个给别人用的函数中，你在里面做了二次内存分配，并把整个结构体返回给用户。用户调用free可以释放结构体，但是用户并不知道这个结构体内的成员也需要free，所以你不能指望用户来发现这个事。所以，如果我们把结构体的内存以及其成员要的内存一次性分配好了，并返回给用户一个结构体指针，用户做一次free就可以把所有的内存也给释放掉。

第二个好处是：这样有利于访问速度.连续的内存有益于提高访问速度，也有益于减少内存碎片。（其实，我个人觉得也没多高了，反正你跑不了要用做偏移量的加法来寻址）