TIPOS DE DATOS
ESTRUCTURAS DE DATOS
OBJETIVOS

Manejo correcto y apropiado de punteros y reserva de
memoria dinámica

Reconocer el tipo de dato void y void * en C como una
herramienta de potencial importancia

Diferenciar entre arreglos y estructuras

Utilizar correctamente las estructuras, punteros a
estructuras, arreglos de estructuras, etc.
DATO

Información en bruto, sin ningún significado

Dado un enunciado, evento o acción, los datos


Permiten representar sus actores o participantes

Analizándolos, se podrá obtener resultados deseados
Analicemos el siguiente hecho:


El estudiante de nombre Pedro Velez de 22 años, tiene un promedio de 7.5
Podemos tomar los siguientes datos

Nombre: Pedro Velez -> Conjunto de Caracteres

Edad: 22
-> entero

Promedio: 7.5
-> real
INFORMACIÓN
Es el resultado deseado luego de procesar los datos
 Los datos, al ser procesados, se convierten en
información útil o resultados.

Datos de salida(se muestran
en el monitor)
Empleado
Horas
Juan, Perez
160
Pedro, Rodriguez
155
Juan, Perez
$320
Luis, Pozo
120
Pedro, Rodriguez
$310
Luis, Pozo
$240
Valor por hora = $2
Datos de entrada(ingresados x
teclado)
Procesamiento:
Calcular salarios
¿Cómo representar los datos?

Los seres humanos:


Usamos lenguaje natural o símbolos
Ejemplo:



Para representar números, usamos el sistema decimal
Para representar palabras, usamos el abecedario
La computadora:
Usa conjuntos de 1s y 0s
 El dato mas pequeño en el computador es



Un 1 o un 0 -> bit
El conjunto de 8 bits -> 1 byte
TIPOS DE DATOS

Los datos se clasifican en TIPOS

Son los diferentes dominios existentes. Ejemplo:

Edad, Año de Nacimiento, Numero de multas


Nombre, Dirección, Num. Cedula,


Tienen dominio numérico
Caen en el dominio de la información tipo texto
Y las operaciones permitidas para dicho dominio
Un conjunto de valores y operaciones
definidas solo para esos valores
RECORDAR



Un tipo de dato es el conjunto de valores

Al que puede pertenecer una constante

Que puede asumir una variable o expresión

Que puede ser generado por una función
De una constante, variable o expresión

Se puede deducir su tipo de dato

Ya sea de su forma o de su declaración

Sin necesidad que se ejecute ningún proceso
Las operaciones entre datos

Necesitan participantes (argumentos) de determinado tipo

Producen resultados de otro o el mismo tipo
TIPOS DE DATOS BASICOS

Los podemos distinguir fácilmente, están en el diario vivir:


El Sr. Vera de 63 años tiene cedula No. 0908815533, y paga $120 de
impuestos
Son tipos de datos simples

Que permiten representar información numérica, caracteres, etc.
NOMBRE
CONJUNTO DE VALORES
OPERACIONES
Enteros
Negativos y positivos sin decimal
Sumar, restar, dividir, multiplicar,
residuo
Reales
Negativos y positivos, con decimal
Sumar, restar, dividir, multiplicar
Lógicos
Verdadero o Falso(1 o 0)
And, Or, Not
Caracteres
Letras, números, especiales, juntos
forman una cadena
Sumar carácter + entero restar,
multiplicar por entero
Y EN LA COMPUTADORA?
1000
1001
 En la computadora
1002
 Cada byte es un casillero y tiene una dirección en memoria
1003
 Los datos (números y letras) se almacena en estos

Solo vienen integrados los tipos de datos básicos
casilleros


¿Cuantas casilleros ocupa un dato?

Depende de su tipo y del hardware de la computadora

Un entero puede ocupar casillas de hasta 4 bytes

Un doble siempre ocupara mas, por su mayor precisión
PERO, un carácter SIEMPRE ocupara casillas de 1 byte
ALMACENANDO DATOS
TIPO DE DATO
#bytes
Representación interna
En ANSI C
ENTEROS
2
4
8
Positivos: conjunto de bits
38 -> 00100110
Negativos:Complemento a Dos
-38 -> 11011001
int
long
REALES
8
16
Mantisa x base(exponente)
387.53 -> 38753 x 10-2
00000000100101110110000111111110
float
double
CARACTERES
1
ASCII
11000000 -> ‘A’
char
DECLARACION DE
VARIABLES

