que - ¿Dónde en memoria están mis variables almacenadas en C?

punteros y arreglos en c (7)

punteros (por ejemplo: char * arr, int * arr) -------> montón

No, pueden estar en la pila o en el segmento de datos. Pueden apuntar a cualquier parte.

Al considerar que la memoria está dividida en cuatro segmentos: datos, montón, pila y código, donde se encuentran variables globales, estáticas, constantes, locales (definidas y declaradas en funciones), variables (en función principal), punteros , y el espacio asignado dinámicamente (usando malloc y calloc) se almacena en la memoria?

Creo que se asignarán de la siguiente manera:

Variables globales -------> Heap (las variables estáticas y globales se almacenan en montón de acuerdo con la programación orientada a objetos de Robert Lafore Book en C ++
Variables estáticas -------> montón
Tipos de datos constantes -----> código
Variables locales (declaradas y definidas en funciones) --------> pila
Variables declaradas y definidas en la función principal -----> montón
Punteros (por ejemplo, char *arr , int *arr ) -------> montón
Espacio asignado dinámicamente (utilizando malloc y calloc) --------> pila

Me refiero a estas variables solo desde la perspectiva C.

Por favor corrígeme si me equivoco ya que soy nuevo en C.

Me refiero a estas variables solo desde la perspectiva C.

Desde la perspectiva del lenguaje C , todo lo que importa es alcance, alcance, vinculación y acceso; exactamente cómo se asignan los elementos a diferentes segmentos de memoria depende de la implementación individual, y eso variará. El estándar de lenguaje no habla de segmentos de memoria en absoluto . La mayoría de las arquitecturas modernas actúan principalmente de la misma manera; las variables de ámbito de bloque y los argumentos de función se asignarán desde la pila, el alcance del archivo y las variables estáticas se asignarán desde un segmento de datos o código, la memoria dinámica se asignará desde un montón, algunos datos constantes se almacenarán en segmentos de solo lectura , etc.

Corregido tus oraciones incorrectas

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

variables constantes locales -----> pila

variable constante global inicializada -----> segmento de datos

variable constante global no inicializada -----> bss

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

variables declaradas y definidas en la función principal -----> pila

pointers(ex:char *arr,int *arr) -------> heap //wrong dynamically allocated space(using malloc,calloc) --------> stack //wrong

punteros (por ejemplo: char * arr, int * arr) -------> tamaño de esa variable puntero estará en la pila.

Considere que está asignando memoria de n bytes (utilizando malloc o calloc ) dinámicamente y luego haciendo que el puntero sea variable para apuntarlo. Ahora que n bytes de memoria están en montón y la variable de puntero requiere 4 bytes (si la máquina de 64 bits 8 bytes) estará en la pila para almacenar el puntero inicial de los n bytes de la porción de la memoria.

Nota: Las variables del puntero pueden señalar la memoria de cualquier segmento.

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

espacio dinámicamente asignado (usando malloc, calloc) --------> montón

Obtuviste algunos de estos derechos, pero quien escribió las preguntas te engañó al menos con una pregunta:

variables globales -------> datos (correctos)
variables estáticas -------> datos (correctos)
tipos de datos constantes -----> código y / o datos. Considere los literales de cadena para una situación en la que una constante se almacenaría en el segmento de datos, y las referencias a ella se incorporarían en el código.
variables locales (declaradas y definidas en funciones) --------> apilar (corregir)
variables declaradas y definidas en la función main -----> ~~montón~~ también pila (el profesor estaba tratando de engañarte)
punteros (por ejemplo: char *arr , int *arr ) -------> ~~pila de~~ datos, según el contexto. C le permite declarar un puntero global o static , en cuyo caso el puntero terminaría en el segmento de datos.
espacio dinámicamente asignado (usando malloc , calloc , realloc ) --------> ~~stack~~ realloc

Vale la pena mencionar que "pila" se llama oficialmente "clase de almacenamiento automático".

Para aquellos visitantes futuros que puedan estar interesados en conocer esos segmentos de memoria, estoy escribiendo puntos importantes sobre 5 segmentos de memoria en C:

Algunas cabezas arriba:

Cada vez que se ejecuta un programa C, se asigna memoria en la RAM para la ejecución del programa. Esta memoria se utiliza para almacenar el código que se ejecuta con frecuencia (datos binarios), variables de programa, etc. Los segmentos de memoria a continuación hablan de lo mismo:
Normalmente hay tres tipos de variables:
- Variables locales (también llamadas como variables automáticas en C)
- Variables globales
- Variables estáticas
- Puede tener variables estáticas globales estáticas o locales, pero los tres anteriores son los tipos principales.

5 segmentos de memoria en C:

1. Segmento de código

El segmento de código, también denominado segmento de texto, es el área de memoria que contiene el código ejecutado frecuentemente.
El segmento de código suele ser de solo lectura para evitar el riesgo de ser anulado al programar errores como el desbordamiento de búfer, etc.
El segmento de código no contiene variables de programa como variables locales ( también llamadas variables automáticas en C ), variables globales, etc.
En función de la implementación de C, el segmento de código también puede contener literales de cadena de solo lectura. Por ejemplo, cuando printf("Hello, world") , se crea la cadena "Hola mundo" en el segmento de código / texto. Puede verificar esto usando el comando de size en el sistema operativo Linux.
Otras lecturas

Segmento de datos

El segmento de datos se divide en las dos partes siguientes y, por lo general, se encuentra debajo del área del montón o en algunas implementaciones encima de la pila, pero el segmento de datos nunca se encuentra entre el montón y el área de la pila.

2. Segmento de datos no inicializado

Este segmento también se conoce como bss .
Esta es la porción de memoria que contiene:
1. Variables globales sin inicializar (incluidas las variables de puntero)
2. Variables globales constantes sin inicializar .
3. Variables estáticas locales sin inicializar .
Cualquier variable local global o estática que no se inicialice se almacenará en el segmento de datos no inicializados
Por ejemplo: variable global int globalVar; o variable local static int localStatic; se almacenará en el segmento de datos no inicializados.
Si declara una variable global y la inicializa como 0 o NULL entonces iría al segmento de datos no inicializados o bss.
Otras lecturas

3. Segmento de datos inicializado

Este segmento almacena:
1. Variables globales inicializadas (incluidas las variables de puntero)
2. Variables globales constantes iniciadas .
3. Variables estáticas locales inicializadas .
Por ejemplo: variable global int globalVar = 1; o variable local static int localStatic = 1; se almacenará en el segmento de datos inicializados.
Este segmento se puede clasificar además en área de solo lectura inicializada y área de lectura-escritura inicializada . Las variables globales constantes inicializadas irán en el área de solo lectura inicializada, mientras que las variables cuyos valores se pueden modificar en el tiempo de ejecución irán en el área inicial de lectura y escritura .
El tamaño de este segmento está determinado por el tamaño de los valores en el código fuente del programa y no cambia en el tiempo de ejecución .
Otras lecturas

4. Segmento de pila

El segmento de pila se usa para almacenar variables que se crean dentro de funciones (la función podría ser la función principal o la función definida por el usuario ), variables como
1. Variables locales de la función (incluidas las variables de puntero)
2. Argumentos pasados a funcionar
3. Dirección del remitente
Las variables almacenadas en la pila se eliminarán tan pronto como finalice la ejecución de la función.
Otras lecturas

5. Segmento de montón

Este segmento es para admitir la asignación de memoria dinámica. Si el programador desea asignar memoria dinámicamente, entonces en C se hace usando los métodos malloc , calloc o realloc .
Por ejemplo, cuando int* prt = malloc(sizeof(int) * 2) se asignarán ocho bytes en el montón y la dirección de memoria de esa ubicación se devolverá y se almacenará en la variable ptr . La variable ptr estará en la pila o segmento de datos dependiendo de la forma en que se declara / usa.
Otras lecturas

Una arquitectura de escritorio popular divide la memoria virtual de un proceso en varios segmentos :

Segmento de texto: contiene el código ejecutable. El puntero de instrucción toma valores en este rango.
Segmento de datos: contiene variables globales (es decir, objetos con enlaces estáticos). Subdividido en datos de solo lectura (como constantes de cadena) y datos no inicializados ("BSS").
Segmento de pila: contiene la memoria dinámica para el programa, es decir, la tienda gratuita ("montón") y los marcos de pila locales para todos los subprocesos. Tradicionalmente, la pila C y la pila C se usaban para crecer en el segmento de pila desde extremos opuestos, pero creo que la práctica se ha abandonado porque es demasiado insegura.

El programa de CA normalmente coloca objetos con duración de almacenamiento estático en el segmento de datos, objetos dinámicamente asignados en la tienda gratuita y objetos automáticos en la pila de llamadas de la cadena en la que vive.

En otras plataformas, como el viejo modo real x86 o en dispositivos integrados, las cosas pueden ser radicalmente diferentes.

Variables / variables automáticas ---> sección de pila
Variables asignadas dinámicamente ---> sección de montón
Variables globales inicializadas -> sección de datos
Variables globales sin inicializar -> sección de datos (bss)
Variables estáticas -> sección de datos
Constantes de cadena -> sección de texto / sección de código
Funciones -> sección de texto / sección de código
Código de texto -> sección de texto / sección de código
Registros -> Registros de CPU
Entradas de línea de comando -> sección de línea de comando / medioambiental
Variables ambientales -> sección ambiental / línea de comando