Programación C introducción

Instituto Tecnolgico de Ciudad Guzmn
Apuntes
Programacin II
Profesor: Academia:
Ing. Ramn Chvez Bracamontes Ingeniera Electrnica
Fecha: Enero de 2006
Programacin II
Contenido
Contenido ...................................................................................................................................................... 2 Identificacin del programa desarrollado por unidades de aprendizaje .................................................. 3 Ubicacin de la asignatura ............................................................................................................................. 3 Objetivo general del curso .............................................................................................................................. 3 Temario ............................................................................................................................................................. 3 Bibliografa ........................................................................................................................................................ 3 UNIDAD I INTRODUCCIN ...................................................................................................................... 4 UNIDAD II ESTRUCTURAS DE CONTROL Y FUNCIONES ................................................................ 16 UNIDAD III ARREGLOS ........................................................................................................................... 32 UNIDAD IV APUNTADORES Y ESTRUCTURAS ................................................................................. 42 UNIDAD V ARCHIVOS ............................................................................................................................ 53 UNIDAD VI UTILIZACIN DE LIBRERIAS EXTERNAS ..................................................................... 64
Ingeniera Electrnica
Programacin II
Identificacin del programa desarrollado por unidades de aprendizaje

Nombre de la asignatura: Programacin II (4-2-10) Nivel: Licenciatura Carrera: Ingeniera electrnica Clave: ECC-9342
Ubicacin de la asignatura
a) Relacin con otras asignaturas del plan de estudio Anteriores: Programacin Posteriores: Mtodos numricos, microprocesadores, comunicaciones, optativas b) Aportacin de la asignatura al perfil del egresado Como auxiliar en la investigacin y como herramienta del trabajo profesional al utilizar un lenguaje de alto nivel.
Objetivo general del curso

Conocer y aplicar las tcnicas de programacin, utilizando un lenguaje de alto nivel para el uso de la computadora como elemento de comunicacin con el mundo real.
Temario
Nmero I Tema Introduccin Subtemas Compilacin y encadenamiento Variables y constantes Tipos de datos Operadores y expresiones Entradas y salidas por consola Sentencias de control Funciones Arrays y cadenas (unidimensionales, bidimensionales) Funciones de caracteres y cadenas Estructuras Uniones Enumeraciones Punteros Archivos (Ficheros) Abrir ficheros Cierre fichero Escritura de caracteres y cadenas Lectura de caracteres y cadenas Posicin en secuenciales y binarios Escritura y lectura en binarios Funciones matemticas Funciones de conversin Funciones de fecha y hora Funciones de sistema Funciones grficas Funciones de comunicacin Proyectos
II III
Estructuras Funciones Arreglos
de
control
IV
Apuntadores y estructuras
Archivos
Vi
Utilizacin de libreras externas
Bibliografa
Turbo C, Programming for the PC, Howard W. Sams El lenguaje de programacin C, Kernigham, Prentice Hall Programacin en Turbo C, Schilt
Programacin II
UNIDAD I INTRODUCCIN
Objetivo educacional: Conocer los fundamentos del lenguaje de programacin C y poder generar un programa ejecutable sencillo.
C est caracterizado por ser de uso general, de sintaxis sumamente compacta y de alta portabilidad. Es un lenguaje de nivel medio porque combina elementos de lenguajes de alto nivel, manipulacin de bits, bytes, direcciones y elementos bsicos como nmeros y caracteres. La portabiblidad significa que es posible adaptar el software escrito para un tipo de computadora o sistema operativo en otro. C no lleva a cabo comprobaciones de errores en tiempo de ejecucin, es el programador el nico responsable de llevar a cabo esas comprobaciones Se trata de un lenguaje estructurado, que es la capacidad de un lenguaje de seccionar y esconder del resto del programa toda la informacin y las instrucciones necesarias para llevar a cabo un determinada tarea. Un lenguaje estructurado permite colocar las sentencias en cualquier parte de una lnea. Todos los lenguajes modernos tiende a ser estructurados. El componente estructural principal de C es la funcin, subrutina independiente que permiten definir tareas de un programa y codificarlas por separado haciendo que los programas sean modulares. Otra forma de estructuracin es el bloque de cdigo que es un grupo de sentencias conectadas de forma lgica que es tratado como una unidad. El compilador de C lee el programa entero y lo convierte a cdigo objeto o cdigo mquina. Una vez compilado, las lneas de cdigo fuente dejan de tener sentido durante la ejecucin. Este cdigo maquina puede ser directamente ejecutado por la computadora. El compilador de C incorpora una biblioteca estndar que proporciona las funciones necesarias para llevar a cabo las tareas ms usuales. En C se puede partir un programa en muchos archivos y que cada uno sea compilado por separado. En la compilacin de un programa consiste en tres pasos. Creacin del cdigo fuente, Compilacin del programa y Enlace del programa con las funciones necesarias de la biblioteca. La forma en que se lleve a cabo el enlace variar entre distintos compiladores y entornos, pero la forma general es:
Programacin II
1. PRIMER PROGRAMA
La mejor forma de aprender a programar en cualquier lenguaje es editar, compilar, corregir y ejecutar pequeos programas descriptivos. Todos los programas en C consisten en una o ms funciones, la nica funcin que debe estar presente es la denominada main(), siendo la primera funcin que se invoca cuando comienza la ejecucin del programa.
Forma general de un programa en C:

#Archivos de cabecera #Archivos de cabecera Declaraciones globales tipo_devuelto main(lista de parmetros) { secuencia de sentencias; } tipo_devuelto funcion1(lista de parmetros) { secuencia de sentencias; } tipo_devuelto funcion2(lista de parmetros) { secuencia de sentencias; } . . . tipo_devuelto funcionN(lista de parmetros) { secuencia de sentencias; }
Programacin II
PROGRAMA 1A
Descripcin: Este programa captura un nombre y lo imprime 5 veces en la pantalla.
#include <stdio.h> #include <conio.h> void main(void) { clrscr(); printf(Bienvenidos); getch (); }
Vamos a ir comentando cada una de las lneas (sentencias) que aparecen en este programa. La primera lnea que aparece se denomina ENCABEZAMIENTO y son ficheros que proporcionan informacin al compilador. En este archivo estn incluidas las funciones llamadas por el programa. La ubicacin de estos ficheros es el directorio C:\TC\INCLUDE\. La segunda lnea del programa indica donde comienza la funcin main indicando los valores que recibe y los que devuelve. La primera lnea de la funcin main (clrscr();) limpia la pantalla. y la segunda muestra un mensaje en la pantalla.
2. VARIABLES Y CONSTANTES
Unidad bsica de almacenamiento, la creacin es la combinacin de un identificador, un tipo y un mbito. Todas las variables en C tienen que ser declaradas antes de ser usadas. El lugar donde se declaran las variables puede ser dentro o en la definicin de una funcin, fuera de todas las funciones.
TIPOS char unsigned char int unsigned int long int unsigned long int float double long double
RANGO
-128 a 127 0 a 255 -32.768 a 32.767 0 a 65.535
TAMAO 1 1 2 2 4 4 4 8 10
DESCRIPCIN
Para una letra o un dgito. Letra o nmero positivo. Para nmeros enteros. Para nmeros enteros. Para nmeros enteros Para nmeros enteros Para nmeros con decimales Para nmeros con decimales Para nmeros con decimales
2.147.483.647
0 a 4.294.967.295 3.4E-38 a 3.4E+38 decimales(7) 1.7E-308 a 1.7E+308 decimales(15) 3.4E-4932 a 1.1E4932 decimales(19)
Programacin II
El nombre de las variables conocido como identificadores debe cumplir las siguientes normas. La longitud puede ir de un carcter a 31. El primero de ellos debe ser siempre una letra. No puede contener espacios en blanco, ni acentos y caracteres gramaticales. Hay que tener en cuenta que el compilador distingue entre maysculas y minsculas.
SINTAXIS:
tipo nombre=valor_numerico; tipo nombre=letra; tipo nombre[tamao]=cadena de letras, tipo nombre=valor_entero.valor_decimal;
CONVERSION (casting): Las conversiones automticas pueden ser controladas por el programador. Bastar con anteponer y encerrar entre parentesis, el tipo al que se desea convertir. Este tipo de conversiones solo es temporal y la variable a convertir mantiene su valor. SINTAXIS:
variable_destino=(tipo)variable_a_convertir; variable_destino=(tipo)(variable1+variable2+variableN);
PROGRAMA 1B
Descripcin: Convierte un par de nmeros flotantes a enteros y realiza la suma de los mismos presentando el resultado.
#include<stdio.h> #include<conio.h> void main(void) { float num1=25.75, num2=10.15; int T; clrscr(); T=(int)num1+(int)num2; // T=(int)(num1+num2); printf(Total: %d,T); getch(); }
Programacin II
AMBITO DE VARIABLE: Segn el lugar donde se declaren las variables tendrn un mbito. Segn el mbito de las variables pueden ser utilizadas desde cualquier parte del programa o nicamente en la funcin donde han sido declaradas. Las variables pueden ser: LOCALES: Cuando se declaran dentro de una funcin. Las variables locales slo pueden ser referenciadas (utilizadas) por sentencias que estn dentro de la funcin que han sido declaradas. No son conocidas fuera de su funcin. Pierden su valor cuando se sale y se entra en la funcin. La declaracin es como siempre.
GLOBALES: Son conocidas a lo largo de todo el programa, y se pueden usar desde cualquier parte del cdigo. Mantienen sus valores durante toda la ejecucin. Deban ser declaradas fuera de todas las funciones incluida main(). La sintaxis de creacin no cambia nada con respecto a las variables locales. Inicialmente toman el valor 0 o nulo, segn el tipo.
DE REGISTRO: Otra posibilidad es, que en vez de ser mantenidas en posiciones de memoria del ordenador, se las guarde en registros internos del microprocesador. De esta manera el acceso a ellas es ms directo y rpido. Para indicar al compilador que es una variable de registro hay que aadir a la declaracin la palabra register delante del tipo. Solo se puede utilizar para variables locales.
ESTTICAS: Las variables locales nacen y mueren con cada llamada y finalizacin de una funcin, sera til que mantuvieran su valor entre una llamada y otra sin por ello perder su mbito. Para conseguir eso se aade a una variable local la palabra static delante del tipo.
EXTERNAS: Debido a que en C es normal la compilacin por separado de pequeos mdulos que componen un programa completo, puede darse el caso que se deba utilizar una variable global que se conozca en los mdulos que nos interese sin perder su valor. Aadiendo delante del tipo la palabra extern y definindola en los otros mdulos como global ya tendremos nuestra variable global.
TIPOS DEFINIDOS POR EL USUARIO: C permite explcitamente nuevos nombres para tipos de datos. Realmente no se crea un nuevo tipo de dato, sino que se define un nuevo nombre para un tipo existente. Esto ayuda a hacer ms transportables los programas con dependencias con las mquinas, solo habr que cambiar las sentencias typedef cuando se compile en un nuevo entorno. SINTAXIS:
tydef tipo nuevo_nombre; nuevo_nombre nombre_variable[=valor];
Programacin II
PROGRAMA 1C
Descripcin: programa que muestra un ejemplo de los diferentes tipos de variables que existen.
#include <stdio.h> #include <conio.h> void func1(void); int numero1=10; extern int numero2=25; void main(void) { int numero3=20; static int numero4=15; register int numero5=30; clrscr(); printf(\n %d, \n %d, \n %d, \n %d, numero2,numero3,numero4,numero5); func1(); getch(); }
\n
%d,,
numero1,
void func1(void) { printf(Las globales, que aqu se conocen); printf(\n %d, \n %d, numero1, numero2); }
LAS CONSTANTES: Se refieren a los valores fijos que no pueden ser modificados por el programa. Pueden ser de cualquier tipo de datos bsicos. Las constantes de carcter van encerradas en comillas simples. Las constantes enteras se especifican con nmeros sin parte decimal y las de coma flotante con su parte entera separada por un punto de su parte decimal. SINTAXIS:
const tipo nombre=valor_entero; const tipo nombre=valor_entero.valor_decimal; const tipo nombre=carcter;
La directiva #define es un identificador y una secuencia de caracteres que sustituir se sustituir cada vez que se encuentre ste en el archivo fuente. Tambin pueden ser utilizados para definir valores numricos constantes.
SINTAXIS:
#define IDENTIFICADOR valor_numerico #define IDENTIFICADOR cadena
Programacin II
PROGRAMA 1D
Descripcin: Este programa desarrolla el permetro de una circunferencia utilizando un define para introducir un dato como constante.
#include <stdio.h> #include <conio.h> #define pi 3.1416 float r, p; void main(void) { clrscr(); printf("Este programa encuentra el circunferencia"); printf("\n \n Introduzca el radio"); scanf ("%f", &r); p=2*r*pi; printf(El permetro es: %f, p); getch(); }
permetro
de
una
PROGRAMA 1E
Descripcin: Este programa es un ejemplo de los define y const para introducir datos constantes al programa.
#include <stdio.h> #include <conio.h> #define DOLAR 11.53 #define TEXTO "Esto es una prueba" #define clr clrscr #define pr printf #define get getch const int peso=1; void main(void) { clr(); pr("El valor del dolar es %.2f pesos",DOLAR); pr("\n%s",TEXTO); pr(Ejemplo de constantes y defines); get(); }
3. OPERADORES
C es un lenguaje muy rico en operadores incorporados, es decir, implementados al realizarse el compilador. Define cuatro tipos de operadores: aritmticos, relacionales, lgicos y a nivel de bits. Tambin se definen operadores para realizar determinadas tareas, como las asignaciones. ASIGNACION (=): En C se puede utilizar el operador de asignacin en cualquier expresin valida. Solo con utilizar un signo de igualdad se realiza la asignacin. El operador destino (parte izquierda) debe ser siempre una variable, mientras que en la parte derecha puede ser
10
Programacin II
cualquier expresin valida. Es posible realizar asignaciones mltiples, igualar variables entre si y a un valor. SINTAXIS:
variable=valor; variable=variable1; variable=variable1=variable2=variableN=valor;
ARITMTICOS: Pueden aplicarse a todo tipo de expresiones. Son utilizados para realizar operaciones matemticas sencillas, aunque unindolos se puede realizar cualquier tipo de operaciones. En la siguiente tabla se muestran todos los operadores aritmticos.
OPERADOR
DESCRIPCIN
Resta. Suma Multiplica Divide Resto de una divisin signo (monario). Decremento en 1. Incrementa en 1.
ORDEN
+ * / % -++
3 3 2 2 2 2 1 1
LGICOS Y RELACIONALES: Los operadores relacionales hacen referencia a la relacin entre unos valores y otros Los lgicos se refiere a la forma en que esas relaciones pueden conectarse entre si. Los veremos a la par por la estrecha relacin en la que trabajan.
OPERADORES RELACIONALES OPERADOR DESCRIPCIN

Menor que. Mayor que. Menor o igual. Mayor o igual Igual Distinto
OPERADORES LGICOS ORDEN 5 5 5 5 6 6 OPERADOR DESCRIPCIN

Y (AND) O (OR) NO (NOT)
ORDEN 10 11 1
< > <= >= == ! =
&& || !
11
Programacin II
A NIVEL DE BITS: Estos operadores son la herramienta ms potente, pueden manipular internamente las variables, es decir bit a bit. Este tipo de operadores solo se pueden aplicar a las variables de tipo char, short, int y long. Para manejar los bits debemos conocer perfectamente el tamao de las variables.
OPERADOR
DESCRIPCIN
Y (AND) bit a bit. O (OR) Inclusiva. O (OR) Exclusiva. Desplazamiento a la izquierda. Desplazamiento a la derecha. Intercambia 0 por 1 y viceversa.
ORDEN 7 9 8 4 4 1
& | ^ << >> ~

PROGRAMA 1F
Descripcin: Este programa captura 2 variables, realiza una divisin y entrega como resultado el cociente y el residuo de la operacin.
#include <stdio.h> #include <conio.h> void main(void) { clrscr (); int x, y; printf ("Introduzca el dividendo y el divisor:"); scanf ("\n %d, %d, &x, &y); printf ("\n Cociente: %d",x/y); printf (\n Resto %d, x%y); getch (); }
4. E/S POR CONSOLA

La entrada y la salida se realizan a travs de funciones de la biblioteca, que ofrece un mecanismo flexible a la vez que consistente para transferir datos entre dispositivos. Las funciones printf() y scanf() realizan la salida y entrada con formato que pueden ser controlados. Aparte hay una gran variedad de funciones E/S. printf: escribe los datos en pantalla. Se puede indicar la posicin donde mostrar mediante una funcin gotoxy(columna,fila) o mediante las constantes de carcter. La sintaxis general que se utiliza la funcin printf() depende de la operacin a realizar.
printf(mensaje [const_carcter]); printf([const_carcter]); printf(ident(es)_formato[const_carcter],variable(s));
12
Programacin II
En las siguientes tablas se muestran todos los identificadores de formato y las constantes de carcter las que se utilizan para realizar operaciones automticamente sin que el usuario tenga que intervenir en esas operaciones.
IDENTIFICADORES DE FORMATO IDENTIFICADOR %c %d %e %E %f %o %s %u %x %X %p %ld %h %% DESCRIPCION Carcter Entero N. Cientfica N. Cientfica Coma flotante Octal Cadena Sin signo Hexadecimal Hexadecimal Puntero Entero Largo Short signo %
CONSTANTES DE CARCTER CONSTANTE \n \f \r \t \b \ \ \\ \? \a DESCRIPCION Salto de lnea Salto de pgina Retorno de carro Tabulacin Retroceso Comilla simple Comillas Barra invertida Interrogacin Sonido de alerta
Existen especificadores de formato asociados a los identificadores que alteran su significado ligeramente. Se puede especificar la longitud mnima, el nmero de decimales y la alineacin. Estos modificadores se sitan entre el signo de porcentaje y el identificador.
% modificador identificador
El especificador de longitud mnima hace que un dato se rellene con espacios en blanco para asegurar que este alcanza una cierta longitud mnima. Si se quiere rellenar con ceros o espacios hay que aadir un cero delante antes del especificador de longitud.
printf(%f ,numero); //salida normal. printf(%10f ,numero); //salida con 10 espacios. printf(%010f ,numero); //salida con los espacios poniendo 0.
13
Programacin II
El especificador de precisin sigue al de longitud mnima (si existe). Consiste en un nulo y un valor entero. Segn el dato al que se aplica su funcin varia. Si se aplica a datos en coma flotante determina el nmero de posiciones decimales. Si es a una cadena determina la longitud mxima del campo. Si se trata de un valor entero determina el nmero mnimo de dgitos.
printf(%10.4f ,numero); //salida con 10 espacios con 4 decimales. printf(%10.15s,cadena); //salida con 10 caracteres dejando 15 espacios. printf(%4.4d,numero); //salida de 4 dgitos mnimo.
El especificador de ajuste fuerza la salida para que se ajuste a la izquierda, por defecto siempre lo muestra a la derecha. Se consigue aadiendo despus del porcentaje un signo menos.
printf(%8d,numero); // salida ajustada a la derecha. printf(%-8d,numero); //salida ajustada a la izquierda.
scanf: Es la rutina de entrada por consola. Puede leer todos los tipos de datos incorporados y convierte los nmeros automticamente al formato incorporado. En caso de leer una cadena lee hasta que encuentra un carcter de espacio en blanco. El formato general:
scanf(identificador,&variable_numerica o char); scanf(identificador,variable_cadena);
La funcin scanf() tambin utiliza modificadores de formato, uno especifica el nmero mximo de caracteres de entrada y eliminadores de entrada.. Para especificar el nmero mximo solo hay que poner un entero despus del signo de porcentaje. Si se desea eliminar entradas hay que aadir %*c en la posicin donde se desee eliminar la entrada.
scanf(%10s,cadena); scanf(%d%*c%d,&x,&y);
En muchas ocasiones se combinaran varias funciones para pedir datos y eso puede traer problemas para el buffer de teclado, es decir que asigne valores que no queramos a nuestras variables. Para evitar esto hay dos funciones que se utilizan para limpiar el buffer de teclado.
fflush(stdin); fflushall();
14
Programacin II
OTRAS FUNCIONES E/S: El archivo de cabecera de todas estas funciones es STDIO.H. Todas estas funciones van a ser utilizadas para leer caracteres o cadenas de caracteres. Todas ellas tienen asociadas una funcin de salida por consola.
FUNCIONES
DESCRIPCIN
Lee un carcter de teclado, espera un salto de carro. Lee un carcter con eco, no espera salto de carro. Lee un carcter sin eco, no espera salto de carro. Lee una cadena del teclado. Muestra un carcter en pantalla. Muestra una cadena en pantalla.
var_char=getchar(); var_char=getche(); var_char=getch(); gets(var_cadena); putchar(var_char); puts(variables);
Constantes enteras en tres bases diferentes

