C语言笔记（十四）——内存四区

悠悠 2022-05-22 11:48 238阅读 0赞

# 一、内存四区 #

内存中各个程序都是存储在不同区域的，而每个区域又包含了相同的四个区：代码区，静态区，堆区，栈区。·

![70][]

## **1.1代码区(里面是一堆指令，都是平行的。代码加载到内存中后不再改变)** ##

代码区code，程序被操作系统加载到内存的时候，所有的**可执行代码**（如a = 3；）都加载代码区，也叫代码段，这块内存是不可以在运行期间修改的。

## **1.2 静态区（内存大小不可变，值可在运行中改变）** ##

所有的**全局变量**以及程序中的**静态变量**都存储到静态区，比较如下两段代码的区别

## **1.3栈区（先进后出，大小不固定，根据程序调用情况决定，不同系统下大小也不同。）** ##

栈stack是一种先进后出的内存结构，所有的**自动变量**，函数的**形参**都是由编译器自动放出栈中，当一个自动变量超出其作用域时，自动从栈中弹出。

对于自动变量，什么时候入栈，什么时候出栈是不需要程序控制的，由C语言编译器实现。

栈溢出：当栈空间已满，但还往栈内存压变量，就叫做栈溢出。对于一个32位操作系统，最大管理4G内存，其中1G是给操作系统自己用的，剩下的3G都是给用户程序，一个用户程序理论上可以使用3G的内存空间。

![70 1][]

## **1.4堆区** ##

堆heap和栈一样，也是一种在程序运行过程中可以随时修改的内存区域，但没有栈那样先进后出的顺序。

堆是一个大容器。它的容量要远远大于栈，但在C语言中，堆内存空间的申请和释放需要手动通过代码来完成。

如下是程序中各参数归属的存储区：

int c = 1; //全局变量存到静态区
    void test(int a, int b) //形参存到栈区
    {
        printf("zanqu_a = %d, zanqu_b = %d\n", &a, &b);
    }
    int main()
    {
        int a = 2; //变量存到栈区
        int b = 0;
        static int d = 0; //静态变量存到静态区
        printf("a = %d, b = %d, c = %d, d = %d, main = %d\n", &a, &b, &c, &d, main);//函数存到代码区
        test(2, 5);
        return 0;
    }

![70 2][]

## **1.5 堆的分配和释放** ##

**   ** 操作系统在管理内存时，**最小单位**不是字节，是**内存页。**

### **1.5.1 malloc //在堆中申请内存。要和free（指针名）配套使用，否则会泄露内存** ###

*void \* malloc（size\_t\_size）;*

malloc函数在堆中分配函数\_size指定大小的内容。其单位：字节，函数返回void \*指针。

### **1.5.2 free //释放堆中内存** ###

**   ** *void free（void \*p）；*

**   ** free负责在堆中释放malloc分配的内存。参数p为malloc返回的堆中的内存地址。

在堆和栈中存储的例子：

int array_print(int *p, int n)
    {
        int i;
        for(i = 0; i < n; i++)
        {
            printf("p[%d] = %d\n", i, p[i]);
        }
    }
    int main(void) //堆数组
    {
       int *p = (int *)malloc(sizeof(int) * 10);//在堆中申请内存。在堆中申请了10个int这么大的空间。堆的内存很大，所以参数10也可以很大，10000或者100000都可以。所以处理大量数据时在堆中保存
        memset(p, 0, sizeof(int) * 10); //将内存清零
        int i;
        for(i = 0; i < 10; i++)
        {
            p[i] = i;
        }
        array_print(p, 10); //打印数组
    
       free(p); //释放通过malloc分配的堆内存。free要跟malloc成对使用，否则会泄露内存
    
        return 0;
    }

int array_print(int *p, int n)
    {
        int i;
        for(i = 0; i < n; i++)
        {
            printf("p[%d] = %d\n", i, p[i]);
        }
    }
    int main(void)//栈数组
    {
     int array[10] = { 0 }; //在栈中申请内存 int *p = array;
        memset(p, 0, sizeof(int) * 10);
        int i;
        for(i = 0; i < 10; i++)
        {
            p[i] = i;
        }
        array_print(p, 10);
    
        return 0;
    }

**注：**

**1)不能将一个栈变量的地址通过函数的返回值返回。**如：

int *geta（）
    {
       int a = 0；
       return &a；
    }

这种写法是错误的。

**2)可以通过函数的返回值返回一个堆地址，但要记得加与其匹配的free。**

int *getb()
    {
       int *p = malloc(sizeof(int));
       return p;
    }
    int main(void)
    {
       int *getp = getb();
       *getp = 30;
       free(getp);
       return 0;
    }

