En MS-DOS se suele direccionar memoria en la forma: segmento:offset
donde cada segmento son 64K y offset es el desplazamiento dentro de cada segmento.
Los modificadores de tipo near, far y huge, que sólo se pueden aplicar a punteros y funciones, están relacionados con el direccionamiento de memoria. El modificador near (cerca) fuerza que el valor de un puntero o una función estén en un sólo segmento mientras que far (lejos) y huge (enorme) hacen que un puntero pueda apuntar a cualquier dirección de la memoria y una función puede estar en culquier lugar de la memoria disponible.
A continuación exponemos la descripción de los modificadores near, far y huge así como los distintos modelos de compilación en Turbo C:
--- near (modificador de tipo) ===========================
Fuerza a los punteros a ser near (estar cerca, un mismo segmento), genera código de funciones para llamadas near y devuelve un valor near.
<tipo> near <definicion-puntero> ; o
<tipo> near <definicion-funcion>
La primera versión de near declara un puntero de tamaño una palabra (2 bytes) con un rango de 64K. Este modificador de tipo es usado normalmente cuando se compila en los modelos de memoria medium, large y huge para forzar a que los punteros sean near (ya que por defecto, son far, en los modelos de memoria mencionados).
Ejemplo =======
char near *s;
int (near *pi)[10];
Cuando near es usado con una declaración de función, Turbo C genera código de función para una llamada near y devuelve near.
Ejemplo =======
int near mi_funcion () {}
--- far (modificador de tipo) ==========================
Fuerza a los punteros a ser far (estar lejos, cualquier segmento), genera código de funciones para llamadas far y devuelve un valor far.
<tipo> far <definicion-puntero> ; o
<tipo> far <definicion-funcion>
La primera versión de far declara un puntero de tamaño dos palabras (4 bytes) con un rango de 1 megabyte. Este modificador de tipo es usado normalmente cuando se compila en los modelos de memoria tiny, small y compact para forzar a que los punteros sean far (ya que por defecto, son near, en los modelos de memoria mencionados).
void * far * p;
Cuando far es usado con una declaración de función, Turbo C genera código de función para una llamada far y devuelve far.
Ejemplo =======
int far my_func() {}
--- huge (modificador de tipo) ===========================
Es similar al modificador de tipo far <tipo> huge <definicion-puntero> ;
El modificador huge es similar al modificador far pero tiene dos carac- terísticas adicionales:
þ Su segmento es normalizado durante la aritmética de punteros así que las comparaciones de punteros son más precisas.
þ Los punteros huge pueden ser incrementados sin el temor de que sobrepase un segmento.
En resumen, la utilización de punteros huge es más segura que la utilización de punteros far, pero su uso es más lento porque requieren más comprobacio- nes.
--- Opciones de modelo ====================
Las opciones de modelo especifican qué modelo de memoria se quiere usar. El modelo de memoria elegido determina el método de direccionamiento de memoria por defecto.
El modelo por defecto es small.
---Ò---Ò--- | | Segmentos | Punteros | | Modelo |Código|Datos| Pila |Código|Datos | |========Î======|=====|======Î=============| | Tiny | 64 K | near | near | |---×---×---+---| | Small | 64 K | 64 K | near | near | |---×---+---×---+---| | Medium | 1 MB | 64 K | far | near | |---×---+---×---+---| | Compact| 64 K | 1 MB | near | far | |---×---+---×---+---| | Large | 1 MB | 1 MB | far | far | |---×---+---×---+---| | Huge | 1 MB | 64 K| 64 K | far | far | | | | cada| pila | | | | | | uno | | | | ---Ð---Á---Á---Ð---Á--- --- | Tiny | ---
Usa el modelo tiny (muy pequeño) cuando la cantidad de memoria a consumir es muy importante y ha de ser la menor posible.
Los cuatro registros de segmentos (CS, DS, ES, SS) toman la misma dirección, de este modo tenemos un total de 64K para código, datos y pila. Siempre se usan punteros near.
Los programas de modelo tiny pueden ser convertidos a formato .COM.
--- | Small | ---
Usa el modelo small (pequeño) para aplicaciones de tamaño medio.
Los segmentos de código y datos son diferentes, así que tenemos 64K de código y 64K de datos y pila.
Siempre son usados los punteros near.
--- | Medium | ---
El modelo medium (medio) es mejor para grandes programas que no guardan muchos datos en memoria.
Los punteros far son usados para código pero no para datos. Esto da como resultado que los datos y la pila juntos están limitados a 64K, pero el código puede ocupar hasta 1MB.
--- | Compact | ---
Usa el modelo compact (compacto) si tu código es pequeño pero necesitas direccionar una gran cantidad de datos.
El modelo compact es el contrario al modelo medium: los punteros far son usados para los datos pero no para el código; el código está limitado entonces a 64K, mientras que los datos tienen un rango de 1Mb.
Todas las funciones son near por defecto y todos los punteros de datos son far por defecto.
--- | Large | ---
Usa el modelo large (grande) para aplicaciones muy grandes solamente. Los punteros far son usados para código y datos, dando un rango de 1Mb para ambos. Todas las funciones y punteros de datos son far por defecto.
--- | Huge |
punteros far son usados para el código y los datos.
Turbo C limita normalmente el tamaño de los datos a 64K; el modelo de memoria huge aparta ese límite permitiendo a los datos ocupar más de 64K.
El modelo huge permite múltiples segmentos de datos (cada uno de 64K de tamaño), hasta 1MB para el código, y 64K para la pila.
Todas las funciones y punteros de datos se asumen como far.
LECCIÓN 8
INTRODUCCION A LA LECCION 8
El objetivo de esta lección es hacer un estudio completo en todo lo referente a la declaración, utilización e inicialización de tipos compuestos de datos y explicar cómo se pueden crear nuevos tipos de datos a partir de los ya existentes. El lenguaje C proporciona cinco maneras diferentes de crear tipos de datos:
- Estructuras (struct). - Campos de bits.
- Uniones (union). - Enumeraciones (enum).
- Tipos definidos por el usuario (typedef). Al terminar la lección se presenta una tabla de precedencia de todos los operadores del lenguaje C.
ESTRUCTURAS
En el lenguaje C una estructura es un conjunto de variables que se referencia bajo un mismo nombre, proporcionando un medio conveniente de mantener junta información relacionada. Las estructuras se denominan registros en otros lenguajes; por ejemplo, en Pascal.
A los elementos de la estructura se les suele llamar miembros o campos.