Base 10 Decimal
8 10 16 65536 24 17
Base 16 Hexadecimal (Hex)

0x08 0x0A 0x10 0x10000 0x18 0x11
Base 8 Octal
010 012 020 0200000 030 021
Programas propuestos para la unidad 1 1. Programa que imprima en la pantalla los datos personales del alumno y el horario de las materias que cursa. 2. Programa que calcule las raices de una ecuacin de segundo grado solicitando al usuario los parmetros de la ecuacin Ax2+Bx+C=0. 3. Programa que lea desde el teclado el precio de un producto x y la cantidad, y como resultado imprima en la pantalla el subtotal, el iva y el total. 4. Programa que lea 1as calificaciones de un grupo de 10 alumnos (0-100) e imprima el promedio del grupo. 5. Programa imprima en pantalla un men de un restaurant x que incluya los precios de los alimentos.
15
Programacin II
UNIDAD II ESTRUCTURAS DE CONTROL Y FUNCIONES

Objetivo educacional: Aplicar las estructuras del lenguaje a la resolucin de problemas utilizando programacin estructurada
5. SENTENCIAS DE CONTROL
Es la manera que tiene un lenguaje de programacin de provocar que el flujo de la ejecucin avance y se ramifique en funcin de los cambios de estado de los datos. if-else: La ejecucin atraviese un conjunto de estados bolean que determinan que se ejecuten distintos fragmentos de cdigo.
if (expresion-booleana) Sentencia1; else Sentencia2; if (expresion-booleana) { Sentencia1; sentencia2; } else Sentencia3;
La clusula else es opcional, la expresin puede ser de cualquier tipo y ms de una (siempre que se unan mediante operadores lgicos).Otra opcin posible es la utilizacin de if anidados, es decir unos dentro de otros compartiendo la clusula else. Un operador muy relacionado con la sentencia if es ?. Es un operador ternario que puede sustituir al if. El modo de trabajo es el siguiente, evala la primera expresin y si es cierta toma el valor de la segunda expresin y se le pasa a la variable. Si es falsa, toma el valor de la tercera y la pasa a la variable
varible=condicion ? expresion2:expresion3;
PROGRAMA #2A
Descripcin: Programa que calcula el nmero de das vividos.
#include <stdio.h> #include <conio.h> void main() { char nombre[50]; int edad; clrscr(); printf("Cmo te llamas?\n "); scanf("%s",nombre); printf("Cuntos aos tienes?\n"); scanf("%i",&edad); edad=edad*365; gotoxy(5,10); printf("%s, has vivido %i dias",nombre,edad); gotoxy(40,22); printf("Pulsa cualquier tecla para terminar..."); getch(); }
16
Programacin II
PROGRAMA #2B
Descripcin: Este programa es un ejemplo de la utilizacin del IF y ELSE. Decide si el peso introducido es menor o mayor de media tonelada.
#include <stdio.h> #include <conio.h> void main(void) { int peso; clrscr(); gotoxy(5,3); printf(Introducir peso: ); gotoxy(22,3); scanf(%d,&peso); if(peso<500) { gotoxy(5,5); printf(No es ni media Tn); } else { gotoxy(5,5); pritnf(Es ms de media Tn); } getch(); }
Para probar la utilizacin de un if anidado realizar un programa que pida una edad. Si la edad es igual o menor a 10 poner el mensaje NIO, si la edad es mayor a 65 poner el mensaje JUBILADO, y si la edad es mayor a 10 y menor o igual 65 poner el mensaje ADULTO.
SWITCH: Realiza distintas operaciones en base al valor de una nica variable o expresin. Es una sentencia muy similar a if-else, pero esta es mucho ms cmoda y fcil de comprender. Si los valores con los que se compara son nmeros se pone directamente el pero si es un carcter se debe encerrar entre comillas simples.
switch (expresin){ case valor1: sentencia; break; case valor2: sentencia; break; case valor3: sentencia; break; case valorN: sentencia; break; default: }
17
Programacin II
El valor de la expresin se compara con cada uno de los literales de la sentencia case si coincide alguno se ejecuta el cdigo que le sigue, si ninguno coincide se realiza la sentencia default (opcional), si no hay sentencia default no se ejecuta nada. La sentencia break realiza la salida de un bloque de cdigo. En el caso de sentencia switch realiza el cdigo y cuando ejecuta break sale de este bloque y sigue con la ejecucin del programa. En el caso que varias sentencias case realicen la misma ejecucin se pueden agrupar, utilizando una sola sentencia break.
switch (expresin){ case valor1: case valor2: case valor5: sentencia; break; case valor4: sentencia; break; default: }
PROGRAMA #2C
Descripcin: Este programa es un ejemplo del SWITCH en la utilizacin para mens
#include <stdio.h> #include <conio.h> void main(void) { int opcion; clrscr(); pritnf(1.ALTAS\n); pritnf(2.BAJAS\n); pritnf(3.MODIFICA\n); pritnf(4.SALIR\n); pritnf(Elegir opcin: ); scanf(%d,&opcion); switch(opcion) { case 1: printf(Opcin break; case 2: printf(Opcin break; case 3: printf(Opcin break; case 4: printf(Opcin break; default: printf(Opcin } getch(); }
Uno);
Dos);
Tres);
Salir);
incorrecta);
18
Programacin II
WHILE: Ejecuta repetidamente el mismo bloque de cdigo hasta que se cumpla una condicin de terminacin. Hay cuatro partes en cualquier bucle. Inicializacin, cuerpo, iteracin y terminacin.
[inicializacin;] while(terminacin){ cuerpo; [iteracin;] }
DO-WHILE: Es lo mismo que en el caso anterior pero aqu como mnimo siempre se ejecutara el cuerpo una vez, en el caso anterior es posible que no se ejecute ni una sola vez.
[inicializacin;] do{ cuerpo; [iteracin;] }while(terminacin);
PROGRAMA #2D
Descripcin: Este programa obtiene el nmero de fibonacci haciendo uso de un cliclo do-while.
#include <stdio.h> #include <conio.h> void main(void) { int n1=0,n2=1,n3; printf("Numero de Fibonacci: %d %d\n",n1,n2); do{ n3=n1+n2; n1=n2+n3; n2=n1+n3; printf("%d %d %d\n",n3,n1,n2); }while(n1<10000 && n2<10000 && n3<10000); }
FOR: Realiza las mismas operaciones que en los casos anteriores pero la sintaxis es una forma compacta. Normalmente la condicin para terminar es de tipo numrico. La iteracin puede ser cualquier expresin matemtica valida. Si de los 3 trminos que necesita no se pone ninguno se convierte en un bucle infinito.
for (inicio;fin;iteracin) sentencia1; for (inicio;fin;iteracin) { sentencia1; sentencia2; }
19
Programacin II
PROGRAMA #2E
Descripcin: Este programa muestra nmeros del 1 al 100. Utilizando un bucle de tipo FOR.
#include<stdio.h> #include<conio.h> void main(void) { int n1=0; for (n1=1;n1<=100;n1++) printf("%d\n",n1); getch(); }
La sentencia continue lo que hace es ignorar las sentencias que tiene el bucle y saltar directamente a la condicin para ver si sigue siendo verdadera, si es as sigue dentro del bucle, en caso contrario saldra directamente de el. La sentencia exit() tiene una operatoria ms drstica, que la sentencia break, en vez de saltear una iteracin, esta abandona directamente el programa dndolo por terminado. Aparte realiza operaciones tiles como cerrar cualquier archivo que estuviera abierto, vaciado de buffers. Se suele utilizar cuando se desea abandonar programas cuando se produce algn error fatal e inevitable.
Otra funcin relacionada con los bucles es kbhit(), lo que hace esta funcin es la detectar el momento en que se pulsa una tecla (cualquiera). Devuelve 0 cuando no se ha pulsado ninguna tecla, cuando se pulsa una tecla devuelve cualquier valor distinto de 0.
PROGRAMA #2F
Descripcin: Muestra nmeros hasta que se pulsa una tecla.
#include <stdio.h> #include <conio.h> void main(void) { long num=0; clrscr(); for( ; ; ) { num++; printf(%ld\n,num); if(kbhit()) exit(); } getch(); }
20
Programacin II
PROGRAMA #2G
Descripcin: Este programa es un ejemplo de if anidados. Tambin es otro ejemplo de cmo hacer un men.
#include <stdio.h> #include <conio.h> void main(void) { char opcion; clrscr(); printf("A) Electronica I\n"); printf("B) Electronica II\n"); printf("C) Electronica III\n"); printf("Opcin ");scanf("%c",&opcion); printf("Escogio: "); if(opcion=='A') printf("Electronica I"); else if(opcion=='B') printf("Electronica II"); else if(opcion=='C') printf("Electronica III"); else printf("Asignatura Inexistente"); getch(); }
PROGRAMA #2H
Descripcin: Este programa captura x nmero de aos y entrega como resultado el promedio de todos.
#include <stdio.h> #include <conio.h> void main(void) { int alumnos,edad,counter=1; float promedio,sumaedad=0; clrscr(); printf("\nNumero de Alumnos: "); scanf("%d",&alumnos); while(1) { printf("\nEdad alumno %d:",counter); scanf("%d",&edad); sumaedad=sumaedad+edad; if(counter==alumnos) break; counter++; } promedio=sumaedad/counter; printf("\nLa edad promedio de %d alumnos es %lf aos",counter,promedio); getch(); }
21
Programacin II
6. FUNCIONES
Las funciones son los bloques constructores de C, es el lugar donde se produce toda la actividad del programa. Es la caracterstica ms importante de C. Subdivide en varias tareas concurrentes el programa, as slo se las tendr que ver con diminutas piezas de programa, de pocas lneas, cuya escritura y correccin es una tarea simple. Las funciones pueden o no devolver y recibir valores del programa. El mecanismo para trabajar con funciones es el siguiente, primero debemos declarar el prototipo de la funcin, a continuacin debemos hacer la llamada y por ltimo desarrollar la funcin. Los dos ltimos pasos pueden cambiar, es decir, no es necesario que el desarrollo de la funcin este debajo de la llamada. Antes de seguir debemos conocer las reglas de mbito de las funciones. El cdigo de una funcin es privado a esa funcin, el cdigo que comprende el cuerpo de esa funcin est oculto al resto del programa a menos que se haga a travs de una llamada. Todas las variables que se definen dentro de una funcin son locales con la excepcin de las variables estticas. SINTAXIS DEL PROTOTIPO:
tipo_devuelto nombre_funcion ([parametros]);
SINTAXIS DE LA LLAMADA:
nombre_funcion([parametros]);
SINTAXIS DEL DESARROLLO:

tipo_devuelto nombre_funcion ([parametros]) { cuerpo; }
Cuando se declaran las funciones es necesario informar al compilador los tamaos de los valores que se le enviarn y el tamao del valor que retorna. En el caso de no indicar nada para el valor devuelto toma por defecto el valor int. Al llamar a una funcin se puede hacer la llamada por valor o por referencia. En el caso de hacerla por valor se copia el contenido del argumento al parmetro de la funcin, es decir si se producen cambios en el parmetro no afecta a los argumentos. C utiliza esta llamada por defecto. Cuando se utiliza la llamada por referencia lo que se pasa a la funcin es la direccin de memoria del argumento, por tanto si se producen cambios estos afectan tambin al argumento. La llamada a una funcin se puede hacer tantas veces como se quiera.
22
Programacin II
PRIMER TIPO: Las funciones de este tipo ni devuelven valor ni se les pasa parmetros. Ente caso hay que indicarle que el valor que devuelve es de tipo void y para indicar que no recibir parmetros tambin utilizamos el tipo void. Cuando realizamos la llamada no hace falta indicarle nada, se abren y cierran los parentesis.
void nombre_funcion(void); nombre_funcion();
PROGRAMA #2I
Descripcin: Este programa indica cuando se esta en una funcin e imprime el contenido de esta.
#include <stdio.h> #include <conio.h> #include <dos.h> void mostrar(void); void main(void) { clrscr(); printf("Estoy en la principal\n"); delay(2000); mostrar(); printf("De vuelta en la principal"); getch(); } void mostrar(void) { printf("Ahora he pasado a la funcin\n"); delay(2000); }
23
Programacin II
SEGUNDO TIPO: Son funciones que devuelven un valor una vez han terminado de realizar sus operaciones, solo se puede devolver uno. La devolucin se realiza mediante la sentencia return, que adems de devolver un valor hace que la ejecucin del programa vuelva al cdigo que llamo a esa funcin. Al compilador hay que indicarle el tipo de valor que se va a devolver poniendo delante del nombre de la funcin el tipo a devolver. En este tipo de casos la funcin es como si fuera una variable, pues toda ella equivale al valor que devuelve.
tipo_devuelto nombre_funcion(void); variable=nombre_funcion();
PROGRAMA #2J
Descripcin: Este programa realiza una suma de 2 nmeros por medio de funciones y regresa el resultado a la funcin principal para imprimirlo.
#include<stdio.h> #include<conio.h> #include<dos.h> int suma(void); void main(void) { int total; clrscr(); printf(Suma valores\n); total=suma(); pritnf(\n%d,total); getch(); } int suma(void) { int a,b,total_dev; printf(valores: ); scanf(%d%*c%d,&a,&b); total_dev=a+b; return total_dev; }
#include<stdio.h> #include<conio.h> #include<dos.h> int suma(void); void main(void) { clrscr(); printf(Suma valores\n); pritnf(\n %d,suma()); getch(); } int suma(void) { int a,b; printf(valores: ); scanf(%d%*c%d,&a,&b); return a+b; }
24
Programacin II
TERCER TIPO: En este tipo las funciones pueden o no devolver valores pero lo importante es que las funciones pueden recibir valores. Hay que indicar al compilador cuantos valores recibe y de que tipo es cada uno de ellos. Se le indica ponindolo en los parentesis que tienen las funciones. Deben ser los mismos que en el prototipo.
void nombre_funcion(tipo1,tipo2tipoN); nombre_funcion(var1,var2varN);
PROGRAMA #2K
Descripcin: Este programa captura dos datos y una cadena. Con los datos se realiza una suma y se imprime el resultado y la cadena capturada.
#include <stdio.h> #include <conio.h> void resta(int x,int y,char *cad); void main(void) { int a,b; char cadena[20]; clrscr(); printf("Resta de valores\n"); printf("Introducir valores y cadena: "); scanf("%d%*c%d",&a,&b); gets(cadena); resta(a,b,cadena); getch(); } void resta(int x,int y,char *cad) { printf("Total= %d",x+y); printf("La cadena es: %s",cad); }
PASO DE ESTRUCTURAS A FUNCIONES: Cuando se utiliza o se pasa una estructura como argumento a una funcin, se le pasa toda la estructura integra, se le pasa por valor. Esto significa que todos los cambios realizados en el interior de la funcin no afectan a la estructura utilizada como argumento. La nica diferencia con los casos anteriores es que, ahora hay que definir como parmetro de la funcin una estructura. SINTAXIS:
tipo_devuelto nombre_funcion(struc nombre etiqueta); nombre_funcion(etiqueta_estructura);
25
Programacin II
PROGRAMA #2L
Descripcin: Este programa captura el nmero de calificaciones y dice cuantas son reprobatorias.
#include <stdio.h> #include <conio.h> int numreprob(int not); void main(void) { int notas, reprobados; clrscr(); printf("\nNmero de notas a leer: "); scanf("%d",&notas); reprobados=numreprob(notas); printf("\nExiste un total de %d alumno(s) reprobado(s)",reprobados); getch(); } int numreprob(int not) { int c=1,calif,rep=0; while(c<=not) { printf("\nCalificacion de la nota %d: ",c); scanf("%d",&calif); if(calif<7) rep++; c++; } return (rep); }
26
Programacin II
PROGRAMA #2M
Descripcin: Este programa captura la matricula y la calificacin de cualquier numero de alumnos e imprime las matriculas y su calificacin, esto ocurre asta que se introduce un cero a la matricula.
#include <stdio.h> #include <conio.h> #include <dos.h> void despliega(int *mats,char *califs,int numcap); int leedato(int *mats,char *califs,int maximo); void main(void) { int max=30,matr[29],numalumn; char calif[29]; clrscr(); numalumn=leedato(matr,calif,max); printf("\nEl numero de alumnos capturados es %d",numalumn); despliega(matr,calif,numalumn); } int leedato(int *mats,char *califs,int maximo) { int n=0; printf("\n ***Introduce la matricula y su calificacin. ***"); printf("\n ***Para terminar dale un cero a la matricula. ***"); while(1) { if(n>=maximo) { printf("\nEl arreglo se encuentra lleno"); getch(); break; } printf("\n\nMatricula del alumno %d: ",n+1); scanf("%d",mats); if(*mats==0) break; printf("\nCalificacin del alumno %d: ",n+1); scanf("%d",califs); mats++; califs++; n++; } return n; } void despliega(int *mats,char *califs,int numcap) { int i=1; while(1){ if(i>numcap) break; printf("\nLa calificacin del alumno %d es %d",*mats,*califs); i++; mats++; califs++; } getch(); }
27
Programacin II
PROGRAMA #2N
Descripcin: Este programa muestra un men donde se pide que tipo de operacin bsica desea realiza. Una vez colocando la opcin, pide que introduzca dos datos (A y B), realiza la operacin y muestra el resultado.
#include <stdio.h> #include <conio.h> #include <ctype.h> void suma(void); void resta(void); void multi(void); void divi(void); void datos(int *a,int *b); char r; int opcion; float a,b; void main(void) { do { clrscr(); gotoxy(30,4); printf("OPERACIONES BASICAS"); gotoxy(20,10);printf("1.- SUMA"); gotoxy(20,12);printf("2.- RESTA"); gotoxy(20,14);printf("3.- MULTIPLICACION"); gotoxy(20,16);printf("4.- DIVISION"); gotoxy(50,20);printf("Opcin deseada: "); scanf("%d",&opcion); switch(opcion) { case 1: suma(); break; case 2: resta(); break; case 3: multi(); break; case 4: divi(); break; default: gotoxy(50,22);printf("Opcion no valida"); } gotoxy(20,24); printf("<< Desea realizar otra operacin [S/N] >>"); r=tolower(getch()); } while(r=='s'); }
28
Programacin II
void suma(void) { clrscr(); gotoxy(38,4); printf("SUMA"); gotoxy(20,8);printf("Valor de A: "); scanf("%f",&a); gotoxy(20,10);printf("Valor de B: "); scanf("%f",&b); gotoxy(20,14);printf("SUMA A + B= %.2f",a+b); } void resta(void) { clrscr(); gotoxy(37,4); printf("RESTA"); gotoxy(20,8);printf("Valor de A: "); scanf("%f",&a); gotoxy(20,10);printf("Valor de B: "); scanf("%f",&b); gotoxy(20,14);printf("RESTA A - B= %.2f",a-b); } void multi(void) { clrscr(); gotoxy(33,4); printf("MULTIPLICACIN"); gotoxy(20,8);printf("Valor de A: "); scanf("%f",&a); gotoxy(20,10);printf("Valor de B: "); scanf("%f",&b); gotoxy(20,14);printf("SUMA A X B= %.2f",a*b); } void divi(void) { clrscr(); gotoxy(38,4); printf("DIVISIN"); gotoxy(20,8);printf("Valor de A: "); scanf("%f",&a); gotoxy(20,10);printf("Valor de B: "); scanf("%f",&b); gotoxy(20,14);printf("SUMA A / B= %.2f",a/b); }
PASO Y DEVOLUCION DE PUNTEROS: Cuando se pasan punteros como parmetros se esta haciendo una llamada por referencia, los valores de los argumentos cambian si los parmetros de la funcin cambian. La manera de pasar punteros es igual que cuando se pasan variables, slo que ahora hay que preceder al nombre del parmetro con un asterisco.
valor_devuelto nombre_funcion(*param1,*param2,*paramN); nombre_funcion(var1,var2,varN);
Para devolver un puntero, una funcin debe ser declarada como si tuviera un tipo puntero de vuelta, si no hay coincidencia en el tipo de vuelta la funcin devuelve un puntero nulo. En el prototipo de la funcin antes del nombre de esta hay que poner un asterisco y en la llamada hay que
29
Programacin II
igualar la funcin a un puntero del mismo tipo que el valor que devuelve. El valor que se retorna debe ser tambin un puntero. PROTOTIPO:
valor_devuelto *nombre(lista_parametros);
LLAMADA:
puntero=nombre_funcion(lista_parametros);
DESARROLLO:
valor_devuelto *nombre_funcion(lista_parametros) { cuerpo; return puntero; }
PROGRAMA #2O
Descripcin: Busca la letra que se le pasa en la cadena y si la encuentra muestra la cadena a partir de esa letra.
#include <stdio.h> #include <conio.h> void *encuentra(char letra, char *cadena); void main(void) { char frase[80], *p, letra_busca; clrscr(); printf("Introducir cadena: "); gets(frase); fflush(stdin); printf("Letra a buscar: "); letra_busca=getchar(); p=encuentra(letra_busca,frase); if(p) printf("\n %s",p); getch(); } void *encuentra(char letra, char *cadena) { while(letra!=*cadena && *cadena) cadena++; return cadena; }
30
Programacin II
LA FUNCIN MAIN: Mtodo para pasar informacin a la funcin main mediante el uso de argumentos, el lugar desde donde se pasan esos valores es la lnea de ordenes del sistema operativo. Se colocan detrs del nombre del programa. Hay dos argumentos especiales ya incorporados, argc y argv que se utilizan para recibir esa informacin. En argc contiene el nmero de argumentos de la lnea de ordenes y es un entero. Siempre vale como mnimo 1, ya que el nombre del programa cuenta como primer argumento. El caso de argv es un puntero a un array de punteros de caracteres donde se irn guardando todos los argumentos. Todos ellos son cadenas. Si la funcin main espera argumentos y no se le pasa ninguno desde la lnea de ordenes, es muy posible que de un error de ejecucin cuando se intenten utilizar esos argumentos. Por tanto lo mejor es siempre controlar que el nmero de argumentos es correcto. Otro aspecto a tener en cuenta es que el nombre de los dos argumentos (argc y argv) son tradicionales pero arbitrarios, es decir que se les puede dar el nombre que a nosotros nos interese, manteniendo eso si el tipo y el nmero de argumentos que recibe. SINTAXIS:
void main(int argc, char *argv[]) { cuerpo; }
PROGRAMA #2P
Descripcin: Este programa requiere ejecutarse en la lnea de comandos del DOS: escribir el nombre del programa y otros dos parmetros numricos.
#include <stdio.h> #include <conio.h> void main(int argc, char *argv[]) { clrscr(); if(argc!=3) //controlo el n de argumentos { printf("Error en n de argumentos"); exit(0); } printf("Suma de valores\n"); printf("Total= %d",atoi(argv[1])+atoi(argv[2])); getch(); }
31
Programacin II
RECURSIVIDAD: Es el proceso de definir algo en trminos de si mismo, es decir que las funciones pueden llamarse a si mismas, esto se consigue cuando en el cuerpo de la funcin hay una llamada a la propia funcin, se dice que es recursiva. Una funcin recursiva no hace una nueva copia de la funcin, solo son nuevos los argumentos. La principal ventaja de las funciones recursivas es que se pueden usar para crear versiones de algoritmos ms claras y sencillas. Cuando se escriben funciones recursivas, se debe tener una sentencia if para forzar a la funcin a volver sin que se ejecute la llamada recursiva.
EJEMPLO:
int fact(int numero) { int resp; if(numero==1) return 1; resp=fact(numero-1)*numero; return(resp); }
Programas propuestos para la unidad 2 1. Programa que pida 3 numeros enteros y en base a ellos indicar cual es el mayor y cual es el menor. 2. Programa que lee un nmero entero positivo y como resultado tendra que indicar si es un nmero primo. 3. Programa que crea un cuadro de ciertas medidas mediante el uso de una funcin definida por el usuario. 4. Programa que convierta de grados Fahrenheit a Centigrados o viceversa
32
Programacin II
UNIDAD III ARREGLOS