**3)可以通过函数的返回值返回一个静态区地址**

int *getb()
    {
      static int a = 0;
       return &a;
    }
    int main(void)
    {
       int *getp = getb();
       *getp = 30;
       return 0;
    }

再来个例子：

/*void getheap(int *p) { printf("p = %p\n", &p); p = malloc(sizeof(int) * 10); }*/ //getheap执行完后，p就消失了，导致他指向的具体空间的地址编号也随之消失。所以不能采用这种方式，要用getheap1的形式
    
    void getheap1（int **p）//二级指针，所以用*p表示
    {
       *p = malloc(sizeof(int) * 10);
    }
    int main()
    {
        int *p = NULL;
        printf("p = %p\n", &p);//比较这个变量的地址
       /*getheap(p);*/ //实参没有任何改变 
        getheap1(&p);//得到了堆内存的地址
        printf（“p = %d\n”, p）;//和实参的地址
        p[0] = 1;
        p[1] = 2;
        printf("P[0] = %d, p[1] = %d\n", p[0], p[1]);
        free(p);
        return 0;
     }

**getheap函数与主函数间的值传递：**

![70 3][]

**getheap1函数与主函数间的值传递：**

![70 4][]

## 1.6怎样判定用堆还是栈？ ##

（1）明确知道数据占用多少内存，且数据很小，用栈。

（2）占内存大，或不确定内存占用量，用堆。

**![70 5][]**

**注：C语言函数参数从右往左入栈。**

**![70 6][]**

## 1.7 calloc 与malloc类似，负责在堆中分配内存。 ##

void \*p = calloc(size\_t\_Count, size\_t\_Size）;//分配完内存后，将内存清零初始化

free（p）；//释放内存

第一个参数是**所需内存单元数量**，第二个参数是**每个内存单元的大小**（单位：字节），**calloc自动将分配的内存置0.**

利用宾馆开房的例子来说：
    char *p1 = malloc(10);//分配了内存，但里面内容随机出现（这句相当于开了房但没做清洁）
    memset(p1, 0, 10);//将分配好的内存置零，初始化（对开房的酒店做清洁）
    等同于
    char *p1 = calloc(10, sizeof(char));//分好内存并置零初始化

## **例子：输出数组中第二大的数** ##

int main(void)//输出数组中第二大的数
    {
        int i = 0;
        printf("i = ");
        scanf("%d", &i);
      int *array = calloc (i, sizeof(int));
        int a;
        for(a = 0; a < i; a++)
        {
            scanf(" %d",  &array[a]);
        }
        int max;
        int smax;
        if(array[0] < array[1])
        {
            max = array[1];
            smax = array[0];
        }
        else
        {
            max = array[0];
            smax = array[1];
        }
        for(a = 2; a < i; a++)
        {
                 if(max < array[a])
                     {
                         smax = max;
                         max = array[a];
                     }
                 else  if((max > array[a]) && (smax < array[a])) //要采用(max > array[a])跟另一个相与的形式，否则若出现两数相等的情况会出问题
                    { smax = array[a]; }
        }
        printf("smax = %d\n", smax);
        free(array);
        return 0;
    }

## **1.8 realloc//重新分配内存，但不初始化** ##

重新分配用malloc或者calloc函数在堆中分配内存空间的大小

void \*p1 = realloc（void \*p， size\_t\_NewSize）;

free（p1）；//释放内存

第一个参数p为**之前用malloc或calloc分配的内存地址**，\_NewSize为**重新分配内存的地址**

char *p1 = calloc(10, sizeof(char));//分好内存并置零初始化
    char *p2 = realloc(p1, 20);//在原有内存基础上，在堆中增加连续内存。若原有内存没有连续空间可扩展，就重新分配一个空间，将原有内存copy到新空间，然后释放原有内存

**注:realloc和malloc一样，只分配内存，不清零。需要配合memset使用**

[70]: /images/20220522/2045a388ab7f49c391a1cf7f3871d591.png
[70 1]: /images/20220522/09a3248de5cd4884a197d158b65621ed.png
[70 2]: /images/20220522/2ea44464493e44bc857d82230792d8b7.png
[70 3]: /images/20220522/e989eaa1be0444379cc9b395755471b0.png
[70 4]: /images/20220522/db18f0a4e8b84c1aa36779936b36459e.png
[70 5]: /images/20220522/06433a7e608d482e997e71a1ef0c5619.png
[70 6]: /images/20220522/0c7a87b1fc5643c895f929d1544e5f2f.png