Una declaración de variables en C incluye

Tipo de dato y

Nombre de variable(identificador)

Ejemplo:
int a, b;
float c;

Al declarar una variable se
le asigna espacio en
memoria y una dirección
para dicho espacio
int a;
char c;
¿Para que se declaran variables?

Especifica cuanta memoria debe reservarse y

Como se van a interpretar dichos datos
f = a + b

Es una suma de enteros, que al final se convierte a real
100
101
102
103
104
4 bytes,
dir: 100
1 byte,
dir: 104
DIRECCIONES DE
MEMORIA

Las variables


Si deseamos conocer dicha dirección



Tienen direcciones de memoria
En lenguaje C
Se usa el operador & de dirección
Ejemplo:
int a;
a = 3;
printf(“Valor:%d Dir: %d”, a, &a);

Un puntero

Es una variable que puede almacenar dirección de
memoria
1000
1001
1002
1003
&a es
1000
DECLARACION DE
PUNTEROS
int *p;

Un tipo de dato


El puntero solo podrá almacenar direcciones de
memoria de variables del tipo especificado
Se pueden definir punteros de cualquier tipo:
float *pf;
3
x
1000 pt
Un identificador que siempre va antecedido del operador *
char *pc;

1000
1001
1002
1003
1004
1005
int *pt, x;
x = 3;
pt = &x;
pt almacena la
dirección de x, se dice
que pt apunta a x
CONSULTANDO CONTENIDO


Si un puntero apunta a una variable

A través del puntero se puede llegar a conocer todo sobre la variable

Ejemplo:
char c, *pc1, *pc2;
pc1 = &c;
Si quiero conocer la dirección, uso directamente el puntero
printf(“%d”, pc1); //Imprimo la dir. Almacenada por pc1
pc2 = pc1; //pc2 almacena la misma dir. que pc1

Si quiero conocer el contenido al que apunta un puntero, uso el
Es equivalente a :
operador *, sobre dicho puntero
printf(“%c”, c);
Ejercicio
c = ‘A’
printf(“%c”, *pc1);
*pc1 = ‘N’
printf(“%c”,c);
Es equivalente a :
c = ‘N’
Imprime ‘N’ pues c ya
cambio
EJERCICIO EN CLASE
int x,y;
int *p1,*p2;
x = -42;
y = 163;
p1 = &x;
p2 = &y;
*p1 = 17;
*p2 = x+5;
1000
-42
17
22
x
1004
163
22
y
1008
1000
1004
0
1000
1004
p1
1012
1004
0
1004
p2
*p1 = *p2;
p1 = p2;
p1 = NULL;
p2 = NULL;
Es equivalente a escribir
x = y;
Esto indica que p1
ahora apunta a la
misma variable que p2
Esto es equivalente a “encerar” el
puntero, y decir que no apunta a ninguna
variable
PASO DE PARAMETROS


Las funciones son porciones de código

Ejecutan una tarea especifica

Usualmente toman datos de entrada->parámetros

Y retornan un valor
Los parámetros se pueden enviar de dos formas:

Por valor

Por referencia
PASO POR VALOR

La función no recibe la variable enviada


Recibe una copia
Similar a cuando va al hacer algún tramite y le piden al cédula




No entrega la cédula verdadera
Entrega una copia
La verdadera estará segura, aunque quemen y destruyan la copia
Ejemplo:
x = 5
printf(“%d\n”,x);
funct(x);
printf(“%d\n”,x);
void funct(int y){
y = y+1;
printf(“%d\n”,y);
}
Se imprime 5, el valor de x no
cambia aunque la función haya
intentado modificarla
PASO POR REFERENCIA

Aquí si la función recibe exactamente la variable enviada




No hay copias
Si algo se le hace al parámetro, se le esta haciendo a la variable
Para esto, se usan punteros
La función trabaja con un puntero a la variable enviada


Sabe todo sobre esa variable y se pude acceder a través de *
Ejemplo:
Ejercicio
x = 5
printf(“%d\n”,x);
funct(&x);
printf(“%d\n”,x);
Se imprime 6, el valor de x cambió
dentro de la función
void funct(int *py){
*py = *py+1;
printf(“%d\n”,*py);
}
TIPOS DE DATOS
COMPUESTOS

