Registros

Archivos
Apuntadores
en
Lenguaje C

Preparado por: Pedro Contreras

DIICC-Facultad de Ingeniería
Universidad de Atacama
 Índice
• Estructura
• Librerías
• Entrada
• Salida
• Selecciones
• Iteraciones
• Vectores y matrices
• Registros, Archivos y Punteros
• Grafica
Estructura
 Estructura
• La estructura en un programa en C es de la
siguiente forma:
#include <stdio.h> Declaración librerías
Declaración de Macros
#define MAXIMO 100
Int funcion1(char vector[], int max) Declaración de funciones
Int funcion2()

int main(void) /*Cabecera de funcion*/ Programa principal

{
int caracter; /*Declaracion de variable local*/
for (caracter = 33 ; caracter < 255 ; caracter++)
/*Define ciclo de 33 a 255*/
putchar(caracter); Bloque programa
/*Imprime caracter segun numero*/
putchar('\n');
return 0;
} /*fin de main()*/
 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
 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.
 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;
 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)
 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);

 Comparaciones
< menor que
> mayor que
<= menor o igual
>= mayor o igual
== igual
!= distinto
 Ejemplos
a > b
a == 3
10 > dato
valor >= 0
if (a == b) printf("a es igual que b");
inicial = 65
 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
Entrada y Salida
 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()
 Salida
• La salida de datos se realiza con las
sentencias
putchar(33);
putchar(variable);
putchar(100);
printf ("hola\n");
printf("Tienes %d edad\n", edad);
printf("Tienes %d edad y mides %f\n", edad, altura);
 Arreglos
• Al declarar el array, indicamos entre
corchetes el numero de elementos que
va a tener.
int mi_array[10];
mi_array=valor_leido;
 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.
Punteros
 Punteros
• Un apuntador es una variable que
contiene la dirección de otra variable.

Apuntador Variable
dirección valor

Se puede acceder al objeto

“indirectamente”
 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
 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*\

 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
 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);}
 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);
}
 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*\
 Punteros
• Ejercicio
– Realice el ordenamiento ascendente de
una lista de 10 números utilizando
punteros para los arreglos. (ingresar,
ordenar,imprimir)
Estructuras
(Registros)
 Estructuras (Registros)
• Para definir un registro se debe definir
una estructura:
struct fecha {
int dia;
int mes;
int año;
};
 Estructuras (Registros)
• Es una especie de molde que
podemos nuevamente utilizar:
struct fecha d;
• Esta se puede inicializar:
struct fecha d={4,7,1987};
 Estructuras (Registros)
• Para hacer referencia:
if (d.mes<6)
if (d.año==1995)
d.dia=15;
 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
 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
 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;
 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;
Uniones
 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;
 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];
 Uniones
• Al miembro ival se accesa:
symtab [i].u.ival;
• Al primero de la cadena sval:
symtab [i].u.sval[0];
Archivos
 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
 Archivos
• Declaraciones
FILE *p_a
FILE *fopen (char *nombre,
char *modo);

p_a es un apuntador de archivo

 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
 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.
 Archivos
• Otras funciones, para e\s con formato
int fscanf(FILE *fp, char *formato, ...)
int fprintf(FILE *fp, char *formato, ...)
ASCII
 Arte ASCII
• http://www.fortunecity.com/marina/
reach/595/indiceAscii.htm