Objetivo educacional: El alumno aplicar el concepto de arreglos en la manipulacin de datos.
7. ARRAYS Y CADENAS
Un array es una coleccin de variables del mismo tipo que se referencian por un nombre en comn. A un elemento especifico de un array se accede mediante un ndice. Todos los array constan de posiciones de memoria contiguas. La direccin mas baja corresponde al primer elemento. Los arrays pueden tener de una a varias dimensiones. UNIDIMENSIONALES El array ms comn en C es la cadena (array de caracteres terminado por un nulo). Todos los array tienen el 0 como primer elemento. Hay que tener muy presente el no rebasar el ltimo ndice. La cantidad de memoria requerida para guardar un array est directamente relacionada con su tipo y su tamao. SINTAXIS:
tipo nombre_array [n elementos]; tipo nombre_array [n elementos]={valor1,valor2,valorN}; tipo nombre_array[]={valor1,valor2,valorN};
INICIALIZACIN DE UN ELEMENTO:
nombre_array[indice]=valor;
UTILIZACIN DE ELEMENTOS:
nombre_array[indice];
PROGRAMA #3A
Descripcin: Reserva 100 elementos enteros, los inicializa todos y muestra el 5 elemento.
#include <conio.h> #include <stdio.h> void main(void) { int x[100]; int cont; clrscr(); for(cont=0;cont<100;cont++) x[cont]=cont; printf("%d",x[4]); getch(); }
33
Programacin II
El uso ms comn de los arrays unidimensionales es con mucho las cadenas, conjunto de caracteres terminados por el carcter nulo ( \0). Por tanto cuando se quiera declarar una arrays de caracteres se pondr siempre una posicin ms. No es necesario aadir explcitamente el carcter nulo el compilador lo hace automticamente. SINTAXIS:
char nombre[tamao]; char nombre[tamao]=cadena; char nombre[]=cadena;
BIDIMENSIONALES: C admite arrays multidimensionales, la forma ms sencilla son los arrays bidimensionales. Un array bidimensional es esencialmente un array de arrays unidimensionales. Los array bidimensionales se almacenan en matrices fila-columna, en las que el primer ndice indica la fila y el segundo indica la columna. Esto significa que el ndice ms a la derecha cambia ms rpido que el de ms a la izquierda cuando accedemos a los elementos. SINTAXIS:
tipo nombre_array[fila][columna]; tipo nomb_array[fil][col]={{v1,v2,vN},{v1,v2,vN},{vN}}; tipo nomb_array[][]={{v1,v2,vN},{v1,v2,vN},{vN}};
INICIALIZACIN DE UN ELEMENTO:
nombre_array[indice_fila][indice_columna]=valor;
UTILIZACIN DE UN ELEMENTO:
nombre_array[indice_fila][indice_columna];
Para conocer el tamao que tiene un array bidimensional tenemos que multiplicar las filas por las columnas por el nmero de bytes que ocupa en memoria el tipo del array. Es exactamente igual que con los array unidimensionales lo nico que se aade son las columnas.
filas * columnas * bytes_del_tipo
Un uso muy comn de los arrays bidimensionales es crear un array de cadenas. En este tipo de array el nmero de filas representa el nmero de cadenas y las columnas representa la longitud de cada una de esas cadenas.
34
Programacin II
PROGRAMA #3B
Descripcin: Introduce 10 cadenas y luego las muestra en pantalla en orden descendente de cmo se capturaron.
#include <conio.h> #include <stdio.h> void main(void) { char texto[10][80]; int indice; clrscr(); for(indice=0;indice<10;indice++) { printf("%2.2d:",indice+1); gets(texto[indice]); } printf("pulsa tecla"); getch(); clrscr(); for(indice=9;indice>=0;indice--) printf("%s\n",texto[indice]); getch(); }
8. FUNCIONES DE CARACTERES Y CADENAS

La biblioteca estndar de C tiene un rico y variado conjunto de funciones de manejo de caracteres y caracteres. En una implementacin estndar, las funciones de cadena requieren el archivo de cabecera STRING.H, que proporciona sus prototipos. Las funciones de caracteres utilizan CTYPE.H, como archivo de cabecera.
ISALPHA: Devuelve un entero. DISTINTO DE CERO si la variable es una letra del alfabeto, en caso contrario devuelve cero. Cabecera: <ctype.h>.
int isalpha(variable_char);
ISDIGIT: Devuelve un entero. DISTINTO DE CERO si la variable es un nmero (0 a 9), en caso contrario devuelve cero. Cabecera <ctype.h>.
int isdigit(variable_char);
ISGRAPH: Devuelve un entero. DISTINTO DE CERO si la variable es cualquier carcter imprimible distinto de un espacio, si es un espacio CERO. Cabecera <ctype.h>.
int isgraph(variable_char);
ISLOWER: Devuelve un entero. DISTINTO DE CERO si la variable esta en minscula, en caso contrario devuelve cero. Cabecera <ctype.h>.
int islower(variable_char);
35
Programacin II
ISPUNCT: Devuelve un entero. DISTINTO DE CERO si la variable es un carcter de puntuacin, en caso contrario, devuelve cero. Cabecera <ctype.h>
int ispunct(variable_char);
ISUPPER: Devuelve un entero. DISTINTO DE CERO si la variable esta en maysculas, en caso contrario, devuelve cero. Cabecera <ctype.h>
int isupper(varible_char);
MEMSET: Inicializa una regin de memoria (buffer) con un valor determinado. Se utiliza principalmente para inicializar cadenas con un valor determinado. Cabecera <string.h>.
memset (var_cadena,carcter,tamao);
STRCAT: Concatena cadenas, es decir, aade la segunda cadena a la primera, la primera cadena no pierde su valor origina. Lo nico que hay que tener en cuenta es que la longitud de la primera cadena debe tener la longitud suficiente para guardar la suma de las dos cadenas. Cabecera <string.h>.
strcat(cadena1,cadena2);
STRCHR: Devuelve un puntero a la primera ocurrencia del carcter especificado en la cadena donde se busca. Si no lo encuentra, devuelve un puntero nulo. Cabecera <string.h>.
strchr(cadena,carcter); strchr(texto,carcter);
STRCMP: Compara alfabticamente dos cadenas y devuelve un entero basado en el resultado de la comparacin. La comparacin no se basa en la longitud de las cadenas. Muy utilizado para comprobar contraseas. Cabecera <string.h>.
strcmp(cadena1,cadena2); strcmp(cadena2,texto);
RESULTADO VALOR Menor a Cero Cero Mayor a Cero DESCRIPCIN

Cadena1 menor a Cadena2. Las cadenas son iguales. Cadena1 mayor a Cadena2.
STRCPY: Copia el contenido de la segunda cadena en la primera. El contenido de la primera se pierde. Lo nico que debemos contemplar es que el tamao de la segunda cadena sea menor o igual a la cadena donde la copiamos. Cabecera <string.h>.
strcpy(cadena1,cadena2); strcpy(cadena1,texto);
36
Programacin II
STRLEN: Devuelve la longitud de la cadena terminada en nulo. El carcter nulo no se contabiliza. Devuelve un valor entero que indica la longitud de la cadena. Cabecera <string.h>.
variable=strlen(cadena);
STRNCAT: Concatena el nmero de caracteres de la segunda cadena en la primera cadena. La primera no pierde la informacin. Hay que controlar que la longitud de la primera cadena debe tener longitud suficiente para guardar las dos cadenas. Cabecera <string.h>.
strncat(cadena1,cadena2,n de caracteres);
STRNCMP: Compara alfabticamente un nmero de caracteres entre dos cadenas. Devuelve un entero segn el resultado de la comparacin. Los valores devueltos son los mismos que en la funcin strcmp. Cabecera <string.h>.
strncmp(cadena1,cadena2,n de caracteres); strncmp(cadena1,texto,n de caracteres);
STRNCPY: Copia un nmero de caracteres de la segunda cadena a la primera. En la primera cadena se pierden aquellos caracteres que se copian de la segunda. Cabecera <string.h>.
strncpy(cadena1,cadena2,n de caracteres); strncpy(cadena1,texto,n de caracteres);
STRRCHR: Devuelve un puntero a la ltima ocurrencia del carcter buscado en la cadena. Si no lo encuentra devuelve un puntero nulo. Cabecera <string.h>.
strrchr(cadena,carcter); strrchr(texto,carcter);
STRPBRK: Devuelve un puntero al primer carcter de la cadena que coincida con algn carcter de la cadena a buscar. Si no hay correspondencia devuelve un puntero nulo. Cabecera <string.h>.
strpbrk(texto,cadena_de_busqueda); strpbrk(cadena,cadena_de_busqueda);
TOLOWER: Devuelve el carcter equivalente al de la variable en minsculas, si la variable es una letra y la deja como esta si la letra esta en minsculas. Cabecera <ctype.h>.
variable_char=tolower(variable_char);
TOUPPER: Devuelve el carcter equivalente al de la variable en maysculas, si la variable es una letra y la deja como esta si la letra esta en minsculas. Cabecera <ctype.h>.
variable_char=toupper(variable_char);
37
Programacin II
PROGRAMA #3C
Descripcin: Cuenta el numero de letras y nmeros que hay en una cadena. La longitud debe ser siempre de cinco por no conocer an la funcin que me devuelve la longitud de una cadena.
#include <conio.h> #include <stdio.h> #include <ctype.h> void main(void) { int ind,cont_num=0,cont_text=0; char temp; char cadena[6]; clrscr(); printf("Introducir 5 caracteres: "); gets(cadena); for(ind=0;ind<5;ind++) { temp=isalpha(cadena[ind]); if(temp) cont_text++; else cont_num++; } printf("El total de letras es %d\n",cont_text); printf("El total de nmeros es %d\n",cont_num); getch(); }
PROGRAMA #3D
Descripcin: Utilizando el resto de funciones nos va a dar informacin completa del valor que contiene la variable.
#include<conio.h> #include<stdio.h> #include<ctype.h> void main(void) { char letra; clrscr(); printf("Introducir valor: "); letra=getchar(); if(isdigit(letra)) printf("Es un numero"); else { if(islower(letra)) printf("Letra en minuscula"); else printf("Letra en mayuscula"); if(ispunct(letra)) printf("Caracter de puntuacin"); if(!isgraph(letra)) printf("Es un espacio"); } getch(); }
38
Programacin II
PROGRAMA #3E
Descripcin: Copia, concatena, mide e inicializa cadenas.
#include<conio.h> #include<stdio.h> #include<string.h> void main(void) { char *origen,destino[20]; clrscr(); printf("Introducir origen: "); gets(origen); strcpy(destino,origen); printf("%s\n%s\n\n",destino,origen); getch(); memset(destino,'\0',20); menset(destino,'x',6); if(strlen(origen)<14) { printf("Se pueden concatenar\n"); strcat(destino,origen); } else printf("No se pueden concatenar\n"); printf("%s",destino); getch(); }
PROGRAMA #3F
Descripcin: Pide una contrasea de entrada. Luego pide 10 cdigos de 6 dgitos. Por ltimo pide los 3 primeros dgitos de los cdigos que deseas ver.
#include #include #include #include <conio.h> <stdio.h> <string.h> <dos.h>
void main(void) { int cont; char ver_codigo[4]; char contra[6]="abcde"; char tu_contra[6]; char codigos[10][7]; clrscr(); printf("Contrasea "); gets(tu_contra);
39
Programacin II
clrscr(); if(strcmp(tu_contra,contra)) { printf("ERROR"); delay(2000); exit(0); } printf("Introducir codigos\n"); for(cont=0;cont<10;cont++); { printf("%2.2d: ",cont-1); gets(codigos[cont]); } clrscr(); printf("Codigo a listar? "); gets(ver_codigo); for(cont=0;cont<10;cont++); { if(strncmp(ver_codigo,codigos[cont],3)) printf("%s\n",codigos[cont]); } getch(); }
PROGRAMA #3G
Descripcin: En el cuadro de la izquierda busca la primera coincidencia y muestra la cadena a partir de esa coincidencia. En el cuadro de la derecha busca la ltima coincidencia y muestra la cadena a partir de ese punto.
#include<stdio.h> #include<conio.h> #include<string.h> void main(void) { char letra; char *resp; char cad[30]; clrscr(); printf("Cadena: "); gets(cad); printf("Buscar Letra: "); letra=getchar(); resp=strchr(cad,letra); if(resp) printf("%s",resp); else printf("No esta"); getch(); } } #include<stdio.h> #include<conio.h> #include<string.h> void main(void) { char letra; char *resp; char cad[30]; clrscr(); printf("Cadena: "); gets(cad); printf("Buscar Letra: "); letra=getchar(); resp=strrchr(cad,letra); if(resp) printf("%s",resp); else printf("No Esta"); getch();
40
Programacin II
PROGRAMA #3H
Descripcin: En este ejemplo se busca en una cadena a partir de un grupo de caracteres. Si no encuentra coincidencia con ninguna letra en la cadena muestra un mensaje de error.
#include <stdio.h> #include <conio.h> #include <string.h> void main(void) { char letras[5]; char *resp; char cad[30]; clrscr(); printf("Introducir cadena: "); gets(cad); printf("Posibles Letras (4): "); gets(letras); resp=strpbrk(cad,letras); if(resp) printf("%s",resp); else printf("Error"); getch(); }
PROGRAMA #3I
Descripcin: El programa permite leer desde teclado caracteres que no sean numricos.
#include <stdio.h> #include <conio.h> #include <ctype.h> void main(void) { char x=0,y=0; clrscr(); printf("Programa que solo capta caracteres no numricos "); printf("Introduzca carcter: "); scanf("%c",&y); x=isalpha(y); if(x) printf("\nEl carcter capturado:%c",y); getch(); }
41
Programacin II
PROGRAMA #3J
Descripcin: El programa lee un carcter (que no sea vocal) y determina a cuantas posiciones se encuentra de las dos vocales mas prximas a el y cuales son. Adems considera maysculas y minsculas indistintamente.
#include #include #include #include #include <stdio.h> <conio.h> <ctype.h> <string.h> <stdlib.h>
void main(void) { char letra, *rep, *ret; char alfa[]="abcdefghijklmnopqrstuvwxyz", vocal[]="aeiou"; clrscr(); printf("Introduzca el caracter: "); letra=tolower(getchar()); if(isalpha(letra)) { rep=strchr(vocal,letra); if(rep) { printf("No acepta vocales"); getch(); exit(0); } else { ret=strchr(alfa,letra); printf("La posicion de la letra es: %d",(ret+1)-alfa); } } getch(); }
Programas propuestos para la unidad 3 1. Programa que utilice al menos 3 funciones de cadena. 2. Programa que pida el nombre y no acepte caracteres diferentes a los alfabticos y la edad que solo sean valores numricos entre 1 y 100. 3. Escribir un programa que convierta un nmero romano (en forma de cadena de caracteres) en un nmero arbigo Reglas de conversin M=1000, D=500, C=100, L=50, X=10, V=5, I=1 4. Se introduce una frase por teclado. Se desea imprimir cada palabra de la frase en lneas diferentes y consecutivas. 5. Escribir un programa que permita escribir en sentido inverso una cadena de caracteres.
42
Programacin II
UNIDAD IV APUNTADORES Y ESTRUCTURAS

Objetivo educacional: El alumno utilizar los apuntadores y estructuras para la realizacin de programas ms eficientes.
9. ESTRUCTURAS, UNIONES, ENUMERACIONES

