APUNTES DE ESTRUCTURAS Y BASES DE DATOS

CONTENIDO

Tema 1 ______________________________________________________________ 3
Introducción__________________________________________________________ 3
1.1 Historia del lenguaje de programación C y C++______________________________ 3
1.2 Programación Orientada a Objetos ________________________________________ 4
1.3 Características de la POO ________________________________________________ 5
TEMA 2 _____________________________________________________________ 8
Tipos de Datos ________________________________________________________ 8
2.1 Tipos de datos básicos en C _______________________________________________ 8
2.2 Tipo de dato “char _____________________________________________________ 10
2.3 Tipo de dato “int” _____________________________________________________ 12
2.4 Tipo de dato “long” ____________________________________________________ 16
2.5 Tipo de dato “float” ____________________________________________________ 17
2.6 Tipo de dato “double” __________________________________________________ 16
2.7 Tipo de dato “long double” ______________________________________________ 16
2.8 Representación en punto flotante _________________________________________ 17
2.9 Aritmética de punto flotante _____________________________________________ 22
2.10 Representación en formato estándar IEEE (short real) _____________________ 22
2.11 Pase de entero a short real IEEE ________________________________________ 23
2.12 Tipo de dato “void ____________________________________________________ 24
Tema 3 _______________________________________ ¡Error! Marcador no definido.
TIPOS DE DATOS DEFINIDOS POR EL USUARIO _________ ¡Error! Marcador no definido.
3.1 Estructuras _____________________________________ ¡Error! Marcador no definido.
3.2 Creación de una estructura ________________________ ¡Error! Marcador no definido.
3.3 Unión __________________________________________ ¡Error! Marcador no definido.
Tema 4 _______________________________________ ¡Error! Marcador no definido.
APUNTADORES (POINTERS) ________________________ ¡Error! Marcador no definido.
4.1 Definición ______________________________________ ¡Error! Marcador no definido.
4.2 Operadores * y & en apuntadores __________________ ¡Error! Marcador no definido.
4.3 Operaciones Aritméticas entre Apuntadores _________ ¡Error! Marcador no definido.
TEMA 5 _____________________________________ ¡Error! Marcador no definido.
CLASES _______________________________________ ¡Error! Marcador no definido.
5.1 Definición de una clase ___________________________ ¡Error! Marcador no definido.
5.1 Definición de una clase _______________________ ¡Error! Marcador no definido.

1
TEMA 6 ______________________________________ ¡Error! Marcador no definido.
ASIGNACIÓN DINÁMICA DE MEMORIA _______________ ¡Error! Marcador no definido.
6.1 Uso de malloc y free ______________________________ ¡Error! Marcador no definido.
Tema 7 _______________________________________ ¡Error! Marcador no definido.
ESTRUCTURAS DINÁMICAS DE DATOS ________________ ¡Error! Marcador no definido.
7.1 Listas simplemente enlazadas ______________________ ¡Error! Marcador no definido.
7.2 Listas doblemente enlazadas _______________________ ¡Error! Marcador no definido.
7.3 Estructura de datos llamada “Pila” _________________ ¡Error! Marcador no definido.
7.4 Estructura de datos llamado “Cola” (Queue) _________ ¡Error! Marcador no definido.
Tema 8 _______________________________________ ¡Error! Marcador no definido.
RECURSIVIDAD _________________________________ ¡Error! Marcador no definido.
8.1 Recursividad ____________________________________ ¡Error! Marcador no definido.
8.2 Tipos de recursión _______________________________ ¡Error! Marcador no definido.
Tema 9 _______________________________________ ¡Error! Marcador no definido.
ÁRBOLES BINARIOS ______________________________ ¡Error! Marcador no definido.
9.1 Árboles Binarios _________________________________ ¡Error! Marcador no definido.
Tema 10 ______________________________________ ¡Error! Marcador no definido.
ARCHIVOS Y CORRIENTES _________________________ ¡Error! Marcador no definido.
10.1 Corrientes _____________________________________ ¡Error! Marcador no definido.
10.2 Archivos ______________________________________ ¡Error! Marcador no definido.
10.3 Apuntadores a archivos __________________________ ¡Error! Marcador no definido.
10.4 Lectura y escritura de Bloques ____________________ ¡Error! Marcador no definido.

2
Tema 1
INTRODUCCIÓN

1.1 Historia del lenguaje de programación C y C++