En ocasiones se necesitan
tipos de datos mas complejos,
y estructurados

Variables que almacenen mas de
un valor

Variables que representen
información de la vida real


Estarán formados a partir de
tipos de datos simples
En C, tenemos:
TIPO
FORMATO
DECLARACION
Bytes
ARREGLOS
int arrEj[10];
10*2 = 20
ESTRUCTURAS typedef struct TReg{
int ID;
char Texto[100];
2 + 100 =
102
}Reg;
UNIONES
typedef union TUn{
int ID;
char Texto[100];
}Un;
100
ARREGLOS

Conjunto de elementos

Finito, Ordenado y Homogéneo,


Todos sus elementos son del mismo tipo
Un arreglo estático se declara
int A[100];



El tipo de los elementos, el identificador y
El numero de elementos (dimensión)
Cada elemento del arreglo tiene un índice


0
1
2
En C, siempre el índice mas pequeño es el 0: limite inferior
El limite superior, es 1 menos que la dimensión


A
Si el arreglo tiene 100 elementos, el índice mas alto es el 99
Y si un entero ocupa 4 bytes, el arreglo ocupa 400 bytes
seguidos
3
4
... 99
OPERACIONES
Tipo de dato:
Conjunto de valores y operaciones
definidas solo para esos valores

No basta con la declaración, para ser tratado como un tipo
de dato

Faltan las operaciones para actuar sobre él

Consulta de un elemento
//Consulto el contenido de los elementos 4 y 5 de A
printf(“%d %d”,A[4], A[5]);

Modificación de un elemento
A[3] = 2; //Almaceno un valor en el elemento 3 de A
for(i = 0; i < 100; i++)
A[i] = 0;
REPRESENTACION INTERNA

Cuantos bytes ocupa un tipo de dato o variable?


En C lo indica el operador sizeof
Ejemplo:
int a;
printf(“%d %d”, sizeof(int), sizeof(a));

El computador internamente



1000
1008
Lista[1]
1016
Lista[2]
No almacena la dirección de todos los elementos del
1024
arreglo
Solo almacena la dirección del primer elemento
1032
El resto lo calcula así:
&Lista[i]
Lista[0]
-> &Lista[0] + (i*sizeof(Lista[0]))
Lista[3]
Lista[4]
RESERVA DE MEMORIA
DINAMICA



La declaración de una variable
a no apunta a otra
variable, tiene
memoria propia,
solo para el

Siempre reserva memoria

Aunque la variable no se use, ya se reservo memoria para ella: ESTATICA
Si deseamos reservar memoria, pero no en la declaración

Si no, a voluntad dentro del programa

La reserva seria dinámica
En C se usan

Punteros y

Las funciones de librería
int *a; //No se reserva nada
..
/*Cuando se desee, se reserva*/
a = malloc(sizeof(int));
//La variable normalmente
*a = 3;
#include <stdlib.h>
void *malloc(size_t size);
ARREGLOS DINAMICOS

En ocasiones deseamos usar arreglos



Donde no hayamos “predefinido” cuantos elementos max. tendremos
Queremos usar arreglos dinámicos
Se declara el arreglo “potencial”:
int *arreglo;

Dentro del programa, se pide memoria cuando se necesite:
arreglo = malloc(sizeof(int)*20);
main(){
Para indicar el nuevo tamaño se puede
usar una constante o una variable,o
cualquier expresión
int *arreglo, n;
printf(“Ingrese el tamaño del arreglo:”);
n = GetInteger();
arreglo = malloc(sizeof(int)*n);
printf(“Ahora tiene %d elementos para trabajar\n”,n);
...
}
Y LIBERA..
Al pedir memoria dinámicamente
 Se debe liberar dentro del programa
 En C se libera usando la función free

int *a;
Cuando se
libera para
una
variable
a = malloc...;
…
free(a);
Ejercicio
ARITMETICA DE PUNTEROS

Los operadores + y –



Se pueden usar con punteros
Pero el significado de la operación cambia un poco
Si un entero ocupa 4 bytes, tomemos este ejemplo
int x;
int *p;
p = &x;

La suma indica que p se mueva 2
“enteros” mas adelante
Cada entero equivale a 4 bytes
100 + 2*4 = 108
Si la dirección de x es un valor 100 y decimos
p = p+2;