C proporciona formas diferentes de creacin de tipos de datos propios. Uno de ellos es la agrupacin de variables bajo un mismo nombre, Otra es permitir que la misma parte de memoria sea definida como dos o ms tipos diferentes de variables y tambin crear una lista de constantes entera con nombre. ESTRUCTURAS Una estructura es una coleccin de variables que se referencia bajo un nico nombre, proporcionando un medio eficaz de mantener junta una informacin relacionada. Las variables que componen la estructura se llaman miembros de la estructura y est relacionado lgicamente con los otros. Otra caracterstica es el ahorro de memoria y evitar declarar variables que tcnicamente realizan las mismas funciones. SINTAXIS:
struct nombre { var1; var2; varN; }; . . . struct nombre etiqueta1,etiquetaN; struct nombre { var1; var2; varN; } etiqueta1,etiquetaN;
Los miembros individuales de la estructura se referencian utilizando la etiqueta de la estructura el operador punto(.) y la variable a la que se hace referencia. Los miembros de la estructura deben ser inicializados fuera de ella, si se hace en el interior da error de compilacin.
etiqueta.variable;
PROGRAMA #4A
Descripcin: El programa es un ejemplo de apuntadores y estructuras
#include <stdio.h> #include <conio.h> void main(void) { int opcion=0; struct ficha{ char nombre[40]; char apellido[50]; unsigned edad;} empleado,usuario;
43
Programacin II
do { clrscr(); gotoxy(2,4);printf("1.-Empleados"); gotoxy(2,5);printf("2.-Usuarios"); gotoxy(2,6);printf("0.-Visualizar"); gotoxy(2,7);printf("Elegir Opcion: "); scanf("%d",&opcion); if(opcion==0) break; if(opcion==1) { gotoxy(2,10);printf("Nombre: "); gets(empleado.nombre); gotoxy(2,11);printf("Apellido: "); gets(empleado.apellido); gotoxy(2,12);printf("Edad: "); scanf("%d",&empleado.edad); } else { gotoxy(2,10);printf("Nombre: "); gets(usuario.nombre); gotoxy(2,11);printf("Apellido: "); gets(usuario.apellido); gotoxy(2,12);printf("Edad: "); scanf("%d",&usuario.edad); } }while(opcion!=0); gotoxy(2,18);printf("%s %s\n",empleado.nombre,empleado.apellido); gotoxy(2,19);printf("%u aos",empleado.edad); gotoxy(30,18);printf("%s %s\n",usuario.nombre,usuario.apellido); gotoxy(30,19);printf("%u aos",usuario.edad); getch(); }
Las operaciones ms comunes es asignar el contenido de una estructura a otra estructura del mismo tipo mediante una nica sentencia de asignacin como si fuera una variable es decir no es necesario ir elemento por elemento. Otra operacin muy comn son los arrays de estructuras. Para declarar un array de estructuras, se debe definir primero la estructura y luego declarar la etiqueta indicando el nmero de elementos. SINTAXIS:
struct nombre{ var1; var2; varN; }etiqueta[n elementos];
Como ejemplo de array de estructuras deberemos crear una lista de correos utilizando estructuras para guardar la informacin. Las operaciones que deben hacerse son aadir datos, borrar datos y realizar listados. El nmero de registros que va a mantener es de 100. Se deber controlar que no supere el lmite mximo.
44
Programacin II
UNIONES Una unin es una posicin de memoria que es compartida por dos o ms variables diferentes, generalmente de distinto tipo, en distintos momentos. La declaracin es similar a la estructura. Cuando se crea una etiqueta de la unin el compilador reserva memoria para el mayor miembro de la unin. El uso de una unin puede ayudar a la creacin de cdigo independiente de la mquina y ahorra memoria en la declaracin de variables. Para referencia a un elemento de la unin se hace igual que si fuera una estructura. SINTAXIS:
union nombre{ var1; var2; varN }; . . union nombre etiqueta1,etiquetaN; union nombre{ var1; var2; varN }etiqueta1,etiquetaN;
PROGRAMA #4B
Descripcin: Este programa pide un nombre y luego imprime el nombre con las iniciales.
#include <stdio.h> #include <conio.h> #include <stdlib.h> union persona { char nombre[10]; char inicial; } pers; int main() { printf("Escribe tu nombre: "); gets(pers.nombre); printf("\nTu nombre es: %s\n",pers.nombre); printf("\nTu inicial es: %c\n",pers.inicial); getch(); return 0; }
45
Programacin II
ENUMERACIONES Es un conjunto de constantes enteras con nombre que especifica todos los valores vlidos que una variable de ese tipo puede tener. La definicin es muy parecida a las estructuras, la palabra clave enum seala el comienzo de un tipo enumerado. El valor del primer elemento de la enumeracin es 0 aunque se puede especificar el valor de uno o ms smbolos utilizando una asignacin. SINTAXIS:
enum nombre{lista_de_enumeraciones}etiqueta1,etiquetaN; enum nombre{lista_de_enumeraciones}; . . . enum nombre etiqueta1,etiquetaN;
PROGRAMA #4C
Descripcin: Este programa hace conversiones de moneda.
#include <stdio.h> #include <conio.h> void main(void) { enum moneda{dolar,penique=100,medio=50,cuarto=25}; enum moneda dinero; clrscr(); printf("Valor de la moneda: "); scanf("%d",&dinero); switch(dinero) { case dolar: printf("Con ese valor es un Dolar"); break; case penique: printf("Con ese valor es un penique"); break; case medio: printf("con ese valor es Medio-Dolar"); break; case cuarto: printf("Con ese valor es un cuarto"); break; default: printf("Moneda Inexistente"); } getch(); }
46
Programacin II
10.PUNTEROS
Un puntero es una variable que contiene una direccin de memoria. Esa direccin es la posicin de n objeto (normalmente una variable) en memoria. Si una variable va a contener un puntero, entonces tiene que declararse como tal. Cuando se declara un puntero que no apunte a ninguna posicin valida ha de ser asignado a un valor nulo (un cero). SINTAXIS:
tipo *nombre;
OPERADORES: El & devuelve la direccin de memoria de su operando. El * devuelve el valor de la variable localizada en la direccin que sigue. Pone en m la direccin de memoria de la variable cuenta. La direccin no tiene nada que ver con el valor de cuenta. En la segunda lnea pone el valor de cuenta en q.
m= &cuenta; q=*m;
PROGRAMA #4D
Descripcin: Devuelve la direccion de memoria.
#include <stdio.h> #include <conio.h> void main(void) { int *p; int valor; clrscr(); printf("Introducir valor: "); scanf("%d",&valor); p=&valor; printf("Direccin de memoria de valor es: %p\n",p); printf("El valor de la variable es: %d",*p); getch(); }
PROGRAMA #4E
Descripcin: Realiza la asignacin de un puntero a otro puntero
#include <conio.h> #include <stdio.h> void main(void) { int x; int *p1, *p2; p1=&x; p2=p1; printf(%p,p2); getch(); }
47
Programacin II
ARITMTICA: Dos operaciones aritmticas que se pueden usar como punteros, la suma y la resta. Cuando se incrementa un puntero, apunta a la posicin de memoria del siguiente elemento de su tipo base. Cada vez que se decrementa, apunta a la posicin del elemento anterior.
p1++; p1--; p1+12;
COMPARACIN: Se pueden comparar dos punteros en una expresin relacional. Generalmente, la comparacin de punteros se utiliza cuando dos o ms punteros apuntan a un objeto comn.
if(p<q) printf (p apunta a menor memoria que q);
ARRAY DE PUNTEROS: Los punteros pueden estructurarse en arrays como cualquier otro tipo de datos. Hay que indicar el tipo y el nmero de elementos. Su utilizacin posterior es igual que los arrays que hemos visto anteriormente, con la diferencia de que se asignan direcciones de memoria. DECLARACIN:
tipo *nombre[n elementos];
ASIGNACIN:
nombre_array[indice]=&variable;
UTILIZAR ELEMENTOS:
*nombre_array[indice];
48
Programacin II
PROGRAMA #4F
Descripcin: Este programa es un ejemplo del nmero de pila en el que se almacena.
#include <stdio.h> #include <conio.h> #include <stdlib.h> void guarda(int i); int recupera(void); int *top, *p1, pila[50]; void main(void) { int valor; clrscr(); top=pila; p1=pila; do{ printf("Introducir un valor: "); scanf("%d",&valor); if(valor!=0) guarda(valor); else printf("En lo alto: %d\n",recupera()); }while(valor!=-1); } void guarda(int i) { if(p1==(top+50)) { printf("Pila desbordada"); exit(1); } p1++; *p1=i; } int recupera(void) { if(p1==top) { printf("Pila vaca"); exit(1); } p1--; getch(); return *(p1+1); }
49
Programacin II
PROGRAMA #4G
Descripcin: Este programa se introduce un nmero y se le asigna el dia respecto al nmero.
#include <stdio.h> #include <conio.h> void dias(int n); void main(void) { int num; clrscr(); printf("Introducir no. de Da: "); scanf("%d",&num); dias(num); getch(); } void dias(int n) { char *dia[]={"No. de da no Valido", "Lunes", "Martes", "Mircoles", "Jueves", "Viernes", "Sbado", "Domingo"}; printf("%s",dia[n]); }
PUNTEROS A CADENAS: Existe una estrecha relacin entre punteros y los arrays. Se asigna la direccin del primer elemento del array y as se conoce el comienzo del array, el final lo sabemos mediante el nulo que tienen todas las cadenas al final. Con esta relacin se puede declarar una cadena sin tener en cuenta la longitud de la cadena. Otra caracterstica importe es la posibilidad es poder pasar cadenas a las funciones.
SINTAXIS:
char *nombre; char *nombre[];
50
Programacin II
PROGRAMA #4H
Descripcin: En este ejemplo se pueden incluir primer apellido o el primero y el segundo, la longitud de la cadena no importa. Mostramos el contenido de apellidos y su direccin de memoria.
#include <stdio.h> #include <conio.h> void main(void) { char *apellidos; clrscr(); printf("Introducir apellidos: "); gets(apellidos); printf("Tus apellidos son: %s",apellidos); printf("La direccin de memoria es: %p",apellidos); getch(); }
PUNTEROS A ESTRUCTURAS: C permite punteros a estructuras igual que permite punteros a cualquier otro tipo de variables. El uso principal de este tipo de punteros es pasar estructuras a funciones. Si tenemos que pasar toda la estructura el tiempo de ejecucin puede hacerse eterno, utilizando punteros slo se pasa la direccin de la estructura. Los punteros a estructuras se declaran poniendo * delante de la etiqueta de la estructura.. SINTAXIS:
struct nombre_estructura etiqueta; struct nombre_estructura *nombre_puntero;
Para encontrar la direccin de una etiqueta de estructura, se coloca el operador & antes del nombre de la etiqueta. Para acceder a los miembros de una estructura usando un puntero usaremos el operador flecha (->).
PROGRAMA #4I Descripcion: Programa que muestra un ejemplo de como acceder a la estructura usando un puntero.
#include <stdio.h> #include <conio.h> void main(void) { struct ficha{ int balance; char nombre[80]; }*p; clrscr(); printf("Nombre: "); gets(p->nombre); printf("Balance: "); scanf("%d",&p->balance); printf("%s",p->nombre); printf("\t%d",p->balance); getch(); }
51
Programacin II
ASIGNACIN DINAMICA DE MEMORIA: La asignacin dinmica es la forma en que un programa puede obtener memoria mientras se est ejecutando. Hay ocasiones en que un programa necesita usar cantidades de memoria variable. La memoria se obtiene del montn (regin de la memoria libre que queda entre el programa y la pila). El tamao del montn es desconocido pero contiene gran cantidad de memoria. El sistema de asignacin dinmica esta compuesto por las funciones malloc()que asigna memoria a un puntero y free()que libera la memoria asignada. Ambas funciones necesitan el archivo de cabecera stdlib.h. SINTAXIS:
puntero=malloc(numero_de_bytes); free(puntero);
PROGRAMA #4J
Descripcin: En este ejemplo se puede ver como se le puede asignar memoria en el programa.
#include <stdio.h> #include <conio.h> #include <stdlib.h> #include <string.h> void main(void) { char *c; int t; clrscr(); c=(char*)malloc(80); if(!c) { printf("Fallo al asignar memoria"); exit(1); } printf("Introducir cadena: "); gets(c); for(t=strlen(c)-1;t>=0;t--) putchar(c[t]); free(c); getch(); }
INDIRECCIN MLTIPLE: Que un puntero apunte a otro puntero que apunte a un valor de destino. En el caso de un puntero a puntero, el primer puntero contiene la direccin del segundo puntero, que apunta al objeto que contiene el valor deseado. La siguiente declaracin indica al compilador que es un puntero a puntero de tipo float.
float **balance;
52
Programacin II
PROGRAMA #4K
Descripcin: Programa que demuestra el procedimiento copia el cual, copia una cadena en otra.
#include<stdio.h> #include<conio.h> #include<string.h> char *copia(char *cad1, char *cad2); void main(void) { char palabra1[10]; char palabra2[20]; printf("Palabra 1= "); scanf("%s",palabra1); printf("Palabra 2= "); scanf("%s",palabra2); copia(palabra1,palabra2); printf("Palabra 1 + Palabra 2 = %s",palabra2); getch(); } char *copia(char *cad1, char *cad2) { char *inicio; inicio=cad2; while(*cad2!='\0') cad2++; while(*cad1!='\0') { *cad2=*cad1; cad2++; cad1++; } *cad2='\0'; cad2=inicio; }
53
Programacin II
Programas propuestos para la unidad 4 1. Programa que lea el nombre, domicilio, telefono y CP. para 10 personas usando estructuras; despus los imprima en orden inverso. 2. Programa similar que lea el nombre, apellidos, edad de 5 personas unsando punteros. 3. Escribir un programa que lea un nmero determinado de enteros desde el teclado y los imprima en el mismo orden y con la condicin de que cada entero slo se escribe una vez. Si el entero ya se ha impreso, no se debe imprimir de nuevo. Por ejemplo si los nmeros siguientes se leen desde el teclado: 55 78 -25 3 55 24 -3 7, el programa debe imprimir lo siguiente: 55 78 -25 3 24 -3 7. 4. Escribir una funcin que utilice punteros para copiar un array de elementos double 5. Escribir el cdigo de la funcin siguiente que devuelve la suma de elementos float apuntados por los n primeros punteros del array p: flota suma(flota *p[], int n)
54
Programacin II
UNIDAD V ARCHIVOS
Objetivo educacional: El alumno utilizar los archivos para el procesamiento de informacin.
11.ARCHIVOS (FICHEROS)
El sistema de archivos de C est diseado para secuencias que son independientes del dispositivo. Existen dos tipos se secuencias: de texto que es una ristra de caracteres organizados en lneas terminadas por el carcter salto de lnea. Secuencia binaria que es una ristra de bytes con una correspondencia uno a uno con los dispositivos. En esencia C trabaja con dos tipos de archivo secuenciales (texto) y binarios (registros). Todas las operaciones de ficheros se realizan a travs de llamadas a funciones que estn definidas en en fichero de cabecera CONIO.H o IO.H. Esto permite una gran flexibilidad y facilidad a la hora de trabajar con ficheros. Mediante una operacin de apertura se asocia una secuencia a un archivo especificado, esta operacin de apertura se realiza mediante un puntero de tipo FILE donde estn definidas las caractersticas del fichero (nombre, estado, posicin,). Una vez abierto el fichero escribiremos y sacaremos informacin mediante las funciones implementadas y por ltimo cerraremos los ficheros abiertos. ABRIR FICHERO: La funcin fopen abre una secuencia para que pueda ser utilizada y vinculada con un archivo. Despus devuelve el puntero al archivo asociado, si es NULL es que se ha producido un error en la apertura. Se utiliza un puntero de tipo FILE para abrir ese fichero. Sirve para los dos tipos de ficheros. Cabecera <stdio.h>.
FILE *nombre_puntero_fichero; fopen(char_nombre_archivo,char_modo_apertura);
MODOS DE APERTURA VALOR r w a rb wb ab r+ w+ a+ r+b w+b a+b DESCRIPCIN

