流行的桌面架构将进程的虚拟内存划分为几个部分:

Text segment: contains the executable code. The instruction pointer takes values in this range. Data segment: contains global variables (i.e. objects with static linkage). Subdivided in read-only data (such as string constants) and uninitialized data ("BSS"). Stack segment: contains the dynamic memory for the program, i.e. the free store ("heap") and the local stack frames for all the threads. Traditionally the C stack and C heap used to grow into the stack segment from opposite ends, but I believe that practice has been abandoned because it is too unsafe.

C程序通常将具有静态存储持续时间的对象放入数据段中，在空闲存储区中动态分配对象，在其所在线程的调用堆栈中自动分配对象。

在其他平台上，如旧的x86真实模式或嵌入式设备上，情况显然完全不同。

纠正错误的句子

constant data types ----->  code //wrong

本地常量变量----->堆栈

初始化全局常量变量----->数据段

未初始化的全局常量变量-----> BSS

variables declared and defined in main function  ----->  heap //wrong

在主函数-----> stack中声明和定义的变量

pointers(ex:char *arr,int *arr) ------->  heap //wrong

dynamically allocated space(using malloc,calloc) --------> stack //wrong

指针(例如:char *arr,int *arr) ------->该指针变量的大小将在堆栈中。

假设您正在动态分配n字节的内存(使用malloc或calloc)，然后使指针变量指向它。现在n个字节的内存在堆中，指针变量需要4个字节(如果64位机器是8个字节)，它将在堆栈中存储n个字节的内存块的起始指针。

注意:指针变量可以指向任何段的内存。

int x = 10;
void func()
{
int a = 0;
int *p = &a: //Now its pointing the memory of stack
int *p2 = &x; //Now its pointing the memory of data segment
chat *name = "ashok" //Now its pointing the constant string literal 
                     //which is actually present in text segment.
char *name2 = malloc(10); //Now its pointing memory in heap
...
}

动态分配空间(使用malloc,calloc) -------->堆

对于那些未来可能有兴趣了解这些内存段的访问者，我在C语言中写了关于5个内存段的要点:

一些提示:

每当C程序执行时，就会在RAM中分配一些内存用于程序执行。这个内存用于存储频繁执行的代码(二进制数据)、程序变量等。下面的内存段讲的是同样的: 通常有三种变量类型: 局部变量(在C语言中也称为自动变量) 全局变量 静态变量 你可以有全局静态变量或局部静态变量，但上面三个是父类型。

5 C中的内存段:

1. 代码段

The code segment, also referred as the text segment, is the area of memory which contains the frequently executed code. The code segment is often read-only to avoid risk of getting overridden by programming bugs like buffer-overflow, etc. The code segment does not contain program variables like local variable (also called as automatic variables in C), global variables, etc. Based on the C implementation, the code segment can also contain read-only string literals. For example, when you do printf("Hello, world") then string "Hello, world" gets created in the code/text segment. You can verify this using size command in Linux OS. Further reading

数据段

数据段被分为下面两部分，通常位于堆区域的下面，或者在某些实现中位于堆栈之上，但数据段从不位于堆和堆栈区域之间。

2. 未初始化的数据段

This segment is also known as bss. This is the portion of memory which contains: Uninitialized global variables (including pointer variables) Uninitialized constant global variables. Uninitialized local static variables. Any global or static local variable which is not initialized will be stored in the uninitialized data segment For example: global variable int globalVar; or static local variable static int localStatic; will be stored in the uninitialized data segment. If you declare a global variable and initialize it as 0 or NULL then still it would go to uninitialized data segment or bss. Further reading

3.初始化的数据段

This segment stores: Initialized global variables (including pointer variables) Initialized constant global variables. Initialized local static variables. For example: global variable int globalVar = 1; or static local variable static int localStatic = 1; will be stored in initialized data segment. This segment can be further classified into initialized read-only area and initialized read-write area. Initialized constant global variables will go in the initialized read-only area while variables whose values can be modified at runtime will go in the initialized read-write area. The size of this segment is determined by the size of the values in the program's source code, and does not change at run time. Further reading

4. 堆栈段

堆栈段用于存储在函数内部创建的变量(函数可以是主函数或用户定义的函数)，如变量 函数的局部变量(包括指针变量) 传递给函数的参数 返回地址 一旦函数执行完成，存储在堆栈中的变量将被删除。 进一步的阅读

5. 堆段

这个段支持动态内存分配。如果程序员想动态分配一些内存，那么在C语言中可以使用malloc、calloc或realloc方法。 例如，当int* prt = malloc(sizeof(int) * 2)时，将在堆中分配8个字节，并返回该位置的内存地址并存储在ptr变量中。ptr变量将在堆栈或数据段上，这取决于它的声明/使用方式。 进一步的阅读

有些问题你答对了，但写问题的人至少在一个问题上骗了你:

global variables -------> data (correct) static variables -------> data (correct) constant data types -----> code and/or data. Consider string literals for a situation when a constant itself would be stored in the data segment, and references to it would be embedded in the code local variables(declared and defined in functions) --------> stack (correct) variables declared and defined in main function -----> heap also stack (the teacher was trying to trick you) pointers(ex: char *arr, int *arr) -------> heap data or stack, depending on the context. C lets you declare a global or a static pointer, in which case the pointer itself would end up in the data segment. dynamically allocated space(using malloc, calloc, realloc) --------> stack heap

值得一提的是，“栈”的正式名称是“自动存储类”。

指针(例如char*arr,int *arr) -->堆

不，它们可以在堆栈上，也可以在数据段中。他们可以指向任何地方。

流行的桌面架构将进程的虚拟内存划分为几个部分:

Text segment: contains the executable code. The instruction pointer takes values in this range. Data segment: contains global variables (i.e. objects with static linkage). Subdivided in read-only data (such as string constants) and uninitialized data ("BSS"). Stack segment: contains the dynamic memory for the program, i.e. the free store ("heap") and the local stack frames for all the threads. Traditionally the C stack and C heap used to grow into the stack segment from opposite ends, but I believe that practice has been abandoned because it is too unsafe.

C程序通常将具有静态存储持续时间的对象放入数据段中，在空闲存储区中动态分配对象，在其所在线程的调用堆栈中自动分配对象。

在其他平台上，如旧的x86真实模式或嵌入式设备上，情况显然完全不同。