By considering that the memory is divided into four segments: data, heap, stack, and code, where do global variables, static variables, constant data types, local variables (defined and declared in functions), variables (in main function), pointers, and dynamically allocated space (using malloc and calloc) get stored in memory?

I think they would be allocated as follows:

Global variables -------> heap (both static and global variables are stored in heap according to Robert Lafore's Book object oriented programming in C++

Static variables -------> heap

Constant data types -----> code

Local variables (declared and defined in functions) --------> stack

Variables declared and defined in main function -----> heap

Pointers (for example, char *arr , int *arr ) -------> heap

Dynamically allocated space (using malloc and calloc) --------> stack

I am referring to these variables only from the C perspective.

Please correct me if I am wrong as I am new to C.

---

You got some of these right, but whoever wrote the questions tricked you on at least one question:

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

It is worth mentioning that "stack" is officially called "automatic storage class".

---

For those future visitors who may be interested in knowing about those memory segments, I am writing important points about 5 memory segments in C:

Some heads up:

Whenever a C program is executed some memory is allocated in the RAM for the program execution. This memory is used for storing the frequently executed code (binary data), program variables, etc. The below memory segments talks about the same:

Typically there are three types of variables:

Local variables (also called as automatic variables in C)

Global variables

Static variables

You can have global static or local static variables, but the above three are the parent types.

5 Memory Segments in C:

1. Code Segment

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

Data Segment

The data segment is divided in the below two parts and typically lies below the heap area or in some implementations above the stack, but the data segment never lies between the heap and stack area.

2. Uninitialized data segment

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. Initialized data segment

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. Stack Segment

Stack segment is used to store variables which are created inside functions (function could be main function or user-defined function), variable like

Local variables of the function (including pointer variables)

Arguments passed to function

Return address

Variables stored in the stack will be removed as soon as the function execution finishes.

Further reading

5. Heap Segment

This segment is to support dynamic memory allocation. If the programmer wants to allocate some memory dynamically then in C it is done using the malloc , calloc , or realloc methods.

For example, when int* prt = malloc(sizeof(int) * 2) then eight bytes will be allocated in heap and memory address of that location will be returned and stored in ptr variable. The ptr variable will be on either the stack or data segment depending on the way it is declared/used.

Further reading

---

Corrected your wrong sentences

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

local constant variables -----> stack

initialized global constant variable -----> data segment

uninitialized global constant variable -----> bss

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

variables declared and defined in main function -----> stack

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

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

pointers(ex:char *arr,int *arr) -------> size of that pointer variable will be in stack.

Consider that you are allocating memory of n bytes (using malloc or calloc ) dynamically and then making pointer variable to point it. Now that n bytes of memory are in heap and the pointer variable requries 4 bytes (if 64 bit machine 8 bytes) which will be in stack to store the starting pointer of the n bytes of memory chunk.

Note : Pointer variables can point the memory of any segment.

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
...
}

dynamically allocated space(using malloc,calloc) --------> heap

链接地址: http://www.djcxy.com/p/28342.html

上一篇: 堆栈溢出在Linux上沉默？

下一篇: 内存中的位置是我的变量存储在C中？