Abre un archivo de texto para lectura. Crea un archivo de texto para escritura. Abre un archivo de texto para aadir informacin. Abre un archivo binario para lectura. Crea un archivo binaro para escritura. Abre un archivo binario para aadir informacin. Abre un archivo de texto para lectura / escritura. Crea un archivo de texto para lectura / escritura. Abre o Crea un archivo de texto para aadir informacin. Abre un archivo binario para lectura / escritura. Crea un archivo binaro para lectura / escritura. Abre o Crea un archivo binario para aadir informacin
55
Programacin II
CIERRE FICHERO: Una vez terminadas las operaciones de escritura y lectura hay que cerrar la secuencia (archivo). Se realiza mediante la llamada a la funcin fclose() que cierra un fichero determinado o fcloseall() que cierra todos los archivos abiertos. Estas funciones escribe la informacin que todava se encuentre en el buffer y cierra el archivo a nivel de MSDOS. Ambas funciones devuelve CERO si no hay problemas. La cabecera que utilizan es <stdio.h>.
int fclose(puntero_fichero); int fcloseall();
PROGRAMA #5A
#include <stdio.h> #include <conio.h> void main(void) { FILE *punt_fich; clrscr(); if((punt_fich=fopen("hola.txt","w"))==NULL) { printf("Error en la apertura"); exit(0); } printf( Ya se creo el archivo hola.txt verificalo); getch(); fclose(punt_fich); }
ESCRITURA DE CARACTERES Y CADENAS EN SECUENCIALES
FPUTC/PUTC: Escribe un carcter en el fichero abierto por el puntero que se pone como parmetro. Si todo se produce correctamente la funcin devuelve el propio carcter, si hay algn error devuelve EOF. La cabecera que utiliza es <stdio.h>.
int fputc(variable_char,puntero_fichero); int fputc(carcter,puntero_fichero); int putc(variable_char,puntero_fichero); int putc(carcter,puntero_fichero);
56
Programacin II
FPUTS:
Escribe el contenido de la cadena puesta como primer parmetro de la funcin. El carcter nulo no se escribe en el fichero. Si se produce algn error devuelve EOF y si todo va bien devuelve un valor no negativo. La cabecera <stdio.h>.
int fputs(variable_cadena,puntero_fichero); int fputs(texto,puntero_fichero);
FPRINTF: Escribe en el fichero cualquier tipo de valor, cadenas, nmeros y caracteres. Esta funcin tiene el mismo formato que printf. Hay que indicarle el puntero, el identificador de formato y nombre de la variables o variables a escribir. Cabecera <stdio.h>.
fprintf(puntero_fichero,texto); fprintf(puntero_ficheroidentificador,var); fprintf(puntero_fichident(es)_formato,variable(s));
PROGRAMA #5B
#include <stdio.h> #include <conio.h> #include <string.h> void letra(void); void frase(void); FILE *punt_fich; void main(void) { int opt; clrscr(); if((punt_fich=fopen("hola.txt","w"))==NULL) { printf("Error en la apertura"); exit(0); } printf("1.INTRODUCIR LETRA A LETRA\n"); printf("2.INTRODUCIR CADENA A CADENA\n\n"); printf("Elegir opcion: "); scanf("%d",&opt); fflush(stdin); clrscr(); switch(opt) { case 1: letra(); break; case 2: frase(); break; } fclose(punt_fich); }
57
Programacin II
void letra(void) { char t; for(;t!='$';) { printf(":"); t=getchar(); fputc(t,punt_fich); fflush(stdin); } } void frase(void) { char *frase; do { printf(":"); gets(frase); fprintf(punt_fich,"%s\n",frase); // fputs(frase,punt_fich); fflush(stdin); }while(strcmp(frase,"$")); }
LECTURA DE CARACTERES Y CADENAS EN SECUENCIALES
FGETC/FGET: Devuelve el carcter ledo del fichero e incrementa el indicador de posicin del archivo. Si se llega al final del fichero la funcin devuelve EOF. Todos los valores que lee los transforma a carcter. Cabecera es <stdio.h>.
var_char=fgetc(puntero_fichero); var_char=getc(puntero_fichero);
FGETS:
Lee un determinado nmero de caracteres de un fichero y los pasa a una variable de tipo cadena. Lee caracteres hasta que encuentra un salto de lnea, un EOF o la longitud especificada en la funcin. Si se produce un error devuelve un puntero NULL. La Cabecera es <stdio.h>.
fgets(variable_cadena,tamao,puntero_fichero);
58
Programacin II
PROGRAMA #5C
#include <stdio.h> #include <conio.h> void letra(void); void frase(void); FILE *punt_fich; void main(void) { int opt; clrscr(); if((punt_fich=fopen("hola.txt","r"))==NULL) { printf("Error en la apertura"); exit(0); } printf("1.LEER LETRA A LETRA\n"); printf("2.LEER CADENAS\n\n"); printf("Elegir opcion: "); scanf("%d",&opt); fflush(stdin); clrscr(); switch(opt) { case 1: letra(); break; case 2: frase(); break; } getch(); fclose(punt_fich); } void letra(void) { char t=0; for(;t!=EOF;) { t=getc(punt_fich); printf("%c",t); } } void frase(void) { char frase[31]; fgets(frase,30,punt_fich); printf("%s",frase); }
59
Programacin II
POSICION EN FICHEROS SECUENCIALES Y BINARIOS
REWIND: Lleva el indicador de posicin al principio del archivo. No devuelve ningn valor. La cabecera que utiliza es <stdio.h>.
rewind(puntero_fichero);
FGETPOS: Guarda el valor actual del indicador de posicin del archivo. El segundo termino es un objeto del tipo fpos_t que guarda la posicin. El valor almacenado slo es valido para posteriores llamadas a fsetpos. Devuelve DISTINTO DE CERO si se produce algn error y CERO si todo va bien. Cabecera <stdio.h>.
int fgetpos(puntero_fichero,&objeto_fpos_t);
FSETPOS: Desplaza el indicador de posicin del archivo al lugar especificado por el segundo termino que es un objeto fpos_t. Este valor tiene que haber sido obtenido por una llamada a fgetpos. Devuelve DISTINTO DE CERO si hay errores y CERO si va todo bien. Cabecera <stdio.h>.
int fsetpos(puntero_fichero,&objeto_fpos_t);
TELL:
Devuelve el valor actual del indicador de posicin del archivo. Este valor es el nmero de bytes que hay entre el comienzo del archivo y el indicador. Devuelve 1 si se produce un error. Cabecera <io.h>.
var_long =tell(puntero_fichero);
FEOF:
Determina el final de un fichero binario. Se utiliza siempre que se realizan consultas, informes y listados, va asociado a un bucle que recorre todo el fichero. Cabecera <stdio.h>.
feof(puntero_fichero);
FSEEK:
Sita el indicador del archivo en la posicin indicada por la variable de tipo long (en segundo termino) desde el lugar que le indiquemos mediante el tercer termino de la funcin (mediante una constante). Devuelve 1 si hay error, si no hay error devuelve la nueva posicin. La Cabecera es <io.h>.
var_long=fseek(puntero_fichero,long_despl,int_origen);
CONSTANTE
SEEK_SET SEEK_CUR SEEK_END
DESCRIPCIN
Desde el principio del fichero Desde la posicin actual. Desde el final del fichero
60
Programacin II
PROGRAMA #5D
Descripcin: Programa que demuestra el procedimiento copia el cual, copia una cadena en otra.
#include <stdio.h> #include <conio.h> #include <stdlib.h> void main(void) { FILE *punte; clrscr(); if((punte=fopen("hola.txt","r"))==NULL) { printf("Error de lectura"); exit(0); } fseek(punte,7,SEEK_SET); printf("%c",fgetc(punte)); getch(); fclose(punte); }
ESCRITURA Y LECTURA EN BINARIOS
FWRITE:
Escribe los datos de una estructura a un fichero binario e incrementa la posicin del archivo en el nmero de caracteres escritos. Hay que tener en cuenta que el modo de apertura del fichero debe ser binario Cabecera <stdio.h>.
fwrite(&eti_estru,tamao_estru,n_reg,punter_fichero);
FREAD:
Lee registros de un fichero binario, cada uno del tamao especificado en la funcin y los sita en la estructura indicada en primer termino de la funcin. Adems de leer los registros incrementa la posicin del fichero. Hay que tener en cuenta el modo de apertura del fichero. Cabecera <stdio.h>.
fread(&eti_estru,tamao_estru,n_reg,punter_fichero);
61
Programacin II
PROGRAMA #5E
#include <stdio.h> #include <conio.h> #include <stdlib.h> #include <ctype.h> void altas(void); void muestra(void); FILE *fich; struct ficha{ int cdigo; char nombre[25]; char direcion[40]; int edad; } cliente; void main(void) { char opcion; if((fich=fopen("gestion.dat","a+b"))==NULL) { printf("Error al crear fichero"); exit(0); } do { clrscr(); printf("Altas\n"); printf("Consulta\n"); printf("Salir\n\n"); printf("Elegir opcion: "); scanf("%c",&opcion); fflush(stdin); switch(toupper(opcion)) { case 'A': altas(); break; case 'C': muestra(); break; } } while(toupper(opcion)!='S'); fclose(fich); } void altas(void) { clrscr(); printf("Cdigo: "); scanf("%d",&cliente.codigo); fflush(stdin); printf("Nombre: "); gets(cliente.nombre);
62
Programacin II
fflush(stdin); printf("Direccion: "); gets(cliente.direcion); fflush(stdin); printf("Edad: "); scanf("%d",&cliente.edad); fflush(stdin); fwrite(&cliente,sizeof(cliente),1,fich); } void muestra(void) { int cod_temp; clrscr(); rewind(fich); printf("Cdigo a mostrar:"); scanf("%d",&cod_temp); while(!feof(fich)) { fread(&cliente,sizeof(cliente),1,fich); if(cod_temp==cliente.codigo) { printf("Cdigo: %d\n",cliente.codigo); printf("Nombre: %s\n",cliente.nombre); printf("Direc: %s\n",cliente.direcion); printf("Edad: %d\n",cliente.edad); getch(); break; } } }
Programas propuestos para la unidad 5 1. Abrir un archivo de texto, leerlo lnea a lnea en un array de caracteres y escribirlo de nuevo en otro archivo. 2. Escribir un programa que lea un texto desde el teclado y almacene ese texto en un nuevo archivo de texto con el nombre de miarch.txt El nuevo archivo debe tener la misma estructura de lnea que el archivo de texto escrito desde el teclado. Adems, todas las letras minusculas deben ser traducidas a lestras mayusculas. 3. Escribir un programa que permita crear un archivo inventario de los libros de una librera, as como calcular e imprimir el valor total del inventario. Los campos de cada libro deben ser, como mnimo, ttulo, autor, ISBN, precio, cantidad, editorial.
63
Programacin II
UNIDAD VI UTILIZACIN DE LIBRERIAS EXTERNAS

Objetivo educacional: El alumno utilizar y crear libreras de funciones.
12. FUNCIONES MATEMTICAS

El estndar C define 22 funciones matemticas que entran en las siguientes categoras, trigonomtricas, hiperblicas, logartmicas, exponenciales y otras. Todas la funciones requieren el archivo de cabecera MATH.H. Si un argumento de una funcin matemtica no se encuentra en el rango para el que esta definido, devolver un valor definido EDOM.
ACOS:
Devuelve un tipo double. Muestra el arcocoseno de la variable. La variable debe ser de tipo double y debe estar en el rango 1 y 1, en otro caso se produce un error de dominio. Cabecera <math.h>.
double acos(variable_double);
ASIN:
Devuelve un tipo double. Muestra el arcoseno de la variable. La variable debe ser de tipo double y debe estar en el rango 1 y 1, en otro caso se produce un error de dominio. Cabecera <math.h>.
double asin(variable_double);
ATAN:
Devuelve un tipo double. Muestra el arcotangente de la variable. La variable debe ser de tipo double y debe estar en el rango 1 y 1, en otro caso se produce un error de dominio. Cabecera <math.h>.
double atan(variable_double);
COS:
Devuelve un tipo double. Muestra el coseno de la variable. La variable debe ser de tipo double y debe estar expresada en radianes. Cabecera <math.h>.
double cos(variable_double_radianes);
SIN:
Devuelve un tipo double. Muestra el seno de la variable. La variable debe ser de tipo double y debe estar expresada en radianes. Cabecera <math.h>.
double sin(variable_double_radianes);
TAN:
Devuelve un tipo double. Muestra la tangente de la variable. La variable debe ser de tipo double y debe estar expresada en radianes. Cabecera <math.h>.
double tan(variable_double_radianes);
COSH:
Devuelve un tipo double. Muestra el coseno hiperblico de la variable. La variable debe ser de tipo double y debe estar en el rango 1 y 1, en otro caso se produce un error de dominio. Cabecera debe ser <math.h>.
double cosh(variable_double);
64
Programacin II
SINH:
Devuelve un tipo double. Muestra el seno hiperblico de la variable. La variable debe ser de tipo double y debe estar en el rango 1 y 1, en otro caso se produce un error de dominio. Cabecera debe ser <math.h>.
double sinh(variable_double);
TANH:
Devuelve un tipo double. Muestra la tangente hiperblico de la variable. La variable debe ser de tipo double y debe estar en el rango 1 y 1, en otro caso se produce un error de dominio. Cabecera debe ser <math.h>.
double tanh(variable_double);
PROGRAMA #6A
#include <stdio.h> #include <conio.h> #include <math.h> void main(void) { double radianes; clrscr(); printf("Introducir radianes: "); scanf("%f",&radianes); printf("Coseno= %f\n",cos(radianes)); printf("Seno= %f\n",sin(radianes)); printf("Tangente= %f",tan(radianes)); getch(); }
CEIL:
Devuelve un double que representa el menor entero sin ser menor de la variable redondeada. Por ejemplo, dado 1.02 devuelve 2.0. Si asignamos 1.02 devuelve 1. En resumen redondea la variable a la alta. Cabecera <math.h>.
double ceil(variable_double);
FLOOR: Devuelve un double que representa el entero mayor que no sea mayor a la variable redondeada. Por ejemplo dado 1.02 devuelve 1.0. Si asignamos 1.2 devuelve 2. En resumen redondea la variable a la baja. Cabecera <math.h>.
double floor(variable_double);
FABS:
Devuelve un valor float o double. Devuelve el valor absoluto de una variable float. Se considera una funcin matemtica, pero su cabecera es <stdlib.h>.
var_float fabs(variable_float);
65
Programacin II
LABS:
Devuelve un valor long. Devuelve el valor absoluto de una variable long. Se considera una funcin matemtica, pero su cabecera es <stdlib.h>.
var_long labs(variable_long);
ABS:
Devuelve un valor entero. Devuelve el valor absoluto de una variable int. Se considera una funcin matemtica, pero su cabecera es <stdlib.h>.
var_float abs(variable_float);
MODF:
Devuelve un double. Descompone la variable en su parte entera y fraccionaria. La parte decimal es el valor que devuelve la funcin, su parte entera la guarda en el segundo termino de la funcin. La variables tienen que ser obligatoriamente de tipo double. Cabecera <math.h>.
var_double_deimal=modf(variable,var_parte_entera);
POW:
Devuelve un double. Realiza la potencia de un nmero base elevado a un exponente que nosotros le indicamos. Se produce un error si la base es cero o el exponente es menor o igual a cero. La cabecera es <math.h>.
var_double=pow(base_double,exponente_double);
SQRT:
Devuelve un double. Realiza la raz cuadrada de la variable. La variable no puede ser negativa, si lo es se produce un error de dominio. La cabecera <math.h>.
var_double=sqrt(variable_double);
PROGRAMA #6B
#include <stdio.h> #include <conio.h> #include <math.h> void main(void) { float num; double num_dec,num_ent; clrscr(); printf("Introducir Numero: "); scanf("%f",&num); gotoxy(9,3);printf("ALTO: %.1f",ceil(num)); gotoxy(1,4);printf("REDONDEO"); gotoxy(9,5);printf("BAJO: %.1f",floor(num)); num_dec=modf(num,&num_ent); gotoxy(12,8);printf("ENTERA: %.2f",num_ent); gotoxy(1,9);printf("DESCONPONGO"); gotoxy(12,10);printf("DECIMAL: %.2f",num_dec); gotoxy(1,13); printf("VALOR ABSOLUTO: %.2f",fabs(num)); gotoxy(1,16); printf("R.CUADRADA: %.2f",sqrt(fabs(num))); getch(); }
66
Programacin II
LOG:
Devuelve un double. Realiza el logaritmo natural (neperiano) de la variable. Se produce un error de dominio si la variable es negativa y un error de rango si es cero. Cabecera <math.h>.
double log(variable_double);
LOG10:
Devuelve un valor double. Realiza el logaritmo decimal de la variable de tipo double. Se produce un error de dominio si la variable es negativo y un error de rango si el valor es cero. La cabecera que utiliza es <math.h>.
double log10(var_double);
RAMDOMIZE(): Inicializa la semilla para generar nmeros aleatorios. Utiliza las funciones de tiempo para crear esa semilla. Esta funcin esta relacionada con random. Cabecera <stdlib.h>.
void randomize();
RANDOM:
Devuelve un entero. Genera un nmero entre 0 y la variable menos uno. Utiliza el reloj del ordenador para ir generando esos valores. El programa debe llevar la funcin randomize para cambiar la semilla en cada ejecucin. Cabecera <stdlib.h>.
int random(variable_int);
PROGRAMA #6C
Descripcin: Genera seis nmeros aleatorios entre 1 y 49. No se repite ninguno de ellos.
#include <stdio.h> #include <conio.h> #include <stdlib.h> void main(void) { int num=0,num1=0,repe,temp; int valores[6]; clrscr(); printf("Loteria primitiva: "); randomize(); for(;;) { repe=1; if(num==6) break; temp=random(49)+1; for(num1=0;num1<=num;num1++) { if(valores[num1]==temp) { valores[num1]=temp; num--; repe=0; break;
67
Programacin II
} } if (repe==1) valores[num]=temp; num++; } for(num=0;num<6;num++) printf("%d ",valores[num]); getch(); }
13.FUNCIONES DE CONVERSIN
En el estndar de C se definen funciones para realizar conversiones entre valores numricos y cadenas de caracteres. La cabecera de todas estas funciones es STDLIB.H. Se pueden dividir en dos grupos, conversin de valores numricos a cadena y conversin de cadena a valores numricos.
ATOI:
Devuelve un entero. Esta funcin convierte la cadena en un valor entero. La cadena debe contener un nmero entero vlido, si no es as el valor devuelto queda indefinido. La cadena puede terminar con espacios en blanco, signos de puntuacin y otros que no sean dgitos, la funcin los ignora. La cabecera es <stdlib.h>.
int atoi(variable_char);
ATOL: Devuelve un long. Esta funcin convierte la cadena en un valor long. La cadena debe contener un nmero long vlido, si no es as el valor devuelto queda indefinido. La cadena puede terminar con espacios en blanco, signos de puntuacin y otros que no sean dgitos, la funcin los ignora. La cabecera es <stdlib.h>.
long atol(variable_char);
ATOF: Devuelve un double. Esta funcin convierte la cadena en un valor double. La cadena debe contener un nmero double vlido, si no es as el valor devuelto queda indefinido. La cadena puede terminar con espacios en blanco, signos de puntuacin y otros que no sean dgitos, la funcin los ignora. La cabecera es <stdlib.h>.
double atof(variable_char);
SPRINTF:
Devuelve una cadena. Esta funcin convierte cualquier tipo numrico a cadena. Para convertir de nmero a cadena hay que indicar el tipo de variable numrica y tener presente que la longitud de la cadena debe poder guardar la totalidad del nmero. Admite tambin los formatos de salida, es decir, que se puede coger distintas partes del nmero. La cabecera es <stdlib.h>.
sprintf(var_cadena,identificador,var_numerica);
ITOA:
Devuelve una cadena. La funcin convierte un entero en su cadena equivalente y sita el resultado en la cadena definida en segundo termino de la funcin. Hay que asegurarse que la cadena se lo suficientemente grande para guardar el nmero. Cabecera <stdlib.h>.
itoa(var_entero,var_cadena,base);
68
Programacin II
BASE 2 8 10 16
DESCRIPCIN
Convierte el valor en binario. Convierte el valor a Octal. Convierte el valor a decimal. Convierte el valor a hexadecimal.
LTOA: Devuelve una cadena. La funcin convierte un long en su cadena equivalente y sita el resultado en la cadena definida en segundo termino de la funcin. Hay que asegurarse que la cadena se lo suficientemente grande para guardar el nmero. Cabecera <stdlib.h>.
ltoa(var_long,var_cadena,base);
PROGRAMA #6D
#include<stdio.h> #include<conio.h> #include<stdlib.h> void main(void) { char texto[4]; char ntext[10],ntext1[10]; int num; float total; clrscr(); printf("Numero de 3 digitos: "); scanf("%d",&num); fflush(stdin); printf("Cadena numerica: "); gets(ntext); fflush(stdin); printf("Cadena numerica: "); gets(ntext1); fflush(stdin); sprintf(texto,"%d",num); printf("%c %c %c\n",texto[0],texto[1],texto[2]); total=atof(ntext)+atof(ntext1); printf("%.3f",total); getch(); }
69
Programacin II
1. FUNCIONES DE FECHA Y HORA

