S1E39：C语言的内存布局--笔记

BaysideLizard

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. //鱼C论坛——BaysideLizard写于2023年11月26日
   
4. 
   
5. //实验一
   
6. int global_uninit_var;
   
7. int global_init_var1 = 1;
   
8. int global_init_var2 = 2;
   
9. 
   
10. int *func(void);
    
11. 
    
12. int main()
    
13. {
    
14.     int local_var1;
    
15.     int local_var2;
    
16. 
    
17.     static int static_uninit_var;
    
18.     static int static_init_var = 3;
    
19. 
    
20.     char *str1 = "abc";
    
21.     char *str2 = "efg";
    
22. 
    
23.     int *malloc_var = (int *)malloc(sizeof(int));
    
24. 
    
25.     printf("实验一\n");
    
26.     printf("addr of func -> %p\n",func);
    
27.     printf("addr of str1 -> %p\n",str1);
    
28.     printf("addr of str2 -> %p\n",str2);
    
29.     printf("addr of global_init_var1 -> %p\n",&global_init_var1);
    
30.     printf("addr of global_init_var2 -> %p\n",&global_init_var2);
    
31.     printf("addr of static_init_var -> %p\n",&static_init_var);
    
32.     printf("addr of static_uninit_var -> %p\n",&static_uninit_var);
    
33.     printf("addr of global_uninit_var -> %p\n",&global_uninit_var);
    
34.     printf("addr of malloc_var -> %p\n",malloc_var);
    
35.     printf("addr of local_var1 -> %p\n",&local_var1);
    
36.     printf("addr of local_var2 -> %p\n",&local_var2);
    
37. /*C语言的内存布局规律：
    
38. 内存地址   低 -------> 高
    
39. 函数  字符串常量  全局变量(初始化)  静态变量(初始化)  静态变量(未初始化)  全局变量(未初始化)  动态申请的变量空间  局部变量
    
40. 
    
41. 代码段  数据段  bss段  堆  栈
    
42. 
    
43. 代码段：存放程序执行代码
    
44. 数据段：存放已经初始化的全局变量和局部静态变量
    
45. BSS(Block Started by Symbol)段：存放未初始化的全局变量，自动初始化为0
    
46. 堆：手动申请与释放
    
47. 栈：自动分配与释放
    
48. */
    
49. 
    
50. //实验二
    
51.     int *ptr = NULL;
    
52.     ptr = func();
    
53.     printf("\n实验二\nptr -> %d\n",*ptr);
    
54.     free(ptr);
    
55. 
    
56. //实验三
    
57.     int *ptr1 = NULL;
    
58.     int *ptr2 = NULL;
    
59. 
    
60.     ptr1 = (int *)malloc(sizeof(int));
    
61.     if(ptr1 == NULL)
    
62.     {
    
63.         exit(1);
    
64.     }
    
65.     ptr2 = (int *)malloc(sizeof(int));
    
66.     if(ptr2 == NULL)
    
67.     {
    
68.         exit(1);
    
69.     }
    
70.     printf("\n实验三\n");
    
71.     printf("stack:&ptr1-%p | &ptr2-%p\n",&ptr1,&ptr2);
    
72.     printf("heap:ptr1-%p | ptr2-%p\n",ptr1,ptr2);
    
73. 
    
74.     ptr1 = realloc(ptr1,2 * sizeof(int));
    
75.     printf("realloc ptr1 -> 2 * sizeof(int):%p\n",ptr1);
    
76.     ptr1 = realloc(ptr1,20 * sizeof(int));
    
77.     printf("realloc ptr1 -> 20 * sizeof(int):%p\n",ptr1);
    
78.     //str1的内存地址取决于realloc的大小
    
79. 
    
80.     return 0;
    
81. 
    
82. }
    
83. 
    
84. int *func(void)
    