Que dirección almacena pi?
102
108
104
p2
EJERCICIO EN CLASE
main(){
double Lista[3];
double *p,*p1,*p2;
int k;
Lista[0] = 1;
Lista[1] = 1.1;
Lista[2] = 1.2;
p = Lista;
p = p + 2;
printf(“%d”, *p);
p = p - 1;
printf(“%d”, *p);
p1 = Lista+2;
p2 = &Lista[0];
k = p1-p2;
printf(“%d”, k);
}
Ejercicio
p
1000
1
Lista[0]
1008
1.1
1016
1.2
p se mueve 2
desfases
p retrocede un
desfase
Da el total de desfases
entre p1 y p2
Lista[1]
Lista[2]
p1
PASO DE ARREGLOS A
FUNCIONES

Al pasar un arreglo a una función debe tomarse en cuenta



¿Necesitare también el tamaño del arreglo?
Si es así, también debe incluirse como parámetro
En prototipos y cabecera
float CalcPromedio(float A[], int size);
float funct(float B[]);

En el cuerpo de la función
float CalcPromedio(float A[], int size){
…..
A[i] = 3;
}

Siempre recuerde que

El paso de arreglos, es un paso por referencia
Ejercicio
ARREGLOS
BIDIMENSIONALES
La programación ofrece innumerables opciones
 Un elemento de un arreglo, puede ser otro arreglo

int A[3][3];
 A[3] es un arreglo de tres elementos
 Cada elemento es otro arreglo de 3 elementos enteros

int A[3][3];
Ejercicio
(0,0) (0,1)
(0,2)
A[0]
A[0][0] A[0]1] A[0][2]
(1,0) (1,1)
(1,2)
A[1]
A[1][0] A[1][1] A[1][2]
(2,0) (2,1)
(2,2)
A[2]
A[2][0] A[2][1] A[2][2]
ESTRUCTURAS o REGISTROS

Es un grupo de “componentes”. Cada componente

Tiene su propio identificador, y

Se conoce como “elemento” o “campo” de la estructura

Ejemplo:

Es la declaración del nuevo “tipo de dato”: NombreCompleto

Con este tipo de dato, podremos crear “variables”:
typedef struct TNombreCompleto{
char Primero[10];
char Inicial;
char Ultimo[10];
}NombreCompleto;
NombreCompleto snombre, enombre;
USANDO ESTRUCTURAS

snombre es una variable de tipo NombreCompleto

Tiene la misma forma que la del nuevo tipo de dato

Cada miembro/campo ocupa memoria

Para acceder a un campo, se indica,

La variable seguida de un punto y del nombre del campo. Ejemplo
snombre.Inicial = ‘L’;
Los registros de tipo
NombreCompleto, tendrán la
misma “estructura”
Cada dato tiene diferente
tamaño y espacio en
memoria
Cada dato representa una
información diferente
snombre
primero
ultimo
inicial
Ejercicio
UNIONES

Permite que una variable se interprete de varias formas distintas,
dependiendo de la necesidad

En una estructura


Siempre es válido referirse a cualquier miembro de la misma

Si hay n miembros, hay n cajones de memoria
En una unión

Solo trabajaremos con un miembro a la vez

Hay un solo cajón de memoria, capaz de almacenar al mas grande de los
miembros

Si el elemento escogido es mas pequeño, sobrara espacio
UNIONES
typedef enum {Entero, Real} Tdato;
typedef union ValorPolimorifco{
int valor_entero;
float valor_real;
typedef union ValorPolimorifco{
Tdato tipo;
int valor_entero;
float valor_real;
};
};
ValorPolimorfico a;
ValorPolimorfico a;
printf(“Tipo de dato:”);
a.valor_entero = 9;
a.tipo = GetInteger();
a.valor_real = 8.9;
if a.tipo == Entero then
a.valor_entero = 9;
elseif a.tipo == Real then
a.valor_real = 8.9;
AMBITO DE VARIABLES



Los parámetros y variables, dentro de una función,

Son variables con ámbito local

Solo son validas en ese ambiente,
Las variables también pueden tener un ámbito “global”

Empiezan a existir desde su declaración, y

Son liberadas con el alcance de un archivo: variables externas
Para darle privacidad a una variable

Para que no pueda ser vista por otros archivos,

Se la declara static, con ámbito global para archivo únicamente
Descargar

INTRODUCCION A LAS ESTRUCTURA DE DATOS