Estas funciones utilizan la informacin de hora y fecha del sistema operativo. Se definen varias funciones para manejar la fecha y la hora del sistema, as como los tiempos transcurridos. Estas funciones requieren el archivo de cabecera TIME.H. En este archivo de cabecera se definen cuatro tipos de estructuras para manejar las funciones de fecha y hora (size_t , clock_t , time_t , time).
TIME:
Devuelve la hora actual del calendario del sistema. Si se produce un error devuelve 1. Utiliza la estructura time_t a la cual debemos asignar una etiqueta que nos servir para trabajar con la fecha y hora. Por si sola no hace nada, necesita otras funciones para mostrar los datos. Cabecera <time.h>.
time_t nombre_etiqueta; . . nombre_etiqueta=time(NULL);
CTIME: Devuelve un puntero a una cadena con un formato da semana mes hora:minutos:segundo ao \n\0. La hora del sistema se obtiene mediante la funcin time. Cabecera <time.h>.
puntero=ctime(&etiqueta_estructura_time_t);
PROGRAMA #6E
#include<stdio.h> #include<conio.h> #include<time.h> void main(void) { time_t fecha_hora; clrscr(); fecha_hora=time(NULL); printf(ctime(&fecha_hora)); getch(); }
GETTIME: Devuelve la hora del sistema. Utiliza la estructura dostime_t para guardar la informacin referente a la hora. Antes de hacer referencia a la funcin hay que crear una etiqueta de la estructura. Cabecera <dos.h>.
_dos_gettime(&etiqueta_estructura_dostime_t); struct dostime_t{ unsigned hour; unsigned minute; unsigned second; unsigned hsecond; }
70
Programacin II
PROGRAMA #6F
#include<stdio.h> #include<conio.h> #include<dos.h> void main(void) { struct dostime_t ho; clrscr(); _dos_gettime(&ho); printf(" %d:%d:%d",ho.hour,ho.minute,ho.second); getch(); }
GETDATE: Devuelve la fecha del sistema. Utiliza la estructura dosdate_t para guardar la informacin referente a la fecha. Antes de hacer referencia a la funcin hay que crear una etiqueta de la estructura. Cabecera <dos.h>.
_dos_getdate(&etiqueta_estructura_dosdate_t);
struct dosdate_t{ unsigned day; unsigned month; unsigned year; unsigned dayofweek; }
PROGRAMA #6G
#include<stdio.h> #include<conio.h> #include<dos.h> void main(void) { struct dosdate_t fec; clrscr(); _dos_getdate(&fec); printf("%d/%d/%d\n",fec.day,fec.month,fec.year); getch(); }
SETTIME: Permite cambiar la hora del sistema. Utiliza la estructura dostime_t para guardar la informacin referente a la hora. Antes de hacer referencia a la funcin hay que crear una etiqueta de la estructura. Cabecera <dos.h>.
_dos_settime(&etiqueta_estructura_dostime_t);
SETDATE: Permite cambiar la fecha del sistema. Utiliza la estructura dosdate_t para guardar la informacin referente a la fecha. Antes de hacer referencia a la funcin hay que crear una etiqueta de la estructura. Cabecera <dos.h>.
_dos_setdate(&etiqueta_estructura_dosdate_t);
71
Programacin II
PROGRAMA #6H
#include<stdio.h> #include<conio.h> #include<dos.h> void main(void) { struct dosdate_t fec; struct dostime_t ho; clrscr(); printf("Introducir fecha: "); gotoxy(19,1); scanf("%u%*c%u%*c%u",&fec.day,&fec.month,&fec.year); printf("Introducir hora: "); gotoxy(18,2); scanf("%u%*c%u%*c%u",&ho.hour,&ho.minute,&ho.second); _dos_settime(&ho); _dos_setdate(&fec); }
DIFFTIME: Devuelve un double. La funcin devuelve la diferencia, en segundos, entre una hora inicial y hora final. Se restara la hora final menos la hora inicial. Tenemos que obtener la hora al iniciar un proceso y al terminar el proceso volveremos a tomar la hora. Cabecera <time.h>.
double difftime(hora_final,hora_inicial);
PROGRAMA #6I
#include<stdio.h> #include<conio.h> #include<time.h> void main(void) { time_t inicio, final; double tiempo,cont; clrscr(); inicio=time(NULL); for(cont=0;cont<50000;cont++) clrscr(); final=time(NULL); tiempo=difftime(final,inicio); printf("Tiempo: %.1f",tiempo); getch(); }
72
Programacin II
2. FUNCIONES DE SISTEMA
Este tema trata sobre funciones que, de una u otra forma, estn ms prximas al sistema operativo que las dems funciones de la biblioteca estndar de C. Estas funciones permiten interactuar directamente con el sistema operativo. Las funciones de este tema interactan con el sistema operativo DOS. Este tipo de funciones atizan en unos casos el archivo de cabecera DOS.H y en otros DIR.H.
BIOS_EQUIPLIST: Esta funcin devuelve un valor que especifica el equipo existente en la computadora. Ese valor est codificado tal como se muestra a continuacin.
BIT 0 1
DESCRIPCIN
Tiene unidades de disco. Con microprocesador matemtico.
EQUIPO
--0 0: 16K
2,3
Tamao RAM en la placa base.
0 1: 32K 1 0: 48K 1 1: 64K 0 0: no utilizado
4,5
Modo inicial de vdeo.
0 1: 40x25BN adap.color 1 0: 80x25BN adap.color 1 1: 80x25adap.monocromo 0 0: una
6,7
Nmero de unidades de disquete.
0 1: dos 1 0: tres 1 1: cuatro
Chip DMA.
0 0 0 0: cero 0 0 1: uno 0 1 0: dos 0 1 1: tres 1 0 0: cuatro 1 0 1: cinco
9,10,11 Nmero de puertos serie.
73
Programacin II
1 1 0: seis 1 1 1: siete
12 13
Con adaptador de juegos. Con mdem
1 1 0 0: cero
14,15
Nmero de impresoras
0 1: uno 1 0: dos 1 1: tres
La cabecera que utiliza esta funcin es <bios.h>. El modo de trabajar es igualar la funcin a una variable sin signo, despus el resultado se le desplaza a los bits que nos interesan para mostrar la informacin.
var_sinsigno=_bios_equiplist(); var_sinsigno >> n_bit;
PROGRAMA #6J
#include<stdio.h> #include<conio.h> #include<bios.h> void main(void) { unsigned num_bit; clrscr(); num_bit=_bios_equiplist(); num_bit>>=6; printf("N de disqueteras: %d",(num_bit & 3)+1); getch(); }
GETDISKFREE:
Devuelve la cantidad de espacio libre del disco especificado por la unidad (numeradas a partir de 1 que corresponde a la unidad A). Esta funcin utiliza la estructura diskfree_t. El espacio lo devuelve indicando el nmero de cilindros libres, para pasarlo a bytes hay que multiplicarlo por 512 y por 64. Cabecera <dos.h>.
_dos_getdiskfree(unidad,&etiq_struct_diskfree_t);
74
Programacin II
struct diskfree_t{ unsigned unsigned unsigned unsigned }
total_clusters; avail_clusters; sectors_per_cluster; bytes_per_sector;
VALOR 1 2 3
UNIDAD A: B: C:
PROGRAMA #6K
#include <stdio.h> #include <conio.h> #include <dos.h> void main(void) { struct diskfree_t disco; float tam; clrscr(); _dos_getdiskfree(3,&disco); tam= (float)(disco.avail_clusters)* (float)(disco.sectors_per_cluster)* (float)(disco.bytes_per_sector); printf("Tamao Bytes: %.0f\n",tam); printf("Tamao Sectores: %d",disco.avail_clusters); getch(); }
GETDRIVE:
Devuelve el nmero de la unidad de disco actual del sistema y deja el valor en la variable int. Ese valor se puede discriminar por medio de un switch o como en el ejemplo utilizar directamente un printf. La cabecera <dos.h>.
_dos_getdrive(&var_intera);
VALOR 1 2 3
UNIDAD A: B: C:
75
Programacin II
PROGRAMA #6L
#include<stdio.h> #include<conio.h> #include<dos.h> void main(void) { int unidad; clrscr(); _dos_getdrive(&unidad); printf("La unidad actual es: %c",unidad+'A'-1); getch(); }
SETDRIVE:
La funcin cambia la unidad de disco actual a la especificada por la variable de tipo entero. La funcin devuelve el nmero de unidades del sistema en el entero apuntado por la segunda variable de la funcin. La cabecera <dos.h>.
_dos_setdrive(var_int_unidad,&var_int_unidades);
PROGRAMA #6M
#include<stdio.h> #include<conio.h> #include<dos.h> void main(void) { unsigned unit; clrscr(); _dos_setdrive(3,&unit); printf("N unidades: %u",unit); getch(); }
GETCUDIR:
Devuelve un entero. La funcin obtiene el directorio actual de la unidad que se le especifica mediante un entero. Esta funcin devuelve CERO si todo se produce correctamente, en caso contrario devuelve uno. La cabecera es <dir.h>.
int getcurdir(int_unidad,cadena);
PROGRAMA #6N
#include<stdio.h> #include<conio.h> #include<dos.h> void main(void) { char *director; clrscr(); getcurdir(3,director); printf("Directorio: %s",director); getch();
76
Programacin II
FINDFIRST/FINDNEXT:
La funcin findfirst busca el primer nombre de archivo que coincida con el patrn de bsqueda. El patrn puede contener la unidad como el camino donde buscar. Adems el patrn puede incluir los caracteres comodines * y ?. Si se encuentra alguno, rellena con informacin la estructura find_t.
int _dos_findfirst(patron,atrib,&etique_find_t);
La funcin findnext continua la bsqueda que haya comenzado con findfirst. Devuelve CERO en caso de xito y un valor DISTINTO DE CERO si no tiene xito la bsqueda. Cabecera <dos.h>.
int struct find_t { char reserved[21]; char attrib; unsigned wr_time; unsigned wr_date; long size; char name[13]; } _dos_findnext(&etiqueta_find_t);
ATRIBUTO
_A_NORMAL _A_RDONLY _A_HIDDEN _A_SYSTEM _A_VOLID _A_SUBDIR _A_ARCH
DESCRIPCIN
Archivo normal. Archivo slo lectura Archivo oculto. Archivo del sistema. Etiqueta de volumen. Subdirectorio. Bit de archivado activado.
PROGRAMA #6O
#include<stdio.h> #include<conio.h> #include<dos.h> void main(void) { struct find_t fiche; int fin; fin=_dos_findfirst("*.c",_A_NORMAL,&fiche); while(!fin) { printf("%s %ld\n",fiche.name,fiche.size); fin=_dos_findnext(&fiche); } getch(); }
77
Programacin II
REMOVE:
La funcin elimina el archivo especificado en la variable. Devuelve CERO si consigue eliminar el fichero, y MENOS UNO si se produce algn error. La cabecera <stdio.h>.
int remove(variable_cadena);
RENAME:
La funcin cambia el nombre del archivo especificado en primer termino por el nombre de la segunda variable cadena. El nuevo nombre no debe coincidir con ninguno que exista en el directorio. Devuelve CERO si tiene xito y DISTINTO DE CERO si se produce algn error. Cabecera <stdio.h>.
int rename(var_nombre_antiguo,var_nombre_nuevo);
PROGRAMA #6P
#include<stdio.h> #include<conio.h> #include<stdlib.h> void main(int argc, char *argv[]) { clrscr(); if (argc!=3) { printf("Error en los argumentos"); exit(0); } if(remove(argv[1])) printf("El fichero no esta\n"); if(rename(argv[2],"nuevo.txt")) printf("No puedo cambiar nombre\n"); }
MKDIR:
Esta funcin permite crear directorios. El directorio depender de aquel donde estemos situados a la hora de crearlo. Devuelve CERO si todo ha ido correctamente y DISTINTO de cero si hay algn error. Cabecera <dir.h>.
int mkdir(variable_cadena);
CHDIR:
Esta funcin permite cambiarse de directorio. Hay que indicarle la ruta completa para poder cambiarse. Devuelve CERO si todo ha ido correctamente y DISTINTO de cero si hay algn error. Cabecera <dir.h>.
int chdir(variable_cadena);
RMDIR:
Esta funcin permite borrar el directorio que le indiquemos. Las condiciones para borrar el directorio es que este vaco y estar en el directorio que le precede. Devuelve CERO si todo ha ido correctamente y DISTINTO de cero si hay algn error. Cabecera <dir.h>.
int rmdir(variable_cadena);
SYSTEM: La funcin pasa la cadena como una orden para el procesador de rdenes del sistema operativo. El valor devuelto por system normalmente es CERO si se realiza todo
78
Programacin II
correctamente y DISTINTO de cero en cualquier otro caso. No es muy utilizada, al llamarla perdemos todo el control del programa y lo coge el sistema operativo. Para probar esta orden es necesario salir a MS-DOS. La cabecera utilizada es <stdlib.h>.
int system(variable_cadena);
SOUND/NOSOUND: La funcin sound hace que el altavoz del ordenador comience a pitar con una frecuencia determinada por la variable. El altavoz seguir pitando hasta que el programa lea una lnea con la funcin nosound(). Cabecera <dos.h>.
sound(int_frecuencia); nosound();
PROGRAMA #6Q
#include <stdio.h> #include <conio.h> #include <dir.h> #include <stdlib.h> #include <dos.h> void main(void) { char *directorio; clrscr(); printf("Nombre del directorio: "); gets(directorio); if(!mkdir(directorio)) printf("Directorio creado\n"); else { printf("No se pudo crear directorio\n"); delay(1000); exit(0); } getch(); system(dir/p); getch(); if(!rmdir(directorio)) printf("\nDirectorio borrado\n"); else { printf("\nNo se pudo borrar\n"); delay(1000); exit(0); } getch(); }
79
Programacin II
3. FUNCIONES GRFICAS
Los prototipos de las funciones grficas y de pantalla se encuentran en GRAPHICS.H. Lo primero que hay que tener en cuenta son los distintos modos de vdeo para el PC. Cuando utilizamos funciones grficas hay que iniciar el modo grfico y esto supone un cambio en las coordenadas en pantalla y el tamao. La parte ms pequea de la pantalla direccionable por el usuario en modo texto es un carcter . En modo grfico es el pixel. Otro aspecto es que en modo grfico la esquina superior izquierda en la coordenada 1,1 y como esquina inferior derecha 24,80. En el modo grfico la esquina superior izquierda es 0,0 y la esquina inferior derecha depende del modo de vdeo. Se pude obtener mediante las funciones getmaxx() y getmaxy(). Para compilar un fichero fuente con funciones grficas tenemos primero que indicar al compilador que se va a trabajar con ese tipo de funciones. OPTIONS LISTA DE COLORES: LINKER LIBRARIES Activar la opcin Graphics Library
TEXTO VALOR 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 n+128
COLOR
Negro. Azul. Verde. Can. Rojo. Magenta. Marrn. Gris claro. Gris oscuro. Azul Claro. Verde claro. Can claro Rojo claro. Magenta claro Amarillo. Blanco. Parpadean.
FONDO DEL TEXTO VALOR COLOR Negro. 0 Azul. 1 Verde. 2 Can. 3 Rojo. 4 Magenta. 5 Marrn. 6
FONDO GRFICO VALOR COLOR Negro. 0 Azul. 1 Verde. 2 Can. 3 Rojo. 4 Magenta. 5 Marrn. 6 Gris claro. 7 Gris oscuro. 8 Azul Claro. 9 Verde claro. 10 Can claro 11 Rojo claro. 12 Magenta claro 13 Amarillo. 14 Blanco. 15
TEXTCOLOR:
Establece el color del texto. No es una funcin grfica. La variable que tiene como parmetro especifica el color, se puede poner una variable o directamente el n de color. Se mantiene ese color hasta el momento en que lee otro valor para textcolor. Cabecera <conio.h>.
textcolor(int color);
80
Programacin II
CPRINTF:
Tiene la misma funcin y formato que printf pero mediante esta funcin el texto se muestra con el color especificado en texcolor. Cabecera <conio.h>.
cprintf(mensaje); cprintf(identificador_formato,variable);
TEXTBACKGROUND: Establece el color de fondo donde se va mostrando el texto, solo aparece cuando hay texto escrito. Se puede utilizar una variable o el valor numrico. Se mantiene hasta que lee otro valor para textbackground. Cabecera <conio.h>.
texbackground(int color);
SETCURSORTYPE:
Esta funcin establece el tipo de cursor que se va a ver en pantalla. Se mantiene hasta el momento en que lee otro valor para en la funcin setcursortype. Admite tres constantes definidas en el compilador de C. Cabecera <conio.h>.
_setcursortype(constante_tipo_cursor);
CONSTANTES DE CURSOR CONSTANTE

_NOCURSOR _SOLIDCURSOR _NORMALCURSOR
DESCRIPCIN
No se ve el cursor. Cursor grande. Cursor normal.
PROGRAMA #6R
#include <stdio.h> #include <conio.h> #include <dir.h> #include <stdlib.h> #include <dos.h> #include <graphic.h> void main(void) { char cadena[20]="hola que tal"; clrscr(); _setcursortype(_NOCURSOR); textbackground(4);
81
Programacin II
textcolor(1); cprintf("%s",cadena); getch(); }
INICIO GRAFICO: Antes de poder utilizar cualquiera de las funciones grficas hay que iniciar el modo grfico. Al iniciar el modo grfico hay que indicarle cual es el modo de vdeo y el directorio donde estn las funciones grficas en C. Para indicar la tarjeta y el modo se utilizan variables de tipo entero asignndoles una constante llamada DETECT. La cabecera <graphics.h>.
initgraph(&var_tarjeta,&var_modo,dir_lib_graficas);
GRAPHRESULT:
Una vez iniciado el modo grfico debemos comprobar que se ha iniciado correctamente el modo grfico para poder utilizar las funciones grficas sin ningn problema. La funcin devuelve un entero que debemos comparar con la constante grOk, si son iguales el modo grfico se ha iniciado correctamente.
variable_int=graphresult();
CERRAR GRAFICO: Una vez que se ha terminado de trabajar con las funciones grficas se debe cerrar siempre el modo grfico. Si un programa termina sin cerrar el modo grfico el sistema operativo mantendr el modo grfico. Cabecera <graphics.h>.
closegraph();
Nota: Si olvidamos cerrar el modo grfico y estamos en MS-DOS podemos utilizar la orden mode co80 para restaurar el modo texto en el sistema operativo. CLEARDEVICE: Esta funcin borra la pantalla una vez que se ha inicializado el modo grfico. Si se utiliza la orden clrscr solo se limpiara una parte de la pantalla. Cabecera <graphics.h>.
cleardevice();
SETBKCOLOR:
Establece el color de fondo en la pantalla. Hay que indicarle mediante variable o valor numrico. Cuando se borra la pantalla este no desaparece. Cabecera <graphics.h>.
setbkcolor(int_color);
82
Programacin II
PROGRAMA #6S
#include <stdio.h> #include <conio.h> #include <dir.h> #include <stdlib.h> #include <dos.h> #include <graphic.h> void main(void) { int tarjeta= DETECT,modo=DETECT; int color; clrscr(); initgraph(&tarjeta, &modo, "c:\\tc\\bgi"); if(graphresult()!=grOk) { printf("Error en el modo grafico"); exit(0); } cleardevice(); for(color=0;color<=15;color++) { setbkcolor(color); delay(1000); } closegraph(); }
SETCOLOR:
Establece el color del borde con el que van a mostrarse los objetos grficos que se van pintando. Por defecto los objetos aparece con el borde de color blanco. El valor que tiene la funcin es un entero. Cabecera <graphics.h>.
setcolor(int_color);
SETFILLSTYLE:
Establece el estilo de relleno de los objetos. Hay que indicar el tipo y el color, teniendo en cuenta que el color debe ser igual al que establecemos en setcolor. Esto simplemente establece el estilo. Cabecera <graphics.h>.
setfillstyle(int_estilo,int_color);
ESTILO 1 2 3
DESCRIPCIN
Slido 100% Lneas horizontales gruesas. Lneas diagonales finas ///
83
Programacin II
4 5 6 7 8 9 10 11
Lneas diagonales gruesas /// Lneas diagonales gruesas \\\ Lneas diagonales finas \\\ Lneas horizontales y verticales cruzadas. Lneas diagonales cruzadas. Lneas diagonales cruzadas muy juntas. Puntos separados. Puntos cercanos.
FLOODFILL:
Rellena el objeto que ha sido pintado previamente. Hay que indicarle las mismas coordenas que tiene el objeto y el color debe ser igual al borde y al estilo de relleno. La cabecera <graphics.h>.
floodfill(int_x,int_y,in_color);
CIRCULO:
Dibuja un circulo en una posicin indicada mediante las coordenadas x e y, tambin hay que indicarle un color. Cabecera <graphics.h>.
circle(int_x,int_y,int_color);
RECTANGULO:
Dibuja un rectngulo o cuadrado. Se le indica la posicin de la esquina superior izquierda mediante los valores x1,y1 y la esquina inferior derecha mediante los valores de x2,y2. Cabecera <graphics.h>.
rectangle(int_x1,int_y1,int_x2,int_y2);
84
Programacin II
PROGRAMA #6T
#include <stdio.h> #include <conio.h> #include <dir.h> #include <stdlib.h> #include <dos.h> #include <graphic.h> void main(void) { int tarjeta= DETECT,modo=DETECT; int color; initgraph(&tarjeta, &modo, "c:\\tc\\bgi"); if(graphresult()!=grOk) { printf("Error en el modo gr fico"); exit(0); } cleardevice(); setcolor(3); circle(200,200,90); setcolor(14); circle(500,200,90); setfillstyle(3,14); floodfill(500,200,14); rectangle(300,100,400,300); getch(); closegraph(); }
ESTILO LINEA:
Sirve para establecer el tipo de lnea con el que se van a pintar los objetos. Los tipos de lnea establecen cinco valores definidos. Tambin hay que especificar el ancho y la separacin. Cabecera <graphics.h>.
setlinestyle(int tipo,int_separacion,int_ancho);
VALOR LINEA 0 1 2 3 4
LINEAS:
DESCRIPCIN
Continua. Guiones. Guiones largos y cortos. Guiones largos. Puntos.
Dibuja una lnea desde la posicin donde nos encontramos. Primero debemos posicionarnos en la coordenada de inicio y despus llamar a la funcin dando
85
Programacin II
la coordenada final mediante 2 enteros. En la segunda funcin directamente se le da el comienzo y el final. Cabecera <graphics.h>.
moveto(x,y); lineto(x,y); line(x1,y1,x2,y2);
PROGRAMA #6W
#include <stdio.h> #include <conio.h> #include <dir.h> #include <stdlib.h> #include <dos.h> #include <graphic.h> void main(void) { int tarjeta= DETECT,modo=DETECT; int color,coord_y,tipo_linea=0; clrscr(); initgraph(&tarjeta, &modo, "c:\\tc\\bgi"); if(graphresult()!=grOk) { printf("Error en el modo grfico"); exit(0); } cleardevice(); setcolor(14); moveto(350,150); lineto(350,250); for(coord_y=150;coord_y<=250;coord_y+=25) { setlinestyle(tipo_linea,1,1); line(300,coord_y,400,coord_y); tipo_linea++; } getch(); closegraph(); }
ELIPSES:
Dibuja una elipse o arco de elipse. Se le indica la posicin mediante los valores x, y. El ngulo inicial (que es cero si es una elipse) y el ngulo final (que es 360 si es una elipse). Hay que indicarle el radio para x y el radio para y. Cabecera <graphics.h>.
ellipse(x,y,ang_inicio,ang_fin,radio_x,radio_y);
ARCOS:
Dibuja un arco. hay que indicarle la posicin, el ngulo inicial y el final y el radio que tiene dicho arco. Todos sus valores son enteros. Cabecera <graphics.h>.
arc(x,y,ang_inicial,ang_final,radio);
86
Programacin II
PUNTOS:
Pintan un punto en una coordenada determinada con un color establecido. Hay que indicarle las coordenadas y el color mediante variables o valores enteros. Se pude pintar puntos aleatoriamente. Cabecera <graphics.h>.
putpixel(int_x,int_y,int_color);
PROGRAMA #6X
#include <stdio.h> #include <conio.h> #include <dir.h> #include <stdlib.h> #include <dos.h> #include <graphic.h> void main(void) { int tarjeta= DETECT,modo=DETECT; clrscr(); initgraph(&tarjeta, &modo, "c:\\tc\\bgi"); if(graphresult()!=grOk) { printf("Error en el modo gr fico"); exit(0); } cleardevice(); setcolor(2); ellipse(400,200,0,360,90,40); setcolor(15); arc(310,200,0,45,90); setcolor(11); line(490,200,470,350); line(310,200,330,350); setcolor(14); ellipse(400,350,180,360,70,25); getch(); closegraph(); }
SETTEXTSTYLE: Establece el estilo de letra que se va a utilizar en modo grfico. Hay que indicarle mediante valores enteros el tipo, la direccin y el tamao que tiene la letra. El color se establece con la funcin setcolor. Cabecera <graphics.h>.
settextstyle(int_tipo,const_direccion,int_tamao);
87
Programacin II
TIPO DE LETRAS VALOR 0 1 2 3 4 5 6 7 8 9 10 11 DESCRIPCIN

