动态内存分配_C语言

逻辑上的分区

栈区
堆区
静态区
常量区
代码区

代码区,常量区,静态区,堆区,栈区这个排列顺序按照地址由小到大排列的

代码区:

只读的

程序员无需对其操作,里边放着代码编译之后形成的二进制

常量区:

只读的

例如"acfun",'Q',5,等等的常量,放在常量区

char *p ="bilibili";

任何试图修改常量区内容的操作,都会造成内存崩溃

char arr[] ="bilibili";
arr[0] = 'I';

在使用指针操作字符串的时候一定注意内存分区的问题

strcpy(p, "123");
p[0] = 'I';
printf("%p\n",p);

静态区:

使用static关键字修饰的变量放在静态区，放在静态区的变量只被初始化一次

static int a = 10;

如果不给初始值，默认相当于赋值0

static int b;//默认相当于给b = 0;

使用static修饰的静态变量生命周期等于整个程序的生命周期,即程序退出后才被释放(iOS编程写单例类的时候,要使用static)

int all = 10;//全局变量,实际上也放在静态区

printf("%p\n",&a);//代码区,常量区,静态区,栈区,的所占空间并不大

printf("%p\n",&all);//里边局部变量0x7fff5fbff7b0

printf("%p\n",&all);//外边全局变量0x100001020

(Stack)栈区:

一块连续的内存,由系统自动分配和释放,不需要程序员手动管理,大小也就1M-2M

他是有自己管理的规则的:栈区内存的分配按照先进后出的原则

int a = 10;//先初始化的a
int b = 20;//后初始化的b

printf("%p\n",&a);//地址高
printf("%p\n",&b);//地址低

之前所学的代码其实都放在栈区,只不过没有出现栈区溢出的问题

堆区:

内存比较大的空间都被堆区占用着,堆区是不连续的内存空间,需要咱们程序员手动的分配和释放内存

定义一个指针

int *p =malloc(4);

malloc就是程序员手动分配内存空间的函数,函数的参数放着我们需要的内存空间这块空间就是堆内存的一块空间

printf("%p\n",p);//堆内存地址
printf("%d\n",*p);//堆内存里边的值

释放空间

free(p);
p = NULL;//让p指向地址0x0.

课上练习

输入三个单词保存在堆内存并输出

   char *word[3] = {0};//指针数组
   char temp1[100] = {0};//用来保存每一个单词
   printf("请输入三个单词:\n");
   for(int i = 0; i < 3; i++) {
       scanf("%s",temp1);
       
        word[i] =malloc(sizeof(temp1));//指向堆内存地址
       
       strcpy(word[i], temp1);
    }
   printf("**********************\n");
   for(int i = 0; i < 3; i++) {
       printf("%s\n",word[i]);
       free(word[i]);//若多释放一块未开辟的空间,程序会崩溃掉,这种情况称为过度释放
        word[i] =NULL;
    }

内存分配函数

malloc和free…这些函数维护一个可用内存池，并向该程序返回一个指向这块内存的指针。这块内存此时此刻并没有以任何方式进行初始化。如果这个内存很重要你可以手动进行初始化，要么使用calloc函数。

malloc函数

函数原型

void *malloc(size_t size);

size就是需要分配的内存字节（字符）数。如果内存池中的内存可以满足这个要求，malloc就返回一个指向被分配内存的起始位置的指针。
malloc所分配的是一块连续的内存。
如果内存池为空，malloc函数会向操作系统请求。如果操作系统无法向malloc提供更多的内存，malloc就会返回一个NULL指针。因此要对malloc返回的指针进行检查，确保其非NULL
malloc返回一个void *的指针。标准的void *指针可以转换为其他任何类型的指针。但是，在某些（老式）编译器可能需要你在转换时使用强制类型转换
对于要求边界对齐的机器，malloc所返回的内存的起始位置将始终能够满足对边界对齐要求最严格的类型的要求。

char *p1 =malloc(4);
for(int i = 0; i < 4; i++) {
    *(p1+i) = 65 + i;
    printf("%c\n",*(p1+i));
}

free(p1);

p1 =NULL;

free函数

函数原型

void free(void *pointer);

free的参数要么是NULL，要么是先前从malloc、calloc或realloc返回的值。
向free传递一个NULL参数不会产生任何效果

calloc函数

函数原型

void *calloc(size_t num_elements,size_t element_size);

calloc也用于分配内存。malloc和calloc之间的主要区别是后者返回指向内存的指针之前把它初始化为0。但显得效率很低。
malloc和calloc它俩请求内存数量的方式不同。calloc的参数包括所需元素的数量和每个元素的字节数。根据这些值，可以计算出总共需要分配的内存。

char *p2 =calloc(3, 1);第一个参数是分配多少个,第二个参数是每个有多少个字节

for(int i = 0; i < 3; i++) {
    *(p2+i) = 'a';
    printf("%c\n",*(p2+i));
}

free(p2);

p2 =NULL;

练习

使用calloc函数分配十块四个字节的空间,存放十个随机数取值范围在10 - 30之间,然后打印

char *p3 =calloc(10, 4);

for(inti = 0; i < 10; i++) {
    *(p3+i) =arc4random()%21 + 10;
    printf("%d\n",*(p3+i));
}

free(p3);

realloc函数

函数原型

void realloc(void *ptr,size_t new_size);

realloc函数用于修改一个原先已经分配的内存块的大小。这个函数可以使一块内存扩大或缩小。
如果扩大，那么这块内存原先的内容依然保留，新增加的内存添加到原先内存块的后面，新内存并未以任何方法进行初始化。
如果缩小，该内存块尾部的部分内存便被拿掉，剩余部分内存的原先内容依然保留。
如果原先的内存块无法改变大小，realloc将分配另一块正确大小的内存，并把原先那块内存的内容复制到新的块上。因此，在使用realloc之后，你就不能再使用指向旧内存的指针，而应该改用realloc所返回的新指针。
如果realloc函数的第一个参数是NULL,那么它的行为就和malloc一模一样。

int *p4 =malloc(4);
int *p5 =realloc(p4, 8);给p4重新分配了8个字节的空间
  
*p5 = 10;
*(p5+1) = 20;

*p4 = 11;
*(p4+1) = 21;
  
printf("%d\n%d\n",*p5,*(p5+1));
printf("%d\n%d\n",*p4,*(p4+1));

memset内存设置函数

int *p6 =malloc(4);

注意这里声明的是整型

memset(p6, 65, 16);第一个参数放要操作的指针,第二个参数放内容(整型或者字符型),第三个参数放字节数

for(inti = 0; i < 4; i++) {
printf("%c\n",*(p6+i));

}

memcpy内存内容拷贝的函数

char*p7 =malloc(4);

memcpy(p7, p6, 5);
 
for(inti = 0; i < 4; i++) {
//        *(p7 + i) = 66;
printf("%c\n",*(p7+i));
}

内存的比较函数

跟字符串比较函数一样,比较里边的内容,找到第一个不相同的字符,按照ascii码表值进行作差

int count =memcmp(p7, p6, 5);
printf("%d\n",count);