Antes de hablar de C y C++, es necesario explicar qué un lenguaje de programación es
una herramienta que nos permite comunicarnos e instruir a la computadora para que
realice una tarea específica. Cada lenguaje de programación posee una sintaxis y un
léxico particular, es decir, forma de escribirse que es diferente en cada uno por la forma
que fue creado y por la forma que trabaja su compilador para revisar, acomodar y
reservar el mismo programa en memoria

Lenguaje C
El lenguaje C se diseñó en 1972 (Dennis Ritchie). Más tarde, en 1983, se definió el
estándar ANSI C (que es el que aquí presentaremos). Ya ha quedado dicho que el
lenguaje C está creado para la programación estructurada.
El lenguaje C tiene muy pocas reglas sintácticas, sencillas de aprender. Su léxico es
muy reducido: tan solo 32 palabras.
A menudo se le llama lenguaje de medio nivel, más próximo al código máquina que
muchos lenguajes de más alto nivel. Y por eso mismo es un lenguaje muy eficiente.
Permite el uso del lenguaje ensamblador en partes del código, trabaja a nivel de bit, y
permite modificar los datos con operadores que manipulan bit a bit la información.
También se puede acceder a las diferentes posiciones de memoria conociendo su
dirección.
El lenguaje C permite con facilidad la programación modular, creando unidades
independientes que pueden compilarse de forma independiente, que pueden
posteriormente enlazarse. Así, se crean funciones o procedimientos, que se pueden
compilar y almacenar, creando así bibliotecas de código ya editado y compilado que
resuelve distintas operaciones. Cada programador puede diseñar sus propias
bibliotecas, que simplifican luego considerablemente el trabajo futuro. El ANSI C posee
una amplia colección de bibliotecas de funciones estándar y normalizadas.

Lenguaje C++
En 1980 surge C++ de la mano de Bjarne Stroustrup (también de Laboratorios Bell de
AT&T). Diseña este lenguaje con el objetivo de añadir a C nuevas características: clases
y funciones virtuales (de SIMULA67), tipos genéricos y expresiones (de ADA), la
posibilidad de declarar variables en cualquier punto del programa (de ALGOL68), y
sobre todo, un auténtico motor de objetos con herencia múltiple que permite combinar
la programación imperativa de C con la programación orientada a objetos. En 1985 se
realizan pruebas permitiendo el uso de este.

3
El nombre de C++ de debe a Rick Mascitti, significando el carácter evolutivo de las
transformaciones de C (“++” es el operador de incremento de C).

C++ ha sido ampliamente revisado y refinado, lo que ha dado lugar a añadir nuevas
características, como herencia múltiple funciones miembro static y const, miembros
protected, tipos genéricos de datos o plantillas y manipulación de excepciones. Se han
revisado características como sobrecarga, enlace y manejo de memoria. Además, se
realizaron cambios para así poder incrementar la compatibilidad con C y se añadieron
la identificación de tipos durante la ejecución y los espacios de nombres con el objetivo
de convertir a C++ en un lenguaje mas propicio para la escritura y utilización de
bibliotecas.
Apartir la estandarización publicada en 1998 llamada estándar ISO C++ (ISO/IEC –
International Standardization Organization/ International Electrotechnical Commissión)
14882) se logro tener la biblioteca que actualmente incorpora C++ y que fue escrita con
la intención de que el código se pueda portar entre diferentes plataformas y de incluir
solo aquellas clases que realmente fueran utilizadas por la mayoría de los
programadores. Las facilidades proporcionadas por esta biblioteca estándar las
podemos resumir en los siguientes puntos:

 Soporte básico, como por ejemplo identificación del tipo de los objetos durante la
ejecución y gestión de memoria.
 Soporte proporcionado para la biblioteca de C (manipulación de cadenas, archivos,
etc.).
 La clase string para la manipulación de cadenas de caracteres.
 Clases para la entrada-salida
 Clases contenedor como vectores, listas y mapas.
 Algoritmo de búsqueda y de ordenación.
 Clases para trabajar con números como son cmath, complex y cstdlib.

C++ es por lo tanto, un lenguaje híbrido que, por una parte, ha adoptado todas las
características de la programación orientada a objetos (POO) que no perjudiquen su
efectividad; por ejemplo, funciones virtuales y la ligadura dinámica (dynamic binding), y
por otra parte, mejora sustancialmente las capacidades de C. Esto, junto con la
biblioteca de clases soportada, dota a C++ de una potencia, eficacia y flexibilidad que
lo convierten en un estándar dentro de los lenguajes de programación orientados a
objetos.

1.2 Programación Orientada a Objetos