ABC
DIRECCIN DEL TEXTO CONST.

HORIZ_DIR VERT_DIR
DESCRIPCIN
En Horizontal. En Vertical.
A B C
ABC ABC
ABC A B C
ABC
A B C
A B C
A B C (tamao grande).
A B C (tamao grande)
ABC
ALINEAR TEXTO: La funcin settextjustify() alineara el texto con respecto a las coordenadas donde se muestra el texto. Lo hace en horizontal y en vertical. Cabecera <graphics.h>.
settextjustify(const_horizontal,const_vertical);
HORIZONTAL CONST.
LEFT_TEXT
VERTICAL DESCRIPCIN
Alineacin izquierda.
CONST.
TOP_TEXT CENTER_TEXT
DESCRIPCIN
Alineacin superior. Alineacin centrada.
CENTER_TEXT Alineacin centrada. RIGHT_TEXT VER TEXTO: Alineacin derecha.
BOTTOM_TEXT Alineacin inferior.
La funcin outtextxy(), muestra el texto de una cadena o el contenido de una variable utilizando el modo grfico. Hay que indicarle la posicin mediante dos valores enteros y a continuacin la variable o cadena entre comillas. Cabecera <graphics.h>.
outtextxy(x,y,variable_cadena); outtextxy(x,y,textto);
88
Programacin II
PROGRAMA #6Y
#include <stdio.h> #include <conio.h> #include <dir.h> #include <stdlib.h> #include <dos.h> #include <graphic.h> void main(void) { int tarjeta= DETECT,modo=DETECT; int tipo=0; clrscr(); initgraph(&tarjeta, &modo, "c:\\tc\\bgi"); if(graphresult()!=grOk) { printf("Error en el modo grfico"); exit(0); } cleardevice(); for(tipo=0;tipo<=11;tipo++) { settextstyle(tipo,HORIZ_DIR,5); outtextxy(200,200,"ABC"); delay(1000); cleardevice(); } closegraph(); }
COPIAR IMAGEN: Existen tres funciones grficas relacionadas entre si, que permiten copiar y mover objetos grficos por la pantalla. Las tres tienen la cabecera <graphics.c>. Deben estar siempre las tres para funcionar. El modo de trabajo es: copiar una zona de la pantalla a la memoria (utilizando un puntero), asignar la memoria necesaria y, mostrar la imagen. GETIMAGE: Copia el contenido del rectngulo definido por las cuatro coordenadas (tipo int) y lo guarda en memoria mediante un puntero. Cabecera <graphics.h>.
getimage(x1,y1,x2,y2,puntero);
IMAGESIZE:
Devuelve el tamao en bytes necesarios para contener la regin especificada en el rectngulo de la orden getimage(). Cabecera <graphics.h>.
variable=imagesize(x1,y1,x2,y2);
PUTIMAGE:
Muestra en pantalla una imagen obtenida por getimage(). El puntero es quien contiene la imagen y la sita en la posicin dada por x,y. El modo en que se muestra esta definido por 5 constantes. Cabecera <graphics.h>.
putimage(x,y,puntero,modo);
CONST. COPY_CUT
VALOR 0
DESCRIPCIN
Copia la imagen.
89
Programacin II
XOR_PUT OR_PUT AND_PUT NOT_PUT PROGRAMA #6Z
1 2 3 4
Borra la imagen anterior. Mezcla las imgenes. Muestra encima de la anterior. Copia en color inverso.
#include <stdio.h> #include <conio.h> #include <dir.h> #include <stdlib.h> #include <dos.h> #include <graphic.h> void main(void) { int tarjeta=DETECT,modo=DETECT,fil,col; long tam; char *imagen; initgraph(&tarjeta,&modo,"c:\\tc\\bgi"); if(graphresult()!=grOk) { printf("Error en modo grafico"); exit(0); } cleardevice(); circle(100,100,40); tam=imagesize(50,50,150,150); imagen=malloc(tam); getimage(50,50,150,150,imagen); cleardevice(); while(!kbhit()) { delay(400); putimage(col,fil,imagen,XOR_PUT); delay(400); putimage(col,fil,imagen,XOR_PUT); col=random(getmaxx()); fil=random(getmaxy()); } closegraph(); }
90
Programacin II
4. PROYECTOS
Procedimiento con el que se compilan de forma independiente distintas partes de un programa y luego se enlazan para formar el programa ejecutable final. Se utiliza con aplicaciones muy grandes. Los proyectos tienen la extensin PRJ. Solo se genera un ejecutable, los ficheros fuente generan ficheros OBJ. Lo primero es crear el proyecto (que es el que va a contener los ficheros fuente). El proyecto va a tener la extensin PRJ. El modo de crearlo es:
MENU PROJECT
OPCION OPEN PROJECT
Asignar un nombre al proyecto.
Lo siguiente es crear cada uno de los ficheros fuente que van a componer el proyecto. La creacin de los ficheros es como siempre, no hay nada de particular. Cuando tengamos los ficheros hay que aadirlos al proyecto. El modo de hacerlo.
Seleccionar la ventana del proyecto (ventana inferior de color gris). MENU PROJECT OPCION ADD ITEM Ir seleccionando cada uno de los ficheros que forman el proyecto
Cuando se tengan todos seleccionados se pulsa el botn DONE. El siguiente paso es COMPILAR CADA UNO DE LOS FICHEROS FUENTE. Para hacerlo hay que seleccionar primero el fichero y luego pulsar ALT+F9. As con todos los ficheros. Posteriormente se tiene que linkar el proyecto.
MENU COMPILE OPCION LINK. Cuando se termine con el proyecto hay que cerrarlo.
MENU PROJECT
OPCION CLOSE.
EJEMPLO: En este proyecto hay dos ficheros fuente. En el primero se muestra 2 valores y se hace la llamada a funciones del segundo programa.
91
Programacin II
Fichero: UNO.C
#include <stdio.h> #include <conio.h> void mostrar(); void sumar(); void main(void) { int x,y; clrscr(); x=10; y=20; printf("%d %d",x,y); getch(); mostrar(); sumar(); getch(); }
Fichero:DOS.C
#include<stdio.h> #include<conio.h> void sumar() { int x,y; printf("%d",x+y); getch(); } void mostrar() { int z,p; z=15; p=25; printf("%d %d",z,p); getch(); }
92
Programacin II
El puerto paralelo de la PC
PRECAUCION: Conectar dispositivos al puerto paralelo implica el riesgo de daos permanentes a la tarjeta madre de la PC, tenga siempre presente que an los profesionales cometen errores, por lo tanto no est de ms recomendarle extremo cuidado al trabajar en el puerto paralelo..
Los puertos de comunicacin de la PC son de particular inters para el estudioso de la electrnica ya que le permiten utilizar una computadora personal para controlar todo tipo circuitos electrnicos utilizados, principalmente, en actividades de automatizacin de procesos, adquicisin de datos, tareas repetitivas y otras actividades que demandan precisin. ste artculo es el primero de una serie que analizar diversos usos para el puerto paralelo de la PC.
Conceptos bsicos
Existen dos mtodos bsicos para transmisin de datos en las computadoras modernas. En un esquema de transmisin de datos en serie un dispositivo enva datos a otro a razn de un bit a la vez a travs de un cable. Por otro lado, en un esquema de transmisin de datos en paralelo un dispositivo enva datos a otro a una tasa de n nmero de bits a travs de n nmero de cables a un tiempo. Sera fcil pensar que un sistema en paralelo es n veces ms rpido que un sistema en serie, sin embargo sto no se cumple, bsicamente el impedimiento principal es el tipo de cable que se utiliza para interconectar los equipos. Si bin un sistema de comunicacin en paralelo puede utilizar cualquier nmero de cables para transmitir datos, la mayora de los sistemas paralelos utilizan ocho lneas de datos para transmitir un byte a la vez, como en todo, existen excepciones, por ejemplo el estndar SCSI permite transferencia de datos en esquemas que van desde los ocho bits y hasta los treinta y dos bits en paralelo. En ste artculo nos concentraremos en transferencias de ocho bits ya que sta es la configuracin del puerto paralelo de una PC. Un tpico sistema de comunicacin en paralelo puede ser de una direccin (unidireccional) o de dos direcciones (bidireccional). El ms simple mecanismo utilizado en un puerto paralelo de una PC es de tipo unidireccional y es el que analizaremos en primer lugar. Distinguimos dos elementos: la parte transmisora y la parte receptora. La parte transmisora coloca la informacin en las lneas de datos e informa a la parte receptora que la informacin (los datos) estn disponibles; entonces la parte receptora lee la informacin en las lneas de datos e informa a la parte transmisora que ha tomado la informacin (los datos). Observe que mbas partes sincronizan su respectivo acceso a las lneas de datos, la parte receptora no leer las lneas de datos hasta que la parte transmisora se lo indique en tanto que la parte transmisora no colocar nueva informacin en las lneas de datos hasta que la parte receptora remueva la informacin y le indique a la parte transmisora que ya ha tomado los datos, a sta coordinacin de operaciones se le llama acuerdo entendimiento. Bin, en stos mbitos tecnolgicos es recomendable utilizar ciertas palabras en ingls que nos permiten irnicamente un mejor entendimiento de los conceptos tratados. Repito: a la coordinacin de operaciones entre la parte transmisora y la parte receptora se le llama handshaking, que en espaol es el acto con el cual dos partes manifiestan estar de acuerdo, es decir, se dan un apretn de manos.
93
Programacin II
El handshaking
Para implementar el handshaking se requieren dos lneas adicionales. La lnea de estroboscopio (en ingls strobe) es la que utiliza la parte transmisora para indicarle a la parte receptora la disponibilidad de informacin. La lnea de admisin (acknowledge) es la que utiliza la parte receptora para indicarle a la parte transmisora que ha tomado la informacin (los datos) y que est lista para recibir ms datos. El puerto paralelo provee de una tercera lnea de handshaking llamada en ingls busy (ocupado), sta la puede utilizar la parte receptora para indicarle a la parte transmisora que est ocupada y por lo tanto la parte transmisora no debe intentar colocar nueva informacin en las lneas de datos. Una tpica sesin de transmisin de datos se parece a lo siguiente: Parte transmisora: La parte transmisora checa la lnea busy para ver si la parte receptora est ocupada. Si la lnea busy est activa, la parte transmisora espera en un bucle hasta que la lnea busy est inactiva. La parte transmisora coloca la informacin en las lneas de datos. La parte transmisora activa la lnea de strobe. La parte transmisora espera en un bucle hasta que la lnea acknowledge est activa. La parte transmisora inactiva la lnea de strobe. La parte transmisora espera en un bucle hasta que la lnea acknowledge est inactiva. La parte transmisora repite los pasos anteriores por cada byte a ser transmitido.
Parte receptora: La parte receptora inactiva la lnea busy (asumiendo que est lista para recibir informacin). La parte receptora espera en un bucle hasta que la lnea strobe est activa. La parte receptora lee la informacin de las lneas de datos (y si es necesario, procesa los datos). La parte receptora activa la lnea acknowledge. La parte receptora espera en un bucle hasta que est inactiva la lnea de strobe. La parte receptora inactiva la lnea acknowledge. La parte receptora repite los pasos anteriores por cada byte que debe recibir.
Se debe ser muy cuidadoso al seguir stos pasos, tanto la parte transmisora como la receptora coordinan sus acciones de tal manera que la parte transmisora no intentar colocar varios bytes en las lneas de datos, en tanto que la parte receptora no debe leer ms datos que los que le enve la parte transmisora, un byte a la vez.
El hardware del puerto paralelo

El puerto paralelo de una tpica PC utiliza un conector hembra de tipo D de 25 patitas (DB-25 S), ste es el caso ms comn, sin embargo es conveniente mencionar los tres tipos de conectores definidos por el estndar IEEE 1284, el primero, llamado 1284 tipo A es un conector hembra de 25
94
Programacin II
patitas de tipo D, es decir, el que mencionamos al principio. El orden de las patitas del conector es ste:
El segundo conector se llama 1284 tipo B que es un conector de 36 patitas de tipo centronics y lo encontramos en la mayora de las impresoras; el tercero se denomina 1284 tipo C, se trata de un conector similar al 1284 tipo B pero ms pequeo, adems se dice que tiene mejores propiedades elctricas y mecnicas, ste conector es el recomendado para nuevos diseos. La siguiente tabla describe la funcin de cada patita del conector 1284 tipo A: Patita 1 2~9 10 11 12 13 14 15 E/S Salida Salida Entrada Entrada Entrada Entrada Salida Entrada Polaridad activa 0 0 0 1 1 0 0 Descripcin Strobe Lneas de datos (bit 0/patita 2, bit 7/patita 9) Lnea acknowledge (activa cuando el sistema remoto toma datos) Lnea busy (si est activa, el sistema remoto no acepta datos) Lnea Falta de papel (si est activa, falta papel en la impresora) Lnea Select (si est activa, la impresora se ha seleccionado) Lnea Autofeed (si est activa, la impresora inserta una nueva lnea por cada retorno de carro) Lnea Error (si est activa, hay un error en la impresora) Lnea Init (Si se mantiene activa por al menos 50 micro-segundos, sta seal autoinicializa la impresora) Lnea Select input (Cuando est inactiva, obliga a la impresora a salir de lnea) Tierra elctrica
16
Salida
17 18 ~ 25
Salida -
0 -
Tabla 1: Configuracin del puerto paralelo estndar

Ingeniera Electrnica 95
Programacin II
Observe que el puerto paralelo tiene 12 lneas de salida (8 lneas de datos, strobe, autofeed, init, y select input) y 5 de entrada (acknowledge, busy, falta de papel, select y error). El estndar IEEE 1284 define cinco modos de operacin: 1. 2. 3. 4. 5. Modo compatible Modo nibble Modo byte Modo EPP, puerto paralelo ampliado Modo ECP, puerto de capacidad extendida
El objetivo del estndar es disear nuevos dispositivos que sean totalmente compatibles con el puerto paralelo estndar (SPP) definido originalmente por la IBM (en ste artculo tratar solamente el modo compatible). Hay tres direcciones de E/S asociadas con un puerto paralelo de la PC, stas direcciones pertenecen al registro de datos, el registro de estado y el registro de control. El registro de datos es un puerto de lectura-escritura de ocho bits. Leer el registro de datos (en la modalidad unidireccional) retorna el ltimo valor escrito en el registro de datos. Los registros de control y estado proveen la interface a las otras lneas de E/S. La distribucin de las diferentes seales para cada uno de los tres registros de un puerto paralelo esta dada en las siguientes tablas: Direccin Base + 0 Nombre Puerto de datos Lectura/Escritura Escritura Bit # Bit 7 Bit 6 Bit 5 Bit 4 Bit 3 Bit 2 Bit 1 Bit 0 Tabla 2: Registro de datos Direccin Base + 1 Nombre Puerto de estado Lectura/Escritura Slo Lectura Bit # Bit 7 Bit 6 Bit 5 Bit 4 Bit 3 Bit 2 Bit 1 Bit 0 Tabla 3: Registro de estado Propiedades Busy Acknowledge Falta de papel Select In Error IRQ (Not) Reservado Reservado Propiedades Dato 7 Dato 6 Dato 5 Dato 4 Dato 3 Dato 2 Dato 1 Dato 0
96
Programacin II
Direccin Base + 2
Nombre Puerto de control
Lectura/Escritura Lectura/Escritura
Bit # Bit 7 Bit 6 Bit 5
Propiedades No usado No usado Permite puerto bidireccional Permite IRQ a travs de la lnea acknowledge Selecciona impresora Inicializa impresora Nueva lnea automtica Strobe
Bit 4
Bit 3 Bit 2 Bit 1 Bit 0 Tabla 4: Registro de control
Una PC soporta hasta tres puertos paralelo separados, por tanto puede haber hasta tres juegos de registros en un sistema en un momento dado. Existen tres direcciones base para el puerto paralelo asociadas con tres posibles puertos paralelo: 0x3BCh, 0x378h y 0x278h, nos referimos a stas como las direcciones base para el puerto LPT1, LPT2 y LPT3, respectivamente. El registro de datos se localiza siempre en la direccin base de un puerto paralelo, el registro de estado aparece en la direccin base + 1, y el registro de control aparece en la direccin base + 2. Por ejemplo, para un puerto LPT2 localizado en 0x378h, sta es la direccin del registro de datos, al registro de estado le corresponde la direccin 0x379h y su respectivo registro de control est en la direccin 0x37Ah. Cuando la PC se enciende el BIOS ejecuta una rutina para determinar el nmero de puertos presentes en el sistema asignando la etiqueta LPT1 al primer puerto localizado, si existen ms puertos entonces se asignarn consecutivamente las etiquetas LPT2 y LPT3 de acuerdo a la siguiente tabla: Direccin inicial 0000:0408 0000:040A 0000:040C 0000:040E Tabla 5: Direcciones base en el BIOS Para trabajar con el puerto paralelo necesitamos en primer lugar conocer la direccin base asignada por el BIOS (estamos hablando de una PC compatible con IBM), podemos utilizar un programa llamado Debug.exe que nos indique la(s) direccin(es) asignada(s): en la plataforma Windows vamos al men inicio, seleccionamos programas y luego MS-DOS para abrir una ventana de Smbolo de MS-DOS y aqu podemos introducir los comandos indicados ms abajo. Si se trabaja Funcin Direccin base para LPT1 Direccin base para LPT2 Direccin base para LPT3 Direccin base para LPT4
97
Programacin II
en ambiente DOS basta con teclear en la lnea de comandos la palabra debug, el programa responde colocando un signo de menos - en donde tecleamos sin dejar espacios en blanco d040:08L8 y presionamos la tecla entrar, entonces el programa debug.exe nos indica en una serie de nmeros la(s) direccin(es) para el (los) puerto(s) paralelo(s) disponibles en nuestro sistema, la siguiente imagen muestra el resultado obtenido como ejemplo:
Se puede observar una serie de nmeros de dos dgitos (ocho en total), se trata del volcado de memoria que empieza en la direccin 40:0008h. Los primeros seis pares de nmeros representn las direcciones base para los puertos paralelo instalados, en la imagen de arriba se aprecia que el nico puerto paralelo de mi mquina est en la direccin 0x378h (78 03). Los nmeros estn invertidos porque Intel almacena tal informacin en un formato de "byte de bajo orden - byte de alto orden". Una vez que obtenemos la informacin deseada cerramos el programa Debug.exe simplemente tecleando la letra q y presionando la tecla entrar. Para cerrar la ventana de Smbolo de MS-DOS tecleamos la palabra exit y presionamos la tecla entrar. Por supuesto, tambin podemos conocer la direccin asignada al puerto paralelo utilizando un programa, faltaba ms, el cdigo es el siguiente:
98
Programacin II
PROGRAMA #7A Descripcin: Determina la direccion del puerto paralelo

#include <stdio.h> #include <dos.h> int main() { unsigned int __far *puntero_a_direccion; int i; puntero_a_direccion=(unsigned int __far *)0x00000408; for (i=0; i<3; i++) { if (*puntero_a_direccion == 0) printf("No se encontro puerto asignado a LPT%d \n", i+1); else printf("La direccion asignada a LPT%d es 0x%Xh\n", i+1, *puntero_a_direccion); puntero_a_direccion++; } return 0; }
El programa es muy sencillo, necesitamos un puntero que seale a la ubicacin de memoria que almacena la informacin para las diferentes direcciones asignadas al puerto paralelo, lo llamamos puntero_a_direccion, ste puntero debe ser de al menos dos bytes, por sta razn se declara como de tipo unsigned int __far. Es importante que Usted verifique en la documentacin de su compilador la manera precisa para utilizar la palabra clave far, sta puede ser simplemente la palabra como tal bin puede llevar uno (_far) o dos guiones bajos (__far), asegrese de utilizar la forma correcta el programa no funcionar. Creo que con lo explicado arriba el funcionamiento del programa puerto1.c no presenta problema alguno.
Interfaz para el puerto paralelo

