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.

Empleado Horas Datos de salida(se muestran

Juan, Perez 160 en el monitor)
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
 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
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 Sumar carácter + entero restar,
forman una cadena multiplicar por entero
Y EN LA COMPUTADORA?
 Solo vienen integrados los tipos de datos básicos 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
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 Positivos: conjunto de bits int

4 38 -> 00100110 long
8 Negativos:Complemento a Dos
-38 -> 11011001
REALES 8 Mantisa x base(exponente) float
16 387.53 -> 38753 x 10-2 double
00000000100101110110000111111110
CARACTERES 1 ASCII char
11000000 -> ‘A’
DECLARACION DE Al declarar una variable se
le asigna espacio en

VARIABLES memoria y una dirección

para dicho espacio

 Una declaración de variables en C incluye

 Tipo de dato y
 Nombre de variable(identificador) 100
4 bytes,
int a; 101
 Ejemplo: dir: 100
102
int a, b; char c; 103
1 byte,
104
float c; dir: 104

 ¿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
DIRECCIONES DE
MEMORIA
 Las variables
 Tienen direcciones de memoria
 Si deseamos conocer dicha dirección
 En lenguaje C
 Se usa el operador & de dirección
1000
&a es
 Ejemplo: 1001 1000
int a;
a = 3; 1002
printf(“Valor:%d Dir: %d”, a, &a);
1003
 Un puntero
 Es una variable que puede almacenar dirección de
memoria
DECLARACION DE
PUNTEROS
int *p;
 Un tipo de dato
 El puntero solo podrá almacenar direcciones de
memoria de variables del tipo especificado
1000
 Se pueden definir punteros de cualquier tipo: 1001 3 x
1002
float *pf; 1003
char *pc; 1000 pt
1004
1005

 Un identificador que siempre va antecedido del operador *

int *pt, x; pt almacena la
x = 3; dirección de x, se dice
pt = &x; 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

operador *, sobre dicho puntero Es equivalente a :
printf(“%c”, c);
c = ‘A’
printf(“%c”, *pc1); Es equivalente a :
Ejercicio c = ‘N’
*pc1 = ‘N’
printf(“%c”,c); Imprime ‘N’ pues c ya
cambio
EJERCICIO EN CLASE
int x,y;
int *p1,*p2;
1000 -42
17
22 x
x = -42;
y = 163; 1004 163
22 y
p1 = &x;
1008 1000
1004
1000
1004
0 p1
p2 = &y;
*p1 = 17; 1012 1004
1004
0 p2
*p2 = x+5;
*p1 = *p2;
Es equivalente a escribir
x = y;
p1 = p2; Esto indica que p1
ahora apunta a la
p1 = NULL; misma variable que p2

p2 = NULL; 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);
Se imprime 5, el valor de x no
funct(x); cambia aunque la función haya
printf(“%d\n”,x); intentado modificarla

void funct(int y){

y = y+1;
printf(“%d\n”,y);
}
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(“%d\n”,x); Se imprime 6, el valor de x cambió
funct(&x); dentro de la función
printf(“%d\n”,x);
void funct(int *py){
*py = *py+1;
printf(“%d\n”,*py);
Ejercicio
}
TIPOS DE DATOS
COMPUESTOS
 En ocasiones se necesitan TIPO FORMATO Bytes
DECLARACION
tipos de datos mas complejos,
ARREGLOS int arrEj[10]; 10*2 = 20
y estructurados
 Variables que almacenen mas de ESTRUCTURAS typedef struct TReg{ 2 + 100 =
un valor int ID; 102
char Texto[100];
 Variables que representen
}Reg;
información de la vida real UNIONES typedef union TUn{ 100
 Estarán formados a partir de int ID;
tipos de datos simples char Texto[100];
}Un;
 En C, tenemos:
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 A
 El numero de elementos (dimensión)
0 1 2 3 4 ... 99
 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
 Tipo de dato:

OPERACIONES 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? 1000 Lista[0]
 En C lo indica el operador sizeof
 Ejemplo:
1008 Lista[1]
int a;
printf(“%d %d”, sizeof(int), sizeof(a));
1016 Lista[2]
 El computador internamente
 No almacena la dirección de todos los elementos del
arreglo 1024 Lista[3]
 Solo almacena la dirección del primer elemento
Lista[4]
 El resto lo calcula así: 1032

&Lista[i] -> &Lista[0] + (i*sizeof(Lista[0]))

RESERVA DE MEMORIA
DINAMICA a no apunta a otra
variable, tiene
memoria propia,
solo para el
 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 int *a; //No se reserva nada
..
 La reserva seria dinámica /*Cuando se desee, se reserva*/
a = malloc(sizeof(int));
 En C se usan //La variable normalmente
*a = 3;
 Punteros y #include <stdlib.h>
void *malloc(size_t size);
 Las funciones de librería
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
main(){ 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

Cuando se
libera para
una
int *a; 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; La suma indica que p se mueva 2
“enteros” mas adelante
int *p; Cada entero equivale a 4 bytes
p = &x; 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]; p 1000
double *p,*p1,*p2; Lista[0]
1
int k; 1008
Lista[0] = 1; 1.1 Lista[1]
Lista[1] = 1.1;
Lista[2] = 1.2; 1016
p = Lista; Lista[2]
1.2
p = p + 2;
printf(“%d”, *p); p1
p se mueve 2
p = p - 1; desfases
printf(“%d”, *p);
p1 = Lista+2; p retrocede un
p2 = &Lista[0]; desfase
k = p1-p2;
printf(“%d”, k); Da el total de desfases
} entre p1 y p2
Ejercicio
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];
(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]

Ejercicio
(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: typedef struct TNombreCompleto{
char Primero[10];
char Inicial;
char Ultimo[10];
}NombreCompleto;

 Es la declaración del nuevo “tipo de dato”: NombreCompleto

 Con este tipo de dato, podremos crear “variables”:
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 snombre
misma “estructura” primero inicial
Cada dato tiene diferente
tamaño y espacio en
Ejercicio
memoria
ultimo
Cada dato representa una
información diferente
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 union ValorPolimorifco{
int valor_entero;
float valor_real;
};
ValorPolimorfico a;
a.valor_entero = 9;
a.valor_real = 8.9;
typedef enum {Entero, Real} Tdato;
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;
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