La programación orientada a objetos (POO) es una forma especial de programar, más
cercana a como expresaríamos las cosas en la vida real que otros tipos de
programación. Con la POO tenemos que aprender a pensar las cosas de una manera
distinta, para escribir nuestros programas en términos de objetos, propiedades, métodos

Durante años, los programadores se han dedicado a construir aplicaciones muy

parecidas que resolvían una y otra vez los mismos problemas. Para conseguir que los
esfuerzos de los programadores puedan ser utilizados por otras personas se creó la

4
POO. Que es una serie de normas de realizar las cosas de manera que otras personas
puedan utilizarlas y adelantar su trabajo, de manera que consigamos que el código se
pueda reutilizar con el fin de disminuir el costo del software, aumentando la eficiencia
en la programación y reduciendo el tiempo necesario para el desarrollo de una
aplicación.

La programación orientada a objetos (POO) tiene tres características básicas: debe

estar basado en objetos, basado en clases y capaz de tener herencia de clases. Muchos
lenguajes cumplen uno o dos de estos puntos; muchos menos cumple los tres. La
barrera más difícil de sortear es usualmente la herencia.

La idea central es simple: organizar los programas a imagen y semejanza de la

organización de los objetos en el mundo real.

Todo objeto del mundo real tiene 2 componentes: características y comportamiento. Por
ejemplo, los automóviles tienen características (marca, modelo, color, velocidad
máxima, etc.) y comportamiento (frenar, acelerar, retroceder, llenar combustible,
cambiar llantas, etc.).
Los Objetos de Software, al igual que los objetos del mundo real, también tienen
características y comportamientos. Un objeto de software mantiene sus características
en una o más "variables", e implementa su comportamiento con "métodos". Un método
es una función o subrutina asociada a un objeto.

Para redondear estas ideas, imaginemos que tenemos estacionado en nuestra cochera
un Ford Focus color azul que corre hasta 200 km/h. Si pasamos ese objeto del mundo
real al mundo del software, tendremos un objeto Automóvil con sus características
predeterminadas:

Marca = Ford
Modelo = Focus
Color = Azul
Velocidad Máxima = 200 km/h

1.3 Características de la POO

No hay un acuerdo aceptado por todo el mundo respecto a cuáles son las características
que definen la POO, pero al menos todos concuerdan en estas:

Abstracción:

Es la capacidad de separar los elementos (al menos mentalmente) para poder verlos de
forma singular. Como cuando describimos el cuerpo humano y decimos cabeza,
brazo(s), pierna(s), etc. Cada objeto en el sistema sirve como modelo de un "agente"

5
abstracto que puede realizar trabajo, informar y cambiar su estado, y "comunicarse" con
otros objetos en el sistema sin revelar cómo se implementan estas características.

Encapsulamiento:

También conocida como ocultamiento. Se encarga de mantener ocultos los procesos

internos que necesita para hacer lo que sea que haga, dándole al programador acceso
sólo a lo que necesita. Esto da dos ventajas iniciales: Lo que hace el usuario puede ser
controlado internamente (incluso sus errores), evitando que todo colapse por una
intervención indeseada. La segunda ventaja es que, al hacer que la mayor parte del
código esté oculto, puedes hacer cambios y/o mejoras sin que eso afecte el modo como
los usuarios van a utilizar tu código. Sólo tienes que mantener igual la forma de acceder
a él. Estas puertas de acceso que das a los usuarios son lo que se conoce como interfaz.

Poliformismo:

Esta propiedad indica la posibilidad de definir varias operaciones con el mismo nombre,
diferenciándolas únicamente en los parámetros de entrada. Dependiendo del objeto que
se introduzca como parámetro de entrada, se elegirá automáticamente cual de las
operaciones se va a realizar.

Ya está habituado al operador <<suma>> que está presente en todos los lenguajes de
programación. Sin embargo, los operadores <<suma de fracciones>> y <<suma de
números complejos>> no existen en casi ningún lenguaje de programación.

Los lenguajes POO permiten definir un operador <<suma>> tal que reconozca que tipo
de objeto se le está aplicando, a través de operaciones de objetos. Previamente deberá
definir la fracción y el número complejo como una clase y la operación suma como una
operación de una clase. Definiendo adecuadamente la operación suma de fracciones y
suma de números imaginarios, el operador suma devolverá, en el caso que los
operandos sean fracciones, una fracción y en el caso de los números imaginarios, otro
número imaginario. Es posible extender el concepto e incluso definir operaciones como
suma de bases de datos.

6
Herencia:

La herencia es la capacidad que tiene una clase de derivar las propiedades y métodos
de otra. Consiste en la propagación de los atributos y las operaciones a través de
distintas subclases definidas a partir de una clase común. Nos permite crear estructuras
jerárquicas de clases donde es posible la creación de subclases que incluyan nuevas
propiedades y atributos. Estas subclases admiten la definición de nuevos atributos, así
como crear, modificar o inhabilitar propiedades.

Para pensarlo de manera más fácil podemos abstraernos al siguiente ejemplo.

Pensemos en los distintos submodelos asociados a un modelo básico de automóvil. A
partir de este modelo básico, los fabricantes introducen distintas características (aire
acondicionado, ABS, distintas tapicerías, acabados, etc.) que crean subclases. Todas
estas subclases tienen en común la estructura básica (chasis, dirección , etc.) o varían
sólo en algunos de sus componentes.

Asociemos a este tipo básico una clase cuyos atributos representen las piezas que
componen el coche. Las subclases aportarán sus propios atributos (en el caso de
vehículos con aire acondicionado, todas aquellas piezas que lo componen), permitiendo
la definición de todos los posibles modelos.

7
TEMA 2
Tipos de Datos

2.1 Tipos de datos básicos en C

En el manejo del lenguaje C se utilizan diferentes tipos de variables

Variables Numéricas: Diferentes valores numéricos tienen requisitos de

almacenamiento de memoria variables, y difieren en la facilidad con que ciertas
operaciones matemáticas pueden ser ejecutas con ellos.

Los números enteros pequeños ocupan poco espacio de memoria para

almacenamiento, así como las operaciones matemáticas (suma, multiplicación, etc.)
siendo así rápidamente ejecutadas por la computadora.

Los números enteros largos y los valores de punto flotante utilizan más espacio en
almacenamiento, obteniendo una ejecución de operaciones más lentas. Las variables
numéricas del C caen en las dos categorías principales:

 Las variables enteras guardan valores que no tienen fracciones usan únicamente
números enteros. Dentro de las variables enteras existen con signo y sin signo. Las
variables enteras con signo ayudan a guardar valores positivos o negativos, en
cambio las variables enteras sin signo únicamente guardar valores positivos
incluyendo el 0.

 Las variables de punto flotante guardan valores que tienen fracciones (números
reales).

Dentro de estas categorías se encuentran dos o más tipos específicos de variables.

Ellos están resumidos en la siguiente tabla, que también muestra la cantidad de
memoria en bytes que se requiere para guardar una sola variable de cada tipo cuando
se usa una computadora de arquitectura de 32 bits.

El rango aproximado (como se puede ver en la siguiente tabla) significa los valores
máximos y mínimos que puede guardar una variable dada, (por desgracia las
limitaciones de los espacios impiden listar los rangos exactos para cada una de estas
variables).

Precisión significa la cantidad de dígitos con los cuales es guardada la variable.

Al ver la tabla puede darse cuenta de que los tipos de variable int y short son idénticos,
pero eso es solamente en los sistemas compatibles con la PC de IBM de 32 bits, por
que pueden ser diferentes en cualquier otro tipo de Hardware. En un sistema VAX, un
short y un int no son del mismo tamaño, en este caso un short es de dos bytes y un int
es de cuatro.

8
 TIPOS DE VARIABLES

Tipo de variables Palabra Bytes Rango

clave requeridos
Carácter char 1 -128 a 127

Entero int 2 -32768 a 32767

Entero Corto short 2 -32768 a 32767

Entero Largo long 4 -2,147,483,648 a

2,147,483,647
Carácter sin signo unsigned char 1 0 a 255

Entero sin signo unsigned int 2 0 a 65535

Entero corto sin unsigned short 2 0 a 65535

signo
Entero largo sin unsigned long 4 0 a 4,294,967,295
signo
Punto flotante de float 4 1.2E-38 a 3.4E38
precisión sencilla
Punto flotante de double 8 2.2E-308 a 1.8E308
doble precisión
Rango
aproximado;
precisión = 7
dígitos
Rango
aproximado; doble
precisión =19
dígitos

Modificadores de tipo signed, unsigned, short y long.

Hay varios modificadores de tipos fundamentales de datos. Los archivos de

cabecera limits.h, float.h, especifican los valores máximos y mínimos para cada
tipo. Los podemos clasificar en:

 Tipos enteros: char, short, int, long.

 Tipos reales: float, double y long double.
 Otros: void.