Actualmente, la mayora de los puertos instalados en las computadoras son de tipo multimodal configurables a travs del BIOS de la mquina, en ste artculo me refiero expresamente al modo Normal (SPP), adems de ste estn las opciones Bidireccional, EPP versin 1.7, EPP versin 1.9 y ECP principalmente. El modo de operacin Normal es el ms elemental y solamente permite la escritura en las lneas de datos, patitas 2 a la 9 del conector DB-25 del puerto paralelo de la PC. Elctricamente, el puerto paralelo entrega seales TTL y como tal, teoricamente, se le puede conectar cualquier dispositivo que cumpla con los niveles de voltaje especficos de la lgica TTL, sin embargo el hardware del puerto paralelo est muy limitado en cuanto a su capacidad de manejo de corriente, por sta razn se debe ser muy cuidadoso con el manejo de las seales del puerto, un corto circuito puede daar permanentemente la tarjeta madre de la PC. Para disminuir lo ms posible el riesgo de daos al puerto utilizamos un circuito integrado 74LS244 como etapa separadora y al mismo tiempo mejoramos la capacidad de manejo de corriente, de esta forma
99
Programacin II
podemos conectar una serie de diodos emisores de luz (LED) que nos indiquen la actividad en las lneas de datos del puerto paralelo. El circuito se detalla en el siguiente diagrama:
Por cada lnea de entrada que tomamos directamente del puerto paralelo existe una etapa amplificadora-separadora dentro del circuito integrado 74LS244 que nos permite trabajar con una tasa de entrega de corriente suficiente para desplegar en los diodos emisores de luz la informacin escrita en las lneas de datos del puerto. Adems es posible habilitar deshabilitar el despliegue del nibble de orden inferior superior del byte escrito en el puerto. Colocando en un nivel lgico alto la patita 1 del CI 74LS244 inhabilitamos el despliegue del nibble de orden bajo, un nivel lgico alto en la patita 19 evita el despliegue del nibble de orden alto. Para comodidad, conecto las patitas 1 y 19 permanentemente a tierra de tal manera que sea posible visualizar la actividad en los diodos emisores de luz (LED). En el diagrama se especifican con nmeros las correspondientes patitas del conector DB-25. Obviamente se requiere de una fuente regulada de 5 Voltios para operar ste circuito, adems los siguientes materiales:

1. Circuito Integrado TTL 74LS244. 8. Diodos Emisores de Luz. 8. Resistencias de 220 Ohms, 1/2 Watt. 1. Cable y conector para el puerto paralelo.
Naturalmente lo ms recomendable es probar el correcto funcionamiento del circuito antes de conectarlo al puerto paralelo de la PC. Ensamble el circuito, preferentemente en un circuito impreso, y conctelo a una fuente regulada de 5 Voltios, conecte temporalmente un extremo de una
100
Programacin II
resistencia de 10,000 Ohms a una lnea de entrada, el resto de las lneas de entrada conctelas a tierra. El otro extremo de la resistencia conctelo directamente al borne positivo de la fuente de alimentacin para inducir una seal TTL alta, el respectivo LED debe encender. Con un trozo de alambre conectado a Tierra, toque temporalemente el extremo de la resistencia que est conectado a la lnea de entrada para inducir una seal TTL de lgica baja, el LED se debe apagar. Repita sta operacin para cada una de las ocho lneas de entrada. Una vez que ha verificado el correcto funcionamiento del circuito est listo para conectarlo al puerto paralelo de la PC. En primer lugar apague la computadora y el circuito. Conecte el cable al puerto paralelo asegurndose que el conector est firme en su sitio. Encienda el circuito y por ltimo encienda la computadora, por regla general, el circuito de restablecimiento de la computadora coloca inicialmente en las lneas de datos del puerto paralelo un valor igual a 0x0h, por lo tanto todos los diodos deben estar apagados una vez que la computadora ha terminado su proceso de arranque, sin embargo, si algn diodo permanece encendido sto no indica una condicin de falla, es responsabilidad del software que Usted escriba para controlar el puerto inicializarlo con un valor adecuado antes de realizar cualquier otra operacin.
Escribiendo datos al puerto paralelo

Con ocho bits podemos escribir en el puerto un total de 256 valores diferentes, cada uno de stos representa un byte de informacin y cada byte puede representar una accin concreta que nosotros podemos definir de acuerdo a nuestras necesidades. En ste artculo el objetivo es entender cmo trabajar con el puerto paralelo, por lo tanto hagamos un programa que nos permita escribir un nmero cualquiera entre 0 y 255 de tal manera que sea posible visualizar el valor en formato binario. En primer lugar consulte la documentacin de su compilador para verificar la correcta sintxis de la funcin que nos sirve para escribir en el puerto, en el caso especfico de Symantec C++, dicha funcin es outp( ). sta funcin requiere dos parmetros, el primero de tipo unsigned int que especifica la direccin del puerto paralelo, y el segundo de tipo char que especifica el valor a escribir en las lneas de datos de puerto. Una tpica llamada a la funcin outp( ) se parece a sto:
outp(0x378, 65);
Se aprecia la facilidad de manejo de la funcin, aunque diferentes compiladores dan a sus respectivas funciones nombres diferentes, la mecnica es la misma, se requieren dos parmetros, la direccin del puerto y el valor a escribir en el puerto. Estudie el siguiente cdigo:
PROGRAMA #7B Descripcin: Escribe datos al puerto paralelo de la PC

#include <stdio.h> #include <dos.h> int puerto(int direcc); int seleccion; int main() {
101
Programacin II
unsigned int __far *puntero_a_direccion; int i, direccion[3]={0,0,0}, disponible[3]={0,0,0}; puntero_a_direccion = (unsigned int __far *)0x00000408; printf("Seleccione el puerto:\n"); /* Cuantos puertos existen? */ for (i=0; i<3; i++) { if (*puntero_a_direccion == 0) printf("Puerto LPT%d...............no disponible\n", i+1); else { disponible[i] = 1; direccion[i] = *puntero_a_direccion; printf("Puerto LPT%d...............%d\n", i+1, i+1); } puntero_a_direccion++; } printf("Salir del programa........0\n"); scanf("%d", &seleccion); do { switch(seleccion) { case 0:/* Salir del programa */ printf("Adios!!!\n"); return 0; break; case 1:/* Puerto LPT1 */ if(disponible[0]==1) puerto(direccion[0]); else { printf("ERROR: PUERTO NO DISPONIBLE\n"); return 0; } break; case 2:/* Puerto LPT2 */ if(disponible[1]==1) puerto(direccion[1]); else { printf("ERROR: PUERTO NO DISPONIBLE\n"); return 0; } break; case 3:/* Puerto LPT3 */ if(disponible[2]==1) puerto(direccion[2]); else {
102
Programacin II
printf("ERROR: PUERTO NO DISPONIBLE\n"); return 0; } break; default: printf("ERROR: OPCION INCORRECTA!\n"); break; } if(seleccion!=0) { printf("Seleccione otra opcion\n"); scanf("%d", &seleccion); } } while(seleccion!=0); return 0; } int puerto(int direcc) { unsigned char valor; /* Solo valores entre 0 y 255 */ printf("Ahora puede escribir cualquier valor\n"); printf("entre 1 y 255, 0 para terminar el programa\n"); do { printf("Valor al puerto?\n"); scanf("%d", &valor); outp(direcc, valor); printf("Se ha escrito %d al puerto\n", valor); } while(valor!=0); return seleccion=0; }
El programa determina el nmero de puertos paralelo, instalados en la computadora y almacena sus respectivas direcciones en el arreglo llamado direccion[i], en caso de encontrarse una direccin vlida adems se establece en 1 el valor del arreglo llamado disponible[i] simplemente como una medida de seguridad adicional. Como resultado de stas acciones el programa despliega un men basado en los puertos encontrados, en este punto Usted puede seleccionar, en caso de que disponga de ms de un puerto, el puerto en donde est conectado el circuito mostrado en el diagrama de arriba. Una vez seleccionado el puerto Usted puede escribir un valor cualquiera comprendido entre 0 y 255. Independientemente del puerto seleccionado toda la funcionalidad del programa est encapsulada en la funcin de tipo int llamada puerto( ) a la cual se le pasa un nico parmetro que es la direccin del puerto seleccionado. La funcin est codificada de tal forma que al escribir un 0 el programa termina, de sta manera al cerrar el programa las lneas de datos del puerto paralelo estn todas en un nivel lgico bajo. ste programa y el circuito asociado son tiles para entender de forma visual la forma de representar valores en formato binario, adems establece las bases de trabajo para otros proyectos de control basados en computadora.
103
Programacin II
PROGRAMA #7C Descripcin: Mediante las flechas se puede hacer una cuenta desde 0 hasta 255
#include <dos.h> #include <stdio.h> #include <conio.h> int b,lum; int c; int a; main() { clrscr(); outport(888,0); gotoxy(2,3), printf("PRESIONE FLECHA ARRIBA - FLECHA ABAJO PARA contar hacia Arriba o hacia Abajo"); gotoxy(30,5), printf("PRESIONE ESC PARA SALIR"); ret: b= getch (); if(b=='\x0') { b= getch (); if(b==72) { a++; } if(b==80) { a--; } if(a==-1) { a=255; } if(a==256) { a=0; } gotoxy(35,15), printf("VALOR DEL PUERTO %i ",a); outport(888,a); lum=(a*100)/255; gotoxy(30,12),printf("INTENSIDAD: %i% ", lum); goto ret; } if(b==27) { outport(888,0); return 0; } getch(); }
* Nota: El circuito se conecta desde la patita 2 hasta la patita 9 a tierra con unos leds
104
Programacin II
Uniendo - 16 Carcter x 2 Lnea LCD

Esta interfase es un ejemplo de otra forma de usar el puerto paralelo. Empezaremos con algo simple. Este ejemplo no usa el rasgo Bidireccional encontrado en los ms nuevos puertos, as debe funcionar con la mayora, si ningn Puerto todo Paralelo. No muestra el uso del Puerto de Estado sin embargo como una entrada. As que qu nosotros estamos uniendo? Un Carcter 16 x 2 Lnea el Mdulo de LCD al Puerto Paralelo. Estos Mdulos de LCD son muy comnes estos das, y es bastante simple trabajar con ellos.
Circuito
Descripcin del circuito

El tablero de LCD Habilite y Registre Seleccione se conecta al Puerto del Mando. El Puerto del Mando es un colector abierto / el rendimiento del desage abierto. Mientras la mayora de los Puertos Paralelos tienen las resistencias pull-up interiores, hay unos qu no hace. Por consiguiente incorporando dos resistencias de 10K, el circuito es ms porttil para un rango ms ancho de computadoras algunos de los cuales no pueden tener ningn problema en las resistencias. Nosotros no hacemos ningn esfuerzo para poner los Datos vaya en el bus de datos en la direccin inversa. Por consiguiente los R/W linean del tablero de LCD, en escriba el modo. Esto causar que ningn bus de datos choca en las lneas de los datos. Como resultado nosotros no podemos leer la Bandera Ocupada interior del LCD que nos dice atrs si el LCD ha aceptado y el proceso acabado la ltima instruccin. Este problema se supera insertando los retrasos conocidos en nuestro programa.
105
Programacin II
El potenciometro de 10k controla el contraste del tablero de LCD. Nada imagina aqu. Como con todos los ejemplos, yo he omitido el suministro de poder. Usted puede usar una alimentacin de 5v o puede usar un onboard +5 regulador. Recuerde unos condensadores de de-coupling, sobre todo si usted tiene el problema con el circuito que trabaja propiamente. La 2 lnea x 16 carcter los mdulos de LCD estn disponibles de una gama amplia de fabricantes y si todos deben ser compatibles con el HD44780.
Programando - el Cdigo de la Fuente

PROGRAMA #7D
#include #include #include #include <stdio.h> <conio.h> <dos.h> <string.h> /* Enter Your Port Address Here */
#define PORTADDRESS 0x378
#define DATA PORTADDRESS+0 #define STATUS PORTADDRESS+1 #define CONTROL PORTADDRESS+2 void main(void) { char string[] = {"Testing 1,2,3""It'Works!"};
char init[10]; int count; int len; init[0] = 0x0F; /* Init Display */ init[1] = 0x01; /* Clear Display */ init[2] = 0x38; /* Dual Line / 8 Bits */ outportb(CONTROL, inportb(CONTROL) & 0xDF); /* Reset Control Port - Make sure Forward Direction */ outportb(CONTROL, inportb(CONTROL) | 0x08); (Register Select) */ /* Set Select Printer
for (count = 0; count <= 2; count++) { outportb(DATA, init[count]); outportb(CONTROL,inportb(CONTROL) | 0x01); /* Set Strobe (Enable)*/ delay(20); /* Larger Delay for INIT */ outportb(CONTROL,inportb(CONTROL) & 0xFE); /* Reset Strobe (Enable)*/ delay(20); /* Larger Delay for INIT */ } outportb(CONTROL, inportb(CONTROL) & 0xF7); (Register Select) */ /* Reset Select Printer
106
Programacin II
len = strlen(string); for (count = 0; count < len; count++) { outportb(DATA, string[count]); outportb(CONTROL,inportb(CONTROL) | 0x01); /* Set Strobe */ delay(2); outportb(CONTROL,inportb(CONTROL) & 0xFE); /* Reset Strobe */ delay(2); } }
Anteriormente es el cdigo de la fuente para conseguir este funcionamiento del ejemplo. Se es escrito para el C de Borland, para que si usted est usando a un recopilador de Microsoft, entonces usted tendr que cambiar el outportb () la funcin al outp () e inportb () al inp (). El tablero de LCD exige a unas instrucciones ser enviado, pedir encender el despliegue e inicializarlo. Esto es lo que la primera para la vuelta hace. Estas instrucciones deben enviarse al Registro de la Instruccin del LCD que se controla por el Registro Seleccione (Pin 4). Cuando fija 4 es bajo el registro de la instruccin se selecciona, as cuando alto el registro de los datos debe seleccionarse. Nosotros conectamos esto a la impresa Selecta del Puerto Paralelo linea qu pasa para ser hardware invertido. Por consiguiente si nosotros escribimos un 1' a pedazo 3 del Registro del Mando la lnea de la impresin Selecta va baja. Nosotros queremos enviar las instrucciones primero al mdulo de LCD. Por consiguiente el Registro la lnea Selecta debe ser baja. Como l hardware invertido es, nosotros querremos poner pedazo 3 del Registro del Mando a 1'. Sin embargo nosotros no queremos perturbar cualquier otro momento en el Puerto del Mando. Nosotros logramos esto leyendo el Puerto del Mando y 0x80 de OR'ing a l. por ejemplo el outportb(CONTROL, inportb(CONTROL) | el 0x08); Esto pondr slo pedazo 3. Despus de que nosotros ponemos un byte del datos en los datos linea, nosotros debemos sealar entonces al mdulo de LCD para leer los datos. Esto que usa se hace el Habilite la lnea. El datos se cronometra en el mdulo de LCD adelante el alto para mugir la transicin. El Estroboscopio es hardware invertido, as poniendo pedazo 0 del Registro del Mando nosotros conseguimos un alto para mugir la transicin en la lnea Estroboscpica. Nosotros esperamos entonces por un retraso, y devuelve la lnea a un estado alto listo para el prximo byte. Despus de que nosotros inicializamos el Mdulo de LCD, nosotros queremos enviar el texto a l. Se envan los carcteres al Puerto de los Datos del LCD, as nosotros queremos aclarar pedazo 3. una vez ms nosotros debemos cambiar slo el uno mordi, as nosotros usamos el outportb(CONTROL, inportb(CONTROL) & el 0xF7);. Entonces nosotros preparamos otro para la vuelta leer un byte del cordn y enviarlo al tablero de LCD. Esto se repite para la longitud del cordn. Los retrasos deben ser convenientes para la mayora de las mquinas. Si el tablero de LCD no est inicializando propiamente, usted puede probar aumentando los retrasos. Igualmente si el tablero est saltando los carcteres, por ejemplo Tst ,2. por otro lado, Si el mdulo de LCD es los carcteres repetidor por ejemplo TTTeessttiinngg entonces usted puede tener un faulting Habilitar la conexin. Verifique su Habilite a la conexin Estroboscpica.
107

Programación C introducción

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Programación C introducción

Uploaded by

Copyright:

Available Formats

Instituto Tecnolgico de Ciudad Guzmn

Ing. Ramn Chvez Bracamontes Ingeniera Electrnica

Fecha: Enero de 2006

Identificacin del programa desarrollado por unidades de aprendizaje

Objetivo general del curso

Estructuras Funciones Arreglos

Utilizacin de libreras externas

Forma general de un programa en C:

tydef tipo nuevo_nombre; nuevo_nombre nombre_variable[=valor];

OPERADORES RELACIONALES OPERADOR DESCRIPCIN

OPERADORES LGICOS ORDEN 5 5 5 5 6 6 OPERADOR DESCRIPCIN

< > <= >= == ! =

& | ^ << >> ~

4. E/S POR CONSOLA

printf(%8d,numero); // salida ajustada a la derecha. printf(%-8d,numero); //salida ajustada a la izquierda.

var_char=getchar(); var_char=getche(); var_char=getch(); gets(var_cadena); putchar(var_char); puts(variables);

Constantes enteras en tres bases diferentes

Base 16 Hexadecimal (Hex)

UNIDAD II ESTRUCTURAS DE CONTROL Y FUNCIONES

SINTAXIS DEL DESARROLLO:

valor_devuelto nombre_funcion(*param1,*param2,*paramN); nombre_funcion(var1,var2,varN);

UNIDAD III ARREGLOS

8. FUNCIONES DE CARACTERES Y CADENAS

RESULTADO VALOR Menor a Cero Cero Mayor a Cero DESCRIPCIN

UNIDAD IV APUNTADORES Y ESTRUCTURAS

9. ESTRUCTURAS, UNIONES, ENUMERACIONES

p1++; p1--; p1+12;

MODOS DE APERTURA VALOR r w a rb wb ab r+ w+ a+ r+b w+b a+b DESCRIPCIN

ESCRITURA DE CARACTERES Y CADENAS EN SECUENCIALES

LECTURA DE CARACTERES Y CADENAS EN SECUENCIALES

POSICION EN FICHEROS SECUENCIALES Y BINARIOS

ESCRITURA Y LECTURA EN BINARIOS

UNIDAD VI UTILIZACIN DE LIBRERIAS EXTERNAS

12. FUNCIONES MATEMTICAS

} } if (repe==1) valores[num]=temp; num++; } for(num=0;num<6;num++) printf("%d ",valores[num]); getch(); }

1. FUNCIONES DE FECHA Y HORA

Tamao RAM en la placa base.

0 1: 32K 1 0: 48K 1 1: 64K 0 0: no utilizado

Modo inicial de vdeo.

0 1: 40x25BN adap.color 1 0: 80x25BN adap.color 1 1: 80x25adap.monocromo 0 0: una

Nmero de unidades de disquete.

0 1: dos 1 0: tres 1 1: cuatro

0 0 0 0: cero 0 0 1: uno 0 1 0: dos 0 1 1: tres 1 0 0: cuatro 1 0 1: cinco

9,10,11 Nmero de puertos serie.

Con adaptador de juegos. Con mdem

0 1: uno 1 0: dos 1 1: tres

struct diskfree_t{ unsigned unsigned unsigned unsigned }

total_clusters; avail_clusters; sectors_per_cluster; bytes_per_sector;

TEXTO VALOR 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 n+128

CONSTANTES DE CURSOR CONSTANTE

textcolor(1); cprintf("%s",cadena); getch(); }

TIPO DE LETRAS VALOR 0 1 2 3 4 5 6 7 8 9 10 11 DESCRIPCIN

DIRECCIN DEL TEXTO CONST.

CENTER_TEXT Alineacin centrada. RIGHT_TEXT VER TEXTO: Alineacin derecha.

BOTTOM_TEXT Alineacin inferior.

XOR_PUT OR_PUT AND_PUT NOT_PUT PROGRAMA #6Z

OPCION OPEN PROJECT

Asignar un nombre al proyecto.

El hardware del puerto paralelo

Tabla 1: Configuracin del puerto paralelo estndar

Nombre Puerto de control

Bit # Bit 7 Bit 6 Bit 5

Bit 3 Bit 2 Bit 1 Bit 0 Tabla 4: Registro de control

valor_devuelto nombre_funcion(param1,param2,*paramN); nombre_funcion(var1,var2,varN);