2.3: Mapas de memoria

Última actualización
Guardar como PDF

Page ID: 81938

\( \newcommand{\vecs}[1]{\overset { \scriptstyle \rightharpoonup} {\mathbf{#1}} } \) \( \newcommand{\vecd}[1]{\overset{-\!-\!\rightharpoonup}{\vphantom{a}\smash {#1}}} \)\(\newcommand{\id}{\mathrm{id}}\) \( \newcommand{\Span}{\mathrm{span}}\) \( \newcommand{\kernel}{\mathrm{null}\,}\) \( \newcommand{\range}{\mathrm{range}\,}\) \( \newcommand{\RealPart}{\mathrm{Re}}\) \( \newcommand{\ImaginaryPart}{\mathrm{Im}}\) \( \newcommand{\Argument}{\mathrm{Arg}}\) \( \newcommand{\norm}[1]{\| #1 \|}\) \( \newcommand{\inner}[2]{\langle #1, #2 \rangle}\) \( \newcommand{\Span}{\mathrm{span}}\) \(\newcommand{\id}{\mathrm{id}}\) \( \newcommand{\Span}{\mathrm{span}}\) \( \newcommand{\kernel}{\mathrm{null}\,}\) \( \newcommand{\range}{\mathrm{range}\,}\) \( \newcommand{\RealPart}{\mathrm{Re}}\) \( \newcommand{\ImaginaryPart}{\mathrm{Im}}\) \( \newcommand{\Argument}{\mathrm{Arg}}\) \( \newcommand{\norm}[1]{\| #1 \|}\) \( \newcommand{\inner}[2]{\langle #1, #2 \rangle}\) \( \newcommand{\Span}{\mathrm{span}}\)\(\newcommand{\AA}{\unicode[.8,0]{x212B}}\)

Cada byte de memoria en un sistema informático tiene una dirección asociada a él. Esto es un requisito. Sin una dirección, el procesador no tiene forma de identificar una ubicación específica en la memoria. Generalmente, el direccionamiento de memoria comienza en 0 y se abre camino hacia arriba, aunque algunas direcciones pueden ser especiales o “reservadas” en algunos sistemas. Es decir, una dirección específica podría no referirse a la memoria normal, sino que podría referirse a un cierto puerto de entrada/salida para comunicación externa. Muy a menudo es útil dibujar un mapa de memoria. Esto no es más que una enorme variedad de ranuras de memoria. Algunas personas los dibujan con la dirección más baja (inicial) en la parte superior y otras personas los dibujan con la dirección más baja en la parte inferior.

Aquí hay un ejemplo con solo seis bytes de memoria:

Figura\(\PageIndex{1}\): Mapa de memoria simple.

Cada dirección o ranura representa un lugar donde podemos almacenar un byte. Si tuviéramos que recordar direcciones específicas estaríamos haciendo mucho trabajo. En cambio, el compilador de C hará un seguimiento de esto por nosotros. Por ejemplo, si declaramos un char llamado X, podría estar en la dirección 2. Si necesitamos imprimir ese valor, no tenemos que decir “buscar el valor en la dirección 2”. En cambio decimos; “buscar el valor de X” y el compilador genera código para hacer que esto funcione a la dirección apropiada (2). Esta abstracción alivia considerablemente nuestra carga mental. Como muchas variables requieren más de un byte, es posible que necesitemos combinar direcciones para almacenar un solo valor. Por ejemplo, si elegimos un int corto, eso necesita dos bytes. Supongamos que esta variable comienza en la dirección 4. También requerirá el uso de la dirección 5. Cuando accedemos a esta variable el compilador genera automáticamente el código para utilizar ambas direcciones porque “sabe” que estamos usando un int corto. Nuestro pequeño mapa de memoria de seis bytes podría contener 6 char, 3 int corto, 1 int largo con 1 int corto, 1 int largo con 2 char, o alguna otra combinación similar. No puede contener un doble ya que eso requiere 8 bytes. Del mismo modo, no pudo contener una matriz de 4 o más int cortos (consulte el Capítulo Tres para obtener detalles sobre los tipos de datos numéricos).

Las matrices son de especial interés ya que deben ser contiguas en la memoria. Por ejemplo, supongamos que un sistema tiene 1000 bytes de memoria y se declaró una matriz de caracteres de 200 elementos. Si esta matriz comienza en la dirección 500, entonces todas las ranuras de 500 a 699 se asignan para la matriz. No se puede crear de manera “dispersa” con unos cuantos bytes aquí y algunos bytes allá. Este requisito se debe a la manera en que los arrays son indexados (accedidos), como veremos más adelante.