Este documento trata sobre registros, archivos y punteros en lenguaje C. Explica que los registros permiten definir nuevos tipos de datos compuestos, los archivos son utilizados para entrada y salida de datos, y los punteros almacenan direcciones de memoria y permiten acceder y modificar valores de variables.

1. RegistrosRegistros
ArchivosArchivos
ApuntadoresApuntadores
en
Lenguaje C
Preparado por: Pedro Contreras
DIICC-Facultad de Ingeniería
Universidad de Atacama

2. Índice
• Estructura
• Librerías
• Entrada
• Salida
• Selecciones
• Iteraciones
• Vectores y matrices
• Registros, Archivos y Punteros
• Grafica

3. Estructura

4. Estructura
• La estructura en un programa en C es de la
siguiente forma:
#include <stdio.h>
#define MAXIMO 100
Int funcion1(char vector[], int max)
Int funcion2()
int main(void) /*Cabecera de funcion*/
{
int caracter; /*Declaracion de variable local*/
for (caracter = 33 ; caracter < 255 ; caracter++)
/*Define ciclo de 33 a 255*/
putchar(caracter);
/*Imprime caracter segun numero*/
putchar('n');
return 0;
} /*fin de main()*/
Programa principal
Declaración librerías
Declaración de funciones
Declaración de Macros
Bloque programa

5. Librerías
• Las librerias se declaradas en archivos
llamados de cabezera “Header files” , estas
se llaman: #include <stdio.h>
• Las locales se llaman #include |pantalla.h|
stdio.h - Funciones de entrada/salida
stdlib.h - Conversión de tipos y asignación de memoria
string.h - Manejo de cadenas de caracteres
ctype.h - Comprobaciones y conversiones de tipos
io.h - Control de disco a bajo nivel
math.h - Funciones matemáticas en punto flotante
dos.h - Interacción con el MS-DOS
dir.h - Búsqueda de ficheros y manejo de directorios

6. Tipos de variables
• Hay cuatro tipos fundamentales, identificados por la
palabra clave que los define en el lenguaje:
• int: numeros enteros.
• char: un caracter individual.
• float: numeros fraccionarios, en notacion de coma flotante.
• double: Numeros en coma flotante, con el doble de digitos
• significativos que los float.
• Existe también una serie de modificadores que
alteran el rango de valores aceptados por los tipos
base:
• short int, o simplemente short: numeros enteros con menor rango de
valores.
• long int, o tambien long: numeros enteros con mayor rango de
valores.
• unsigned int, o simplemente unsigned: numeros enteros sin signo.
• unsigned long: enteros grandes y sin signo.
• unsigned char: esto es util cuando usemos una variable char como
si fuese un int.

7. Ejemplos
unsigned x;
int x,y,
z3,valor;
char letra = 'A';
unsigned long valor_largo;
double pi = 3.1416;
float num_1, num_2, num_3;

8. Tipo y funciones
int convertir(char letra_1, char letra_2)
double raiz_cuadrada(double operando)
void escribir(char letra)
unsigned long espacio_libre(void)

9. Llamar funciones
escribir('X');
resultado = raiz_cuadrada(x);
espacio = espacio_libre() + 512;
valor = raiz_cuadrada(convertir('z', caracter_2));
if (es_primo(x))
return raiz_cuadrada(x * y);

10. Comparaciones
< menor que
> mayor que
<= menor o igual
>= mayor o igual
== igual
!= distinto

11. Ejemplos
a > b
a == 3
10 > dato
valor >= 0
if (a == b) printf("a es igual que b");
inicial = 65

12. Expresiones Lógicas
• a > 0 && b > 0
• dato == 0 && x != 0
• a > 0 || b > 0
• !(dato > 0)
• letra > 'A' && letra < 'Z'
• raiz_cuadrada(x) >= logaritmo(y) - 1
• letra_inicial != 100 && !(edad > 'A')
• !(edad < 10 || edad > 70)&& sexo != 'F'
• (inicial == 'A' || inicial == 'B' || inicial
== 'C' || inicial == 'X') && edad > 10

13. Entrada y Salida

14. Entrada
• La lectura de datos se realiza con las
sentencias
scanf(“%d”, &edad)
scanf(“%d %c %f”, &a,&c,&x);
caracter = getc(variable);
c = getchar()

15. Salida
• La salida de datos se realiza con las
sentencias
putchar(33);
putchar(variable);
putchar(100);
printf ("holan");
printf("Tienes %d edadn", edad);
printf("Tienes %d edad y mides %fn", edad, altura);

16. Arreglos
• Al declarar el array, indicamos entre
corchetes el numero de elementos que
va a tener.
int mi_array[10];
mi_array=valor_leido;

17. Ejercicio en clases
• Programe una aplicación que lea dos
números y calcule sus suma, resta,
producto y división. Mostrar por
pantalla resultado.
• Programe una aplicación en C que lea
el nombre una persona y la edad, sea
ingresado a un arreglo y sea impreso
en orden de edad.

18. Punteros

19. Punteros
• Un apuntador es una variable que
contiene la dirección de otra variable.
dirección
Apuntador
valor
Variable
Se puede acceder al objeto
“indirectamente”

20. Punteros
• Operador unitario &: da la dirección del
objeto p=&c
• Se asigna la dirección de c a la variable p
• p es el puntero
• Operador unitario *: es el operador de
indirección o desreferencia; da acceso
a objeto que señala el apuntador

21. Punteros
• Ejemplos
int *px; *declara a px como un puntero a un objeto integer*
char *px; *declara a px como un puntero a un objeto char*
int x,y,*px;
px=&x; *asigna la dirección de x a la variable px*
y=*px; *asigna a y el valor al que apunta px*

