数据结构（Day13）

一、学习内容

内存空间划分
1. 1、一个进程启动后，计算机会给该进程分配4G的虚拟内存
  2、其中0G-3G是用户空间【程序员写代码操作部分】【应用层】
  3、3G-4G是内核空间【与底层驱动有关】
  4、所有进程共享3G-4G的内核空间，每个进程独立拥有0G-3G的用户空间
  5、内存分区的目的是：专人专项、提高效率
  1. 栈区特点
    1. 运行时自动分配和回收：栈是自动管理的，程序员不需要手工干预，使用起来方便简单。
    2. 反复使用：栈内存在程序中其实就是那一块空间，程序反复使用这一块空间。
    3. 脏内存：栈内存由于反复使用，每次使用后程序不会去清理，因此分配到时如果没有初始化会保留原来的值。
    4. 临时性：函数不能返回栈变量的指针，因为这个空间是临时的。
    5. 栈会溢出：因为操作系统事先给定了栈的大小，如果在函数中无穷尽的分配栈内存总会消耗完。
    6. 栈空间是向下增长的
  2. 堆区特点
    1. 大块内存：堆内存管理是总量很大的操作系统内存块，各进程可以按需申请使用，使用完释放。
    2. 程序手动申请和释放：手工意思是需要写代码去申请malloc()和释放free()。
    3. 脏内存：堆内存也是反复使用的，而且使用者用完释放前不会清除，因此也是脏的。
    4. 临时性：堆内存只在申请malloc()和释放free()之间属于这个进程，可以访问。在释放free()之后不能再访问，否则会有不可预料的后果。
    5. 不可直接操作：需要通过指针操作。
    6. 堆空间是向上增长的
  3. 堆和栈的区别
    1. 管理分配效率不同。栈编译器自动管理，无需程序员手工控制；而堆空间的申请释放工作由程序员控制，容易产生内存泄漏。堆的效率比栈要低
    2. 空间大小不同。栈是向低地址扩展的数据结构，是一块连续的内存区域。堆是向高地址扩展的数据结构，是不连续的内存区域。
    3. 是否产生碎片。对于堆来讲，频繁的malloc/free（new/delete）势必会造成内存空间的不连续，从而造成大量的碎片，使程序效率降低（虽然程序在退出后操作系统会对内存进行回收管理）。对于栈来讲，则不会存在这个问题。
    4. 增长方向不同。堆的增长方向是向上的，即向着内存地址增加的方向；栈的增长方向是向下的，即向着内存地址减小的方向。
动态内存分配和回收（申请和释放）
- malloc函数
  - 功能：在堆区开辟指定字节的空间
  - 头文件：#include <stdlib.h>
  - 原型：void *malloc(size_t size);
  - 分析：返回值是void *【通用型指针】——可以转换成任意类型的指针
    - 参数是size_t size 【数据类型 size_t 64位是long int——%ld 32位是int——%d】【size表示的是索要开辟的空间的大小】
- free函数
  - 功能：手动释放堆区空间
  - 头文件：#include <stdlib.h>
  - 原型：void free(void *ptr); //无返回值函数参数是void *ptr 【通用型指针，传参直接传指针名即可】
- 常见的内存错误
  - 野指针
    - 原因
      - 指向动态分配内存的指针在释放后，没有NULL
      - 指向被删除的对象或无效对象的指针
      - 接收了函数返回的局部变量的指针
    - 解决方法
      - malloc() free()后及时NULL
      - 及时更新指针
      - 编码时明确变量的作用域，不要接收返回的局部变量的指针
  - 内存越界
    - 原因
      - 访问到野指针指向的区域，越界访问
      - 数组下标越界访问
      - 向缓冲区写入超过其容量的数据【strcpy、strcat的例子】
    - 解决方法
      - 使用数组时确保下标的范围，使用循环计数或条件判断控制范围
      - 使用指针时，进行if(NULL==p)的检查
      - 使用strncat 和 strncpy可以确保不会溢出目标缓冲区 strcpy(dest , src); strncpy(dest , src , strlen(dest))
  - 内存泄漏
    - 如果没有适时释放被动态分配的内存，会导致内存泄露问题。未释放的内存一直占用系统资源，使得系统变慢并最终导致崩溃。
      - 原因
        
        丢失了分配的内存的首地址，导致无法释放
        
        每循环一次，泄露一次内存
        
        非法访问常量区
      - 解决方法
        
        及时使用free()释放不再使用的内存
        
        合理设计数据结构和算法，避免内存无线增长
        
        设置合理的变量【作用域】，减少内存占用
脑图

二、作业

p 和 "hello,world"存储在内存哪个区域？( ) (鲁科安全)

int main()

{

char *p = "hello,world";

return 0;

}

解析：

字符串 "hello,world" 是一个字符串字面量，在编译时会存储在程序的常量区（或者叫做只读数据段）中。该区域通常是只读的，不能被修改。
变量 p 是一个指针变量，它指向字符串 "hello,world"。因为 p 是在 main() 函数中定义的局部变量，所以它存储在栈区中。

解答：

*p在栈区 "hello，world"在静态区中的.ro段

一个由C/C++编译的程序，会将占用的内存分为几个部分：堆、栈、代码段、数据段、BSS段。请问以下程序中的变量a、b、c、d，分别被存在内存的哪个部分？(泰华智慧)

int a = 0;

char *b;

int main()

{

    int c;

    static char d = 'a';

    b = malloc(10);

    *b = d;

    return 0;

}

解析：

变量 a：

变量 a 是一个全局变量并且初始化为 0。

存储区域：数据段（已初始化的全局变量存储在数据段）。

变量 b：

变量 b 是一个全局指针变量，但它没有初始化。