Cada tipo puede ser calificado por las palabras clave signed o unsigned, lo que
da lugar a tener disponibles los siguientes tipos extras:

9
 signed char
 unsigned char
 signed short
 unsigned short
 signed int
 unsigned int
 signed long
 unsigned long

Un entero calificado signed es un entero con signo, esto es, un número entero
positivo o negativo. Un número entero calificado unsigned es un número enero
sin signo, el cual es manipulado como un número entero positivo.

Si los calificadores signed y unsigned se utilizan sin un tipo específico, se usa el

tipo int.

Por este motivo las siguientes declaraciones son equivalentes:

signed x;
signed int x;

unsigned y;
unsigned int y;

2.2 Tipo de dato “char”

char (carácter 1 byte)

El tipo char es utilizado para almacenar un valor entero en el rango de -128 a

127, correspondiente a un carácter del código ASCII. Solamente los valores de
0 a 127 son equivalentes a un carácter.
De forma similar el tipo unsigned char puede almacenar valores en rango de 0
a 255, valores correspondientes a los números ordinales de los 256 caracteres
ASCII.

En ASCII C, signed y unsigned char son tipos diferentes.

Ejemplo, char car;

Este ejemplo declara una variable llamada car de tipo char, capaz de contener
un carácter cuyo código ASCII se corresponderá con un valor entero entre 0 y
127. Otros ejemplos son:

char a = ’z’;
signed char b = 0x07;
unsigned char c = 32;

char es la abreviación de signed char.

ocupa 1 byte de memoria

10
1 byte = 8 bits

8 bits = 1 byte

64 32 16 8 4 2 1 Valor de la posición

1 2 3 4 5 6 7 8


NOTA: La palabra bit

bit de signo proviene de:
0=+ binary
1=-
bit
Ejemplo: digit
00000000 = + 0
01111111 = + 127
11111111 = - 127
10000001 = -1
10000000 = -0 = -128

Rango de valores “char”: -128 a +127 (256 valores)

La tabla ASCII tiene 256 caracteres.

11
 PROGRAMA # 1

Usando el tipo de dato unsigned char, desplegar en la pantalla la tabla “ASCII”

#include<conio.h>
#include<string.h>
#include<iostream>
//#include<iomanip.h>

using namespace std;

// PROGRAMA No.1

int main(void)
{
unsigned char c;
cout<<" TABLA ASCII"; cout<<"\n\n\n Este programa despliega en la pantalla la tabla
ASCII";
cout<<"\n En modo caracter y sus valores en decimal y hexadecimal \n\n";
getch();

system("cls");
cout<<"------------------------------------------------------------"<<endl;
cout<<"| CARACTER º DECIMAL º HEXADECIMAL |"<<endl;
cout<<"------------------------------------------------------------"<<endl;

for(c=0;c<255;c++)
{
cout<<endl<<"| "<<c<<" |"<<"\t"<< dec << (int)c <<" |"<< hex << (int)c <<" |";
getch();
}

cout<<endl<<"| "<<c<<" |"<<"\t"<< dec << (int)c <<" |"<< hex << (int)c <<" |";
cout <<endl;
cout<<"----------------------------------------";
getch();
return(0);
}

12
2.3 Tipo de dato “int”

Ocupa 2 ó 4 bytes de memoria dependiendo del procesador (32 ó 64 bytes).

short int (entero formato corto ocupa 2 bytes)

El tipo short proporciona un entero en el rango de valores de: -32768 a +32767

De forma similar el tipo unsigned short puede almacenar valores en el rango de:
0 a 65535.

Ejemplo:

short i, j;

Este ejemplo declara i y j como variables enteras con posibilidad de tomar

valores entre -32768 y 32767. Otros ejemplos son:

shor int a = -500;

signed short b = 1990;
unsigned short int c = 0Xf000;

short es la abreviación de signed short int.

Un entero es para C un número sin punto decimal. El rango de valores depende

de la máquina. Igualmente ocurre con el tipo unsigned int. Para una máquina con
un procesador de 16 bits el rango de valores es de:

-32768 a +32767 para el tipo int.

0 a 65535 para el tipo unsigned.

El uso de enteros produce un código compacto y rápido. Para una máquina de

16 bits. Este tipo es equivalente al tipo short y solamente ocupa 2 bytes de
memoria.

En general:

tamaño (short)  tamaño (int)

int ocupa 2 bytes de memoria

Short( entero formato corto 2 bytes)

13
 2 bytes = 16 bits

16385 8192 4096 2048 1024 512 256 128 64 32 16 8 4 2 1

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