22. Punteros
• Operaciones permitidas
– Un apuntador puede ser asignado a otro
– Es posible sumar o restar un apuntador
con un entero
– Es posible restar o comparar dos
apuntadores
– No es posible realizar ninguna operación
entre dos apuntadores

23. Punteros
• Argumentos de funciones
#include <stdio.h>
//*******************
void swap(int *px,int *py)
{int temporal;
temporal=*px;
*px=*py;
*py=temporal;
printf("%d",temporal);
printf("**");
printf("%d",*px);
printf("**");
printf("%d",*py);}
//********************
void main()
{int x,y;
x=1;
y=2;
swap(&x,&y);}

24. Punteros
• Punteros y arreglos
#include <stdio.h>
//*******************
void strcpy(char s[], char t[])
{
int i=0;
while (i<=5)
{
s[i]=t[i];
i++;}
}
//********************
void main()
{
char ss[5];
char tt[5];
tt[0]='a';
tt[1]='b';
tt[2]='c';
tt[3]='d';
tt[4]='e';
strcpy(ss,tt);
}

25. Punteros
• Apuntadores a funciones
– Estos apuntadores pueden poner en arreglos por ejemplo, y
retornar valores en cada posición
int *f(); * f:función que regresa un apuntador a int *
int (*pf)(); * pf:apuntador a una función regresa un int *
char **argv; * argv:apuntador a un apuntador char *
int (*diatab)[13]; * apuntador a un arreglo[13] de int*
int *daytab[13]; * arreglo[13] de apuntadores a int *
void *comp(); * comp: función que retorna apuntador a void*
void (*comp)(); *comp: apuntador a una función que retorna
void*
char (*(*x())[])(); * x: función que regresa un apuntador a
un arreglo[] de apuntadores a una función que regresa char*
char (*(*x[3]())[5]; * x: arreglo[3] de apuntadores a una
función que regresa un apuntador a un arreglo[5] de char*

26. Punteros
• Ejercicio
– Realice el ordenamiento ascendente de
una lista de 10 números utilizando
punteros para los arreglos. (ingresar,
ordenar,imprimir)

27. Estructuras
(Registros)

28. Estructuras (Registros)
• Para definir un registro se debe definir
una estructura:
struct fecha {
int dia;
int mes;
int año;
};

29. Estructuras (Registros)
• Es una especie de molde que
podemos nuevamente utilizar:
struct fecha d;
• Esta se puede inicializar:
struct fecha d={4,7,1987};

30. Estructuras (Registros)
• Para hacer referencia:
if (d.mes<6)
if (d.año==1995)
d.dia=15;

31. Apuntar estructuras
• Operaciones únicas con estructuras
– Acceder a uno de sus miembros
– Tomar su dirección (&)
• Las estructuras no se pueden asignar
o copiar como una unidad (no se
puede pasar como argumento a
funciones)
• Los punteros a estructuras no tienen
estas limitaciones

32. Apuntar estructuras
• Apuntador a una estructura del tipo fecha
struct fecha *pd;
• Puntero a una estrucura de tipo fecha
pd=&d
(*pd).mes
• Notación abreviada
pd-><miembro_estructura>
pd->mes

33. Definición de tipos de datos
• C dispone de una declaración de tipos
de datos llamada typedef
typedef int entero;
• La palabra “entero” es sinónimo de
“int”
entero a,b,c;

34. Definición de tipos de datos
• Podemos crear los nodos de un arbol
typedef struct anodo{
char *word;
int count;
Treeptr left;
Treeptr right;
}NodoArbol;
• Se creo la palabra reserva NodoArbol;
• La equivalencia puede ser de dos formas:
NodoArbol d;
struct anodo d;

35. Uniones

36. Uniones
• Variable que puede contener obtener
objetos de diferentes tamaños
• El compilador sigue el tamaño y requisito de
alineación
• Manipula diferentes clases de datos en una
sola area de almacenamiento
union u_tag {
int ival;
float fval;
char *sval;
}u;

37. Uniones
• Se tiene acceso a los miembros como:
nombre-unión.miembro
apuntador-union.miembro
struct {
char *name;
int flags;
int utype;
union {
int ival;
float fval;
char *sval;
}u;
}symtab[NSYM];

38. Uniones
• Al miembro ival se accesa:
symtab [i].u.ival;
• Al primero de la cadena sval:
symtab [i].u.sval[0];

39. Archivos

40. Archivos
• Recomendaciones para trabajar con
archivos
– Debe ser abierto
– Tomar nombre externo
– Utilizar apuntador para lecturas y escrituras
(apuntador de archivo)
• Ubicación de un buffer
• Posición carácter actual del buffer
• Si el archivo esta siendo leído o escrito
• Ocurrencia de errores
• Fin de archivo

41. Archivos
• Declaraciones
FILE *p_a
FILE *fopen (char *nombre,
char *modo);
p_a es un apuntador de archivo

42. Archivos
• Argumentos de “fopen”
El primero es una cadena de caracteres con
el nombre del archivo: “datos.txt”
El segundo es el tipo de acceso:
• Escritura “w”
• Lectura “r”
• Agregación “a”
• Si no existe con “a” y “w” se crea
• Con “w” elimina todo lo del archivo
• “fopen” regresa NULL si existe error

43. Archivos
• Otras funciones
int getc(FILE *fp)
Regresa el siguiente carácter de un archivo.
Regresa EOF si existe error.
int putc(int c, FILE *fp)
Escribe el carácter c en el archivo fp.
Regresa el carácter escrito.
Regresa EOF si existe error.

44. Archivos
• Otras funciones, para es con formato
int fscanf(FILE *fp, char *formato, ...)
int fprintf(FILE *fp, char *formato, ...)

45. ASCII

46. Arte ASCII
• http://www.fortunecity.com/marina/
reach/595/indiceAscii.htm