存储区域：BSS 段（未初始化的全局变量和静态变量存储在 BSS 段中）。

变量 c：

变量 c 是在 main 函数内部定义的局部变量。

存储区域：栈区（局部变量存储在栈区）。

变量 d：

变量 d 是一个静态局部变量并初始化为 'a'。

存储区域：数据段（静态局部变量也存储在数据段中，因为它已初始化）。

解答：

变量a在数据段、b在bss段、c在栈区、d在数据段

如下代码：变量g_iA，g_iB，g_iC，iD，iE, iF, piG,iH 分别在内存中的什么区( ) (H3C)

int g_iA = 1;

int g_iB;

static int g_iC = 1;

void func1(){

    static int iD=2;

    iD++;

    int iE=2;

    iE++;

}

void func2(){

    int iF=3;

    int *piG = (int*) malloc(4);

}

int main(){

    int iH = 100;

}

解析：

g_iA：

这是一个已初始化的全局变量。

存储区域：data段（已初始化的全局变量存储在数据段中）。

g_iB：

这是一个未初始化的全局变量。

存储区域：BSS 段（未初始化的全局变量存储在 BSS 段中）。

g_iC：

这是一个已初始化的静态全局变量。

存储区域：data段（已初始化的静态全局变量也存储在数据段中）。

iD：

这是在 func1 函数中定义的已初始化的静态局部变量。

存储区域：data段（静态局部变量存储在数据段中，无论函数是否被调用）。

iE：

这是在 func1 函数中定义的局部变量。

存储区域：栈区（局部变量存储在栈中，每次函数调用时都会分配新的内存）。

iF：

这是在 func2 函数中定义的局部变量。

存储区域：栈区（局部变量存储在栈中）。

piG：

这是在 func2 函数中定义的指针，malloc(4) 动态分配了 4 字节的内存，piG 指向这块内存。

存储区域：栈区（指针 piG 本身）和堆区（malloc(4) 动态分配的内存）。

iH：

这是在 main 函数中定义的局部变量。

存储区域：栈区（局部变量存储在栈中）

解答：

g_iA在静态区中的.data段、g_iB在静态区的.bss段、g_iC在静态区的.data段、iD在静态区的.data段、iE在栈区、iF在栈区、piG在栈区、iH在栈区

有关内存的思考题 (山东山大电力技术有限公司，登虹科技，昆腾微电子)

void GetMemory(char *p)

{

           p =(char *)malloc(100);

}

void Test(void)

{

    char *str=NULL;

    GetMemory(str);

    strcpy(str,"hello world");

    printf(str);

}

请问运行 Test 函数会有什么样的结果？

char * GetMemory(void)

{

           char pl[] = "hello world"; //char *p = "hello world"

    return p1;

}

Void Test(void)

{

           char *str=NULL;

    str = GetMemory();

    printf(str);

}

请问运行 Test 函数会有什么样的结果？

void GetMemory(char **p,int num)

{

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

}

void Test(void)

{

    char *str = NULL;

    GetMemory(&str, 100);

    strcpy(str, "hello world");

    printf(str);

}

请问运行 Test 函数会有什么样的结果？

void Test (void)

{

    char *str = (char *)malloc(100);

   strcpy(str,"hello");

    free(str);

    if(str != NULL)

    {

        strcpy(str, "world");

        printf(str);

    }

}

请问运行 Test 函数会有什么样的结果？

解析：

1、第一段

在 GetMemory 函数中，参数 p 是一个局部指针变量，当 malloc(100) 动态分配内存时，只是将地址赋值给局部的 p，而不会影响调用者 Test 中的 str。换句话说，str 仍然是 NULL。随后在 Test 中调用 strcpy(str, "hello world") 时，会试图向 NULL 指针中写入数据，这会导致段错误（Segmentation Fault）。

2、第二段
GetMemory 函数中，p1[] 是一个局部数组，存储在栈区。当 GetMemory 函数返回时，栈帧将被释放，局部变量 p1 将变为无效。虽然 GetMemory 返回 p1 的地址，但是这个地址指向已经被释放的栈空间，尝试访问该地址的内容是未定义行为。

3、第三段
在 GetMemory 中，传递的是 str 的地址（&str），因此函数可以正确地分配内存并将其赋值给 str。随后 strcpy(str, "hello world") 将字符串拷贝到分配的内存中，并调用 printf(str) 输出字符串。
4、第四段
malloc(100) 分配了 100 字节的内存，随后 strcpy(str, "hello") 将字符串 "hello" 拷贝到这块内存。free(str) 释放了 str 指向的内存。虽然在 C 中，调用 free 并不会自动将指针置为 NULL，但在 if (str != NULL) 语句中，str 依然保持其原来的值（它指向已释放的内存）。由于内存已经被释放，再次尝试 strcpy(str, "world") 将会向一块已经释放的内存写入数据，这是未定义行为。

解答：

第一段：段错误

第二段：段错误

第三段："hello,world"

第四段：程序崩溃

堆和栈的区别是什么？ (矩阵软件)

解答：

管理分配效率不同。栈编译器自动管理，无需程序员手工控制；而堆空间的申请释放工作由程序员控制，容易产生内存泄漏。堆的效率比栈要低

空间大小不同。栈是向低地址扩展的数据结构，是一块连续的内存区域。堆是向高地址扩展的数据结构，是不连续的内存区域。

是否产生碎片。对于堆来讲，频繁的malloc/free（new/delete）势必会造成内存空间的不连续，从而造成大量的碎片，使程序效率降低（虽然程序在退出后操作系统会对内存进行回收管理）。对于栈来讲，则不会存在这个问题。

增长方向不同。堆的增长方向是向上的，即向着内存地址增加的方向；栈的增长方向是向下的，即向着内存地址减小的方向。