bit de signo
0=+
1=-

Ejemplo: Representación de los valores enteros

0000000000000000 = + 0
0000000000000001 = +1
0111111111111111 = + 32767
1000000000000000 = - 0 = -32768
1111111111111111 = -32767

Rango de valores “int” (2 bytes): -32768 a +32767

unsigned int: Rango de valores de 0 a 65535

Ejemplos:
int a = 2000;
signed int b= -30;
unsigned int c = oxf003;

int es lo equivalente de signed int.

14
 PROGRAMA #2

Programa que sirve para simular el movimiento de un carácter

#include<conio.h>
#include<string.h>
#include <stdio.h>
#include<iostream>
#include<time.h>
#include<ctime>

using namespace std;

void delay(int secs)

{
for(int i = (time(NULL) + secs); time(NULL) != i; time(NULL));
}

/* La función time(NULL) nos devuelve el segundo exacto en que estamos.

1. Si le sumamos cierta cantidad de segundos obtenemos una fecha en el futuro.
2. En cada vuelta del ciclo se checa si esa fecha en el futuro es diferente a la fecha
actual.
3. En cuanto las dos fechas son iguales el ciclo acaba y el programa continúa.*/

// PROGRAMA No.2

int main(void)
{

int i, j;
int xmin=1,xmax=15,ymin=1,ymax=3;
system("cls");
cout<<"\t\t\t\t\tMANEJO DE DATOS ENTEROS\n\t\SIMULACION DE
MOVIMIENTO\n\n";
cout<<"\n\n\t\tpresione cualquier tecla para continuar";
getch();
system("cls");

for(j=ymin; j<ymax;j++)
{
for(i=xmin;i<=xmax;i++)
{ cout<<">"; delay(1);
cout <<"\b ";
}cout<<endl;
}
cout<<"\n FIN";
getch();

cout<<"\nfin del programa \n\n\n\n\n\npresione cualquier tecla para salir";

getch();
}

15
2.4 Tipo de dato “long”
(entero largo 4 bytes)

Este tipo de números es idóneo para aplicaciones de gestión. Al igual que los
enteros, son números sin punto decimal comprendidos en el rango de:
 -2147483648 a 2147483647 para tipo long.
 0 a 4294967295 para el tipo unsigned long.
En general:
tamaño (int)  tamaño (long).

2.6 Tipo de dato “double”

(Reales en doble precisión.- 8 bytes)

Un número real en doble precisión es uno que puede tener un punto decimal y
puede estar comprendido en el rango de:

-1.79769E+308 a -2.22507E-308 para números negativos.

2.22507E-308 a 1.79769 E+308 para números positivos.

Un número real en doble precisión tiene 16 dígitos significativos. Estos dan

lugar a cálculos más exactos que en simple precisión.

Ejemplo:

double x;

Este ejemplo declara la variable x de tipo real en donde precisión. Otros

ejemplos son:

double a= 3.1415926;
double b= 2.2 e-8

2.7 Tipo de dato “long double”

(Reales en doble precisión formato largo.- 10 bytes)

Los valores para este tipo están comprendidos en el rango de:

-1.189731E+4932 a -3.362103E-4932 para números negativos.

3.362103E-4932 a 1.189731E+4932 para números positivos.

16
Un número real en doble precisión formato largo no tiene más de 19 dígitos
significativos. Esto da lugar a cálculos más precisos que en doble precisión.
Ejemplo:

long double x;
long double>’=3.17e+425;

2.5 Tipo de dato “float”

Ocupa 4 bytes de memoria

4 bytes = 32 bits

float (reales en simple precisión.- 4 bytes)

IBM = FORMATO IBM DE PUNTO FLOTANTE

DIGITAL = FORMATO VAX
IEEE = FORMATO IEEE DE PUNTO FLOTANTE

Estos números son los más recurridos en un lenguaje de programación. Un real

en simple precisión es un número que puede tener un punto decimal y que puede
estar comprendido en el rango de:
-3.402823E+38 a -1.175494E-38 para números negativos.
1.175494E-38 a 3.402823E+38 para números positivos.

Un número real en simple precisión no tiene más de 7 dígitos significativos.

Ejemplo:

float x;

Este ejemplo declara la variable x de tipo real en simple precisión. Otros

ejemplos son:

float a = 3.14159;
float b = 2.2 e-8;

2.8 Representación en punto flotante

Existen varias formas de almacenar en la memoria, un dato en punto flotante.

Una de ellas es la que se trata aquí.

Las computadoras representan los números reales utilizando una notación

