estructura de datos

1. TIPOS DE DATOS
ESTRUCTURAS DE DATOS

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

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

4. INFORMACIÓN
 Es el resultado deseado luego de procesar los datos
 Los datos, al ser procesados, se convierten en
información útil o resultados.
Procesamiento:
Calcular salarios
Juan, Perez $320
Pedro, Rodriguez $310
Luis, Pozo $240
Datos de salida(se muestran
en el monitor)
Datos de entrada(ingresados x
teclado)
Juan, Perez
Pedro, Rodriguez
Luis, Pozo
160
155
120
Empleado Horas
Valor por hora = $2

5. ¿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

6. TIPOS DE DATOS
 Los datos se clasifican en TIPOS
 Son los diferentes dominios existentes. Ejemplo:
 Edad, Año de Nacimiento, Numero de multas
 Tienen dominio numérico
 Nombre, Dirección, Num. Cedula,
 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

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

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

9. Y EN LA COMPUTADORA?
 Solo vienen integrados los tipos de datos básicos
 En la computadora
 Cada byte es un casillero y tiene una dirección en memoria
 Los datos (números y letras) se almacena en estos
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
1000
1001
1002
1003

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

11. 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;
 ¿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
Al declarar una variable se
le asigna espacio en
memoria y una dirección
para dicho espacio
int a;
4 bytes,
dir: 100
1 byte,
dir: 104
100
101
102
103
104
char c;

12. DIRECCIONES DE
MEMORIA
1000
1001
1002
1003
&a es
1000
 Las variables
 Tienen direcciones de memoria
 Si deseamos conocer dicha dirección
 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

13. DECLARACION DE
PUNTEROS
 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;
char *pc;
 Un identificador que siempre va antecedido del operador *
pt almacena la
dirección de x, se dice
que pt apunta a x
x
pt
int *p;
1000
1001
1002
1003
1004
1005
1000
int *pt, x;
x = 3;
pt = &x;
3

14. CONSULTANDO CONTENIDO
 Si un puntero apunta a una variable
 A través del puntero se puede llegar a conocer todo sobre la variable
 Ejemplo:
c = ‘A’
printf(“%c”, *pc1);
*pc1 = ‘N’
printf(“%c”,c);
Es equivalente a :
printf(“%c”, c);
Es equivalente a :
c = ‘N’
Imprime ‘N’ pues c ya
cambio
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
operador *, sobre dicho puntero
Ejercicio

15. EJERCICIO EN CLASE
*p1 = *p2;
int x,y;
int *p1,*p2;
x = -42;
y = 163;
p1 = &x;
p2 = &y;
*p1 = 17;
*p2 = x+5;
1000
1004
Es equivalente a escribir
x = y;
p1 = p2; Esto indica que p1
ahora apunta a la
misma variable que p2
1004
p1 = NULL;
p2 = NULL; Esto es equivalente a “encerar” el
puntero, y decir que no apunta a ninguna
variable
1000
1004
1008
1012
x
y
p1
p2
-42
22
1000
1004
17
22
0
0
163
1004

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

17. 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(“%dn”,x);
funct(x);
printf(“%dn”,x);
void funct(int y){
y = y+1;
printf(“%dn”,y);
}
Se imprime 5, el valor de x no
cambia aunque la función haya
intentado modificarla

18. 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: x = 5
printf(“%dn”,x);
funct(&x);
printf(“%dn”,x);
void funct(int *py){
*py = *py+1;
printf(“%dn”,*py);
}
Se imprime 6, el valor de x cambió
dentro de la función
Ejercicio

19. 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];
}Reg;
2 + 100 =
102
UNIONES typedef union TUn{
int ID;
char Texto[100];
}Un;
100

20. 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
 En C, siempre el índice mas pequeño es el 0: limite inferior
 El limite superior, es 1 menos que la dimensión
 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
0 1 2 3 4 ...
A
99

21. OPERACIONES
 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;
Tipo de dato:
Conjunto de valores y operaciones
definidas solo para esos valores

22. REPRESENTACION
INTERNA
1000
1008
1016
1024
1032
Lista[0]
Lista[1]
Lista[2]
Lista[3]
Lista[4]
&Lista[i] -> &Lista[0] + (i*sizeof(Lista[0]))
 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
 No almacena la dirección de todos los elementos del
arreglo
 Solo almacena la dirección del primer elemento
 El resto lo calcula así:

23. RESERVA DE MEMORIA
DINAMICA
 La declaración de una variable
 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
#include <stdlib.h>
void *malloc(size_t size);
int *a; //No se reserva nada
..
/*Cuando se desee, se reserva*/
a = malloc(sizeof(int));
//La variable normalmente
*a = 3;
a no apunta a otra
variable, tiene
memoria propia,
solo para el

24. 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); Para indicar el nuevo tamaño se puede
usar una constante o una variable,o
cualquier expresión
main(){
int *arreglo, n;
printf(“Ingrese el tamaño del arreglo:”);
n = GetInteger();
arreglo = malloc(sizeof(int)*n);
printf(“Ahora tiene %d elementos para trabajarn”,n);
...
}

25. Y LIBERA..
 Al pedir memoria dinámicamente
 Se debe liberar dentro del programa
 En C se libera usando la función free
int *a;
a = malloc...;
…
free(a);
Cuando se
libera para
una
variable
Ejercicio

26. 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;
 Si la dirección de x es un valor 100 y decimos
p = p+2;
 Que dirección almacena pi?
102 108 104
La suma indica que p se mueva 2
“enteros” mas adelante
Cada entero equivale a 4 bytes
100 + 2*4 = 108

27. 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);
}
1000
1008
1016
Lista[0]
Lista[1]
Lista[2]
p
p2
p1
p se mueve 2
desfases
p retrocede un
desfase
Da el total de desfases
entre p1 y p2
1
1.1
1.2
Ejercicio

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

29. 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
(0,0) (0,1) (0,2)
(1,0) (1,1) (1,2)
(2,0) (2,1) (2,2)
A[0]
A[1]
A[2]
A[0][0]
A[1][0]
A[2][0]
A[0]1]
A[1][1]
A[2][1]
A[0][2]
A[1][2]
A[2][2]
int A[3][3];
Ejercicio

30. 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”:
NombreCompleto snombre, enombre;
typedef struct TNombreCompleto{
char Primero[10];
char Inicial;
char Ultimo[10];
}NombreCompleto;

31. USANDO ESTRUCTURAS
primero inicial
ultimo
snombre
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 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’;
Ejercicio

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

33. UNIONES
typedef union ValorPolimorifco{
int valor_entero;
float valor_real;
};
ValorPolimorfico a;
a.valor_entero = 9;
a.valor_real = 8.9;
typedef union ValorPolimorifco{
int valor_entero;
float valor_real;
Tdato tipo;
};
ValorPolimorfico a;
printf(“Tipo de dato:”);
a.tipo = GetInteger();
if a.tipo == Entero then
a.valor_entero = 9;
elseif a.tipo == Real then
a.valor_real = 8.9;
typedef enum {Entero, Real} Tdato;

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