85. {
    
86.     int *ptr = NULL;
    
87.     ptr = (int *)malloc(sizeof(int));
    
88.     if(ptr == NULL)
    
89.     {
    
90.         exit(1);
    
91.     }
    
92. 
    
93.     *ptr = 123;
    
94. 
    
95.     return ptr;
    
96. }
    

复制代码

运行结果：
实验一
addr of func -> 000000000040177F
addr of str1 -> 0000000000404000
addr of str2 -> 0000000000404004
addr of global_init_var1 -> 0000000000403010
addr of global_init_var2 -> 0000000000403014
addr of static_init_var -> 0000000000403018
addr of static_uninit_var -> 0000000000407030
addr of global_uninit_var -> 0000000000407970
addr of malloc_var -> 0000000000C55E60
addr of local_var1 -> 000000000061FDFC
addr of local_var2 -> 000000000061FDF8

实验二
ptr -> 123

实验三
stack:&ptr1-000000000061FDF0 | &ptr2-000000000061FDE8
heap:ptr1-0000000000C56E90 | ptr2-0000000000C56EB0
realloc ptr1 -> 2 * sizeof(int):0000000000C56E90
realloc ptr1 -> 20 * sizeof(int):0000000000C56ED0

Process returned 0 (0x0)   execution time : 0.037 s
Press any key to continue.








不过我发现了一个问题，在我的电脑上堆的地址似乎更高，这是由于编译器和操作系统的具体实现方式引起的。具体来说，当你运行程序时，操作系统会为进程分配虚拟地址空间，并将其划分为不同的区域，如代码区、数据区（包括全局变量和静态变量）、堆和栈等。
详见https://fishc.com.cn/thread-236996-1-1.html







在FishC学C的第21天

FishC_GPT

你的代码主要是用来展示C语言的内存布局的。我会逐一解释相关部分。

首先是实验一，你定义了一些全局变量、局部变量、静态变量和动态申请的变量空间，并打印它们的地址。

- 函数`func`的地址是`0x000000000040177F`
- 字符串常量`str1`的地址是`0x0000000000404000`
- 字符串常量`str2`的地址是`0x0000000000404004`
- 全局变量`global_init_var1`的地址是`0x0000000000403010`
- 全局变量`global_init_var2`的地址是`0x0000000000403014`
- 静态变量`static_init_var`的地址是`0x0000000000403018`
- 静态变量`static_uninit_var`的地址是`0x0000000000407030`
- 未初始化的全局变量`global_uninit_var`的地址是`0x0000000000407970`
- 动态申请的变量空间`malloc_var`的地址是`0x0000000000C55E60`
- 局部变量`local_var1`的地址是`0x000000000061FDFC`
- 局部变量`local_var2`的地址是`0x000000000061FDF8`

然后你提到了C语言的内存布局规律，从低地址到高地址，依次是代码段、数据段、BSS段、堆和栈。

- 代码段：存放程序执行代码
- 数据段：存放已经初始化的全局变量和局部静态变量
- BSS段：存放未初始化的全局变量，自动初始化为0
- 堆：手动申请和释放内存
- 栈：自动分配和释放内存

接下来是实验二，你定义了一个指针`ptr`，并将它赋值为`func`函数的返回值，然后打印`ptr`指向的值。

在`func`函数中，你动态申请了一个整型变量的空间，并将其赋值为123，然后返回指向该空间的指针。

运行结果显示`ptr`指向的值是123。

最后是实验三，你首先定义了两个指针`ptr1`和`ptr2`，然后分别对它们进行了动态内存分配，分别打印它们在栈和堆中的地址。

接着使用`realloc`函数重新分配了`ptr1`的内存空间，将原来的大小改为2倍，然后打印`ptr1`的值。接着又将`ptr1`的大小改为20倍，并再次打印`ptr1`的值。

注意，使用`realloc`重新分配内存时，要确保之前申请的指针不为空，否则会出错。

希望以上解释能帮助你理解内存布局和相关概念。如果还有其他问题，请随时提问。

以上回复来自 -- ChatGPT（FishC官方接口），如未能正确解答您的问题，请继续追问。