semejante a la conocida notación científica normalizada

17
Signo exponente signo exponente

+ 0.602 X 10 -22 + 0.101110 X 2 -1100

Mantisa base Mantisa base

NOTACIÓN CIENTÍFICA NORMALIZADA REPRESENTACIÓN EN UN PUNTO

FLOTANTE NORMALIZADA

En todo número en punto flotante se distinguen cuatro componentes:

SIGNO: Indica el signo del número (0= positivo, 1= negativo)

MANTISA: Contiene la magnitud del número (en binario puro)
EXPONENTE: Contiene el valor de la potencia de la base (notación exceso)
BASE: Queda implícita y es común a todos los números (habitual base 2)

Otras alternativas menos extendidas para la representación de los números

reales

 Notación punto fijo (primeros computadores)

 Ciertas representaciones involucran el almacenamiento de los logaritmos de
un número (las multiplicaciones se pueden implementar mediante sumas).
 Notación racional: se utilizan dos números enteros (a, b) para representar la
fracción a/b.

Un mismo número puede tener varias representaciones (0.11.2 5= 110.22=

0.0110.26). Los números suelen estar normalizados. Un número esta
normalizado en base dos si tiene la forma:

0.1 XXXXXXXX 2XXX

Tienen siempre un 1 a la izquierda
Se pueden almacenar de forma
implícita
1. XXXXXXXX 2XXX

FORMATO DE PUNTO FLOTANTE DE 32 BITS

1 bit 8 bits 23 bits

sig exponente mantisa

32 bits

18
El rango de valores representable por cada uno de los campos es:

 Exponente (8 bits en exceso 128): -128 … +127

 Mantisa (23 bits normalizados 1.M): los valores binarios representables
oscilan entre 1.00…0 y 1.11…1. (1 y 2-2-23)

OVERFLOW Y UNDERFLOW:

Overflow

Es una situación de «overflow» aquélla en la que hemos sobre pasado las

capacidades de que disponemos cuando, por ejemplo, el ordenador nos
indica que no dispone de memoria suficiente para responder a un
requerimiento concreto que le hemos pedido. Un ejemplo más gráfico es el
de una elemental calculadora de 8 dígitos que no puede mostrar en su
pantalla el resultado de una operación en cientos de millones.

Underflow

Es un estado de «underflow» aquel que resulta de la pretensión de operar con

cantidades demasiado pequeñas.

La cantidad de números representables es 232. El espacio de representación

no es uniforme: mayor densidad cerca de o!!

││││││││││││ │││││ ││││││││││ ││││││ │ │ │ │ │ │ │

-n 0 n 2Xn 4Xn

PRECISIÓN: Depende del número de bits de la mantisa. Con 23 bits es

imposible distinguir entre 2 números que se diferencien en 2-23=10-7.
Precisión 23 bits, precisión 7 dígitos decimales, Epsilon (eps) del computador: 2 -
23

PUNTO FLOTANTE IEEE

El punto flotante es un método muy útil para realizar operaciones numéricas

cuando estas tienen una magnitud muy diferente, el microprocesador 8088 no
posee en forma nativa la posibilidad de su uso, se deben recurrir a emuladores

19
o coprocesadores para poder usarlos, y si bien actualmente todas las PC que
podemos encontrar poseen coprocesadores, no pasa lo mismo con los
microcontroladores que en su mayoría no lo soporta.
Si bien el ensamble posee emuladores de coma flotante, lo que se intenta, es
que se comprenda el uso del punto flotante para luego poder ser utilizado en
cualquier microprocesador o microcontrolador que no posee ninguna
característica de manejo para estos números.

Componentes
Un número flotante esta formado por:

- 1 . 10111 X 21101

Exponente
Mantisa (parte decimal)

Mantisa (parte entera)

Signo

Cada una de estas partes del punto flotante tendrán una ubicación determinada
dentro de la codificación del número, y su longitud detendrá el tipo del número.

EXPONENTE

El exponente de un número de punto flotante es modificado antes de su

almacenamiento.
El número a almacenar en la posición del exponente será igual a:

eieee = e + 2m-1 -1

Donde e será el exponente real y me es el número de bits del exponente en el

formato elegido. Esta modificación se realizara para evitar el uso de un bit de
signo, lo que permite realizar comparaciones mas fácil entre exponentes, dado
que estamos sumando 2m-1 -1 que es igual a sumar la mitad del máximo valor
que se puede almacenar en el exponente.

MANTISA

La mantisa debe cumplir 1 = mantisa<2. Por lo tanto la parte entera será siempre
1 y solo será guardada en el número la parte decimal justificada a la derecha (un
caso particular es el 10 – byte real, en el cual el campo de parte entera existe, y
siempre valdrá 1).

20
Signo

1 = NEGATIVO
0 = POSITIVO

TIPOS

SHORT REAL NUMBER

Signo: 1 bit
Exponente: 8 bits
Mantisa (parte decimal): 23 bits
Total: 32 bits (4 bytes).

Como la parte entera es siempre 1 directamente lo asume y no lo incluye en la

codificación

LONG REAL NUMBER

Singo: 1 bit
Exponente: 11 bits
Mantisa (parte decimal): 52 bits
Total: 64 bits (8 bytes)

Como la parte entera es siempre 1 directamente lo asume y no lo incluye en la

codificación.

21
2.9 Aritmética de punto flotante

Pase de un número real a Short Real IEEE.

Dado un número lo pasaremos a punto flotante en base 2

X=3.625
El número será de la forma (-1)5 X f X 2e.

Al ser el número del ejemplo positivo entonces ya tenemos la primera incógnita

s=0, f deberá ser un número cuya parte entera sea 1 por lo tanto debe cumplir
que 1<=f<2

Sacamos el exponente
f X 2e = 3.625

e= int ( ln(3.625)/ ln (2) )

= int(1.85798)
e =1

Dado que 3.625 = f X 21, entonces f= (3.265/ 21 )=1.8125.

Pasamos el resultado a base 2
Parte entera = 1

Parte decimal:
0.8125 X 2 = 1.625 entero =1
0.625 X 2 = 1.25 entero =1
0.25 X 2 = 0.5 entero =0
0.5 X 2 = 1 entero= 1

f= 1.1101

resultado:

x=(-1)0 X 1.1101 X 21

2.10 Representación en formato estándar IEEE (short real)

Signo= 0
Mantisa = 110100000000000000000002
Exponente:
exp= 1 +27 -1= 1 +127 = 128
exp= 100000002

Resultado
x= 3.625
x= 1.1101x21
22
x= 0_10000000_11010000000000000000000
x=4068000016

2.11 Pase de entero a short real IEEE

Si quisiéramos realizar un programa que transformara un número apto flotante

este generalmente sería entero, por lo tanto aquí describiremos un método más
sencillo de pasar de entero apto flotante para ser aplicado a un programa.

A modo de ejemplo necesitamos almacenar el número 2356 en formato punto

flotante tipo short real de 32 bits.

Primero debemos realizar una función que almacene el valor en el número. Está
función realizará lo siguiente:
 carga el bit de signo con el signo del número.
 guarda en la mantisa el valor ABSOLUTO del número.
 Calcular el exponente y guardarlo en el campo correspondiente.

Para la realización del cálculo del exponente deberemos saber primero como
estamos almacenando el número.

Hasta ahora tenemos:

0 00000000 00000000000 100100110100

Donde 235610 = 1001001101002

La mantisa ingresada corresponde a la parte decimal del número por lo tanto el

número nos quedaría expresado como:

x = 1,000000000001001001101 x 2e

Esto significa que el exponente no puede ser 0, sino que será un número que
recorra la coma a la derecha tantos lugares como longitud de mantisa tenga,
para este caso serán 23, además sabemos que el valor a almacenar en el campo
de exponente es

exp = 23 + 127 = 150

0 10001010 00000000000100100110100

Una vez hecho esto debemos realizar otra operación llamada normalización.
Esta operación realiza sucesivos shift register a la izquierda al mismo tiempo

23
que se decrementa el exponente hasta que el shift register provoque el desborde
de un uno.

Esto es necesario porque como ya vimos este formato supone la existencia de

un uno como parte entera, condición que no respetaba el número que
ingresemos.
Quedando el número final como:

0 10001010 00100110100 000000000000

2.12 Tipo de dato “void”

El tipo void se utiliza para declarar funciones que no retornan un valor o para
declarar un puntero a un tipo no especificado. Si void aparece entre paréntesis
a continuación del nombre de una función, no es interpretado como un tipo, en
este caso indica que la función no acepta argumentos.

Ejemplo:

double fx(void);
double fy(void);
void *p;

Este ejemplo declara la función denominada fx como una función sin argumentos
que devuelve un valor de tipo real de doble precisión; la función fy, como una
función sin argumentos que no devuelve valor alguno; y un puntero p a un objeto
de un tipo especificado.

PROGRAMA #3

24