Raptor y C

NDICE
Captulo #1
Introduccin
1.1. PRLOGO ----------------------------------------------------------------------------------------------- 1
1.2. DEFINICIN DE PROGRAMACIN -------------------------------------------------------------- 2
1.3. HISTORIA DEL LENGUAJE C ------------------------------------------------------------------- 2
1.4. MTODO A SEGUIR PARA LA SOLUCIN DE PROBLEMAS ----------------------------- 2
1.5. MTODOS PARA LA ELABORACIN DE ALGORITMOS ---------------------------------- 3
1.6. EDITOR DE TEXTOS DE TURBO C --------------------------------------------------------------- 3
Captulo #2
Variables, Constantes, Operadores y Expresiones
2.1. LAS VARIABLES -------------------------------------------------------------------------------------- 5
2.1.1. Tipos de Datos ------------------------------------------------------------------------------- 5
2.1.2. Modificadores del Tipo de Datos --------------------------------------------------------- 6
2.1.3. Turbo C es Sensible al Tamao de las Letras-------------------------------------------- 7
2.2. LAS CONSTANTES
2.2.1. Constantes Hexadecimales y Octales ---------------------------------------------------- 7
2.2.2. Constantes de Cadena ---------------------------------------------------------------------- 7
2.2.3. Constantes de Caracteres de Diagonal Invertida --------------------------------------- 7
2.3. OPERADORES
2.3.1. Operadores Aritmticos -------------------------------------------------------------------- 8
2.3.2. Operadores Relacionales y Lgicos ------------------------------------------------------ 9
2.3.3. Operador de Asignacin -------------------------------------------------------------------- 10
2.4. EXPRESIONES ----------------------------------------------------------------------------------------- 10
2.5. ESCRIBIENDO FRMULAS MATEMTICAS EN C --------------------------------------- 11
Captulo #3
Operaciones de Entrada-Salida de Datos
3.1. ESTRUCTURA GENERAL DE UN PROGRAMA EN LENGUAJE C --------------------- 12
3.2. ESPEFICADORES DE FORMATO ----------------------------------------------------------------- 13
3.3. ENTRADA Y SALIDA DE DATOS ----------------------------------------------------------------- 13
3.4. ENTRADA Y SALIDA DE CARACTERES Y CADENAS DE CARACTERES ------------ 18
Captulo #4
Estructuras Selectivas
4.1 SENTENCIA if() ---------------------------------------------------------------------------------------- 21
4.2 if()s ANIDADOS --------------------------------------------------------------------------------------- 28
4.3 SENTENCIA switch() ---------------------------------------------------------------------------------- 32
Captulo #5
Estructuras Repetitivas
5.1 SENTENCIA for() -------------------------------------------------------------------------------------- 34
5.1.1 Programas con for() y, sentencias de entrada y salida de datos: printf() y scanf()- 35
5.1.2 Programas con for() e if() ----------------------------------------------------------------- 37
5.1.3 Programas con for() e if()s anidados --------------------------------------------------- 39
5.2 CICLO do{PROCESO}while(condicin); ---------------------------------------------------- 41
5.3 CICLO while(condicin){PROCESO} -------------------------------------------------------- 43
5.4 SENTENCIA break; ------------------------------------------------------------------------------------ 43
5.5 SENTENCIA continue; -------------------------------------------------------------------------------- 43
5.6 PROBLEMAS PROPUESTOS ----------------------------------------------------------------------- 44
Captulo #6
Funciones Definidas por el Usuario sin Parmetros ----------------------------------- 46
Captulo #7
Arreglos de Memoria
7.1 ARREGLOS DE MEMORIA UNIDIMENSIONALES -------------------------------------------- 52
7.2 PROBLEMAS PROPUESTOS ------------------------------------------------------------------------ 56
7.3 ARREGLOS DE MEMORIA BIDIMENSIONALES ---------------------------------------------- 61
7.4 PROBLEMAS PROPUESTOS ------------------------------------------------------------------------ 63
Captulo #8
Funciones Definidos por el Usuario con Parmetros ----------------------------------- 64
RECURSIVIDAD -------------------------------------------------------------------------------------------- 68
Captulo #9
Apuntadores, Tipos de Datos Definidos por el Usuario y Archivos de Datos
9.1 APUNTADORES ---------------------------------------------------------------------------------------- 69
9.1 Conceptos Bsicos ---------------------------------------------------------------------------- 69
9.1.2 Declaracin de Apuntadores -------------------------------------------------------------- 70
9.2 TIPOS DE DATOS DEFINIDOS POR EL USUARIO ------------------------------------------- 71
9.3 ARCHIVOS DE DATOS ------------------------------------------------------------------------------ 74
9.3.1 Apertura y Cierre de un Archivo --------------------------------------------------------- 74
9.3.2 Creacin de un Archivo -------------------------------------------------------------------- 75
Capitulo #10
Aplicacin de los Archivos de Datos
10.1 PROGRAMAS QUE INVOLUCRAN ARCHIVOS DE DATOS ------------------------------ 78
10.2 PROGRAMAS DE CORTE DE CONTROL ------------------------------------------------------ 85
10.3 PROGRAMAS DE ALTAS, BAJAS Y CAMBIOS ---------------------------------------------- 90
10.3.1 Procesamiento de un Archivo ----------------------------------------------------------- 91
Captulo #1
Introduccin
1.1. PRESENTACIN
Saber programar es una herramienta imprescindible para cualquier profesionista, ms en el rea de la
ingeniera, pues le permite solucionar problemas complejos mediante la realizacin de clculos matemticos
que procesan grandes cantidades de datos. En los ltimos aos ha habido una mayor tendencia al uso de C entre
programadores profesionales. Entre las muchas razones de la popularidad de C estn las siguientes:
C es un lenguaje de programacin estructurado, de alto nivel, flexible y orientado a funciones.

C tiene ciertas caractersticas de bajo nivel de las que slo se dispone normalmente en ensamblador o
en lenguaje mquina.
Los programas escritos en C son transformados por los compiladores en pequeos programas objeto
que se ejecutan eficientemente.
Existen compiladores de C comerciales para la mayora de las computadoras personales,
minicomputadoras y grandes computadoras.
C no depende en gran manera de la mquina. Los programas escritos en C se pueden llevar fcilmente
de una computadora a otra.
Durante mi estancia como estudiante en la F.I.M.E.-U.A.N.L. aprend a programar en FORTRAN, BASIC

y COBOL, todos estos lenguajes eran no estructurados. Una vez que termin la carrera y comenc a impartir
ctedra, me correspondi ensear PASCAL, QUICKBASIC y COBOL.
Tanto PASCAL como QUICKBASIC ya incluan caractersticas de la programacin estructurada; la
diferencia radica en que en la programacin estructurada las instrucciones se ejecutan de manera secuencial y
esta secuencialidad no se ve interrumpida en ningn momento.
Un lenguaje estructurado tiene adems instrucciones repetitivas y selectivas; todas ellas con un principio
y un fin bien claro y definido. La principal instruccin que rompe con la secuencialidad de un programa es la
sentencia goto, por eso su uso ya ha sido descontinuado.
Ahora, en la F.I.M.E. ya impartimos Lenguaje C, Visual Fox Pro y Progress, todos ellos soportan la
programacin estructurada, aunque en el caso de Visual Fox Pro y Progress tambin soportan la Programacin
Orientada a Objetos.
La realizacin de este libro, es el resultado del esfuerzo coordinado de cada uno de los autores; esperamos
sea un apoyo que le permita, al estudiante, visualizar en forma prctica las instrucciones ms importantes y
utilizadas para comprender y aprender la filosofa de la Programacin Estructurada.
Atentamente
I.A.S. Edgar Danilo Domnguez Vera, M.C.
Maestro en Ciencias de Administracin con especialidad en Sistemas
1.2. DEFINICIN DE PROGRAMACIN DE COMPUTADORAS.

Es muy difcil dar una definicin de lo que es la programacin por lo que comenzar por decir que la
programacin no es una ciencia exacta, aqu no hay soluciones nicas, un problema puede ser resuelto por
programacin, sin embargo, puede haber programas diferentes que solucionan el mismo problema.
En la programacin no hay reglas estrictas porque no se trata de aplicar una frmula. Es intil tratar de
aprender a programar por memorizacin. En la programacin hay herramientas y el objetivo es usar esas
herramientas con un orden lgico que nos ayuden a resolver un problema.
Mucho se ha discutido acerca de que la programacin es un arte. Hay algo de verdad en lo anterior pero
tambin es ciencia porque trata de entender la realidad y procura desarrollar una solucin mediante tcnicas y
mtodos ya existentes.
Por lo tanto, podemos decir que la programacin de computadoras es la habilidad de interpretar un
problema; llevar ese problema a un nivel de abstraccin tal que permita desarrollar un algoritmo de
solucin que posteriormente pueda convertirse en un cdigo que sea interpretable por una computadora.
1.3. HISTORIA DEL LENGUAJE C

El lenguaje C es un lenguaje de alto nivel que combina el poder de un lenguaje ensamblador con la facilidad
de uso y portabilidad de un lenguaje de alto nivel. Fue desarrollado en 1972 en los laboratorios de Bell de AT
& T. Fue diseado por Dennis Ritchie como un lenguaje en el cual se escribi el sistema operativo UNIX.
Originalmente fue usado para programar sistemas operativos. Sin embargo, con el transcurso de los aos debido
a su flexibilidad y su poder, junto con la disponibilidad de compiladores C de alta calidad, para todo tipo de
computadoras de todos tamaos, se ha hecho popular en la industria, para una gran cantidad de aplicaciones.
Un lenguaje estndar es el que describe todas las construcciones y especificaciones de su sintaxis para que
puedan ser ejecutadas en cualquier computadora.
El lenguaje C estndar usualmente llamado ANSI fue adoptado por el Instituto de Estndares Nacionales
Americanos (ANSI) en 1989.
1.4. MTODO A SEGUIR PARA LA SOLUCIN DE PROBLEMAS

Ya que una computadora no piensa, para que realice un trabajo til debemos proporcionar una serie de
instrucciones, las cuales forman un programa.
Pero programar implica ms que una lista de instrucciones. La solucin de problemas es un componente
crucial de la programacin.
Antes de escribir un programa para la solucin de un problema en particular, debemos considerar
cuidadosamente todos los aspectos del problema y luego, desarrollar y organizar una solucin.
Antes de hacer tus propios problemas debes aplicar el siguiente mtodo para la solucin del problema
propuesto.
1. Especificar los requerimientos. Esto consiste en establecer el problema y entenderlo claramente, as
como determinar con precisin lo que se requiere para su solucin. Se debe descartar todo lo que no
es importante y llegar a la raz del mismo, y si despus de esto, el problema no queda totalmente
definido debemos pedir ms informacin a la persona que quiere resolverlo.
2. Anlisis. El anlisis consiste en identificar las entradas del problema (datos conocidos), las salidas
deseadas (datos que se desean conocer) y cualquier requisito o restriccin adicional para lograr la
solucin. Identificar qu informacin es proporcionada por los datos del problema y qu resultados se
deben computarizar y desplegar.
3. Diseo. Lo siguiente es desarrollar una lista de pasos a seguir para la solucin del problema llamada
ALGORITMO y verificar que el algoritmo resuelva el problema como se intenta. Escribir el algoritmo
es la parte ms difcil del proceso de solucin de problemas.
4. Una vez que se tenga el algoritmo hay que verificar que sea correcto antes de seguir adelante.
5. Implementacin. Implementar el algoritmo como programa. Se requiere conocer un lenguaje de
programacin ya que cada paso del algoritmo se convierte a una o varias lneas de cdigo en el lenguaje
seleccionado.
6. Verificacin y Prueba. Probar el trabajo completo y verificar que trabaja como se esperaba usando
diferentes conjuntos de datos.
1.5. MTODOS PARA LA ELABORACIN DE ALGORITMOS.

Hay dos mtodos para la elaboracin de algoritmos: Diagramas de flujo y pseudo cdigo.
Para la elaboracin de diagramas de flujo se utilizan una serie de smbolos que representan una accin
computacional, tales como entrada de datos, impresin de datos, operaciones matemticas, seleccin de
alternativas, repeticin de pasos, etc.
Es conveniente tomar en cuenta las siguientes reglas generales para la elaboracin de diagramas de
flujo:
1. Utilice smbolos estandarizados
2. Desarrolle el diagrama de flujo de tal forma que se lea de arriba hacia abajo y de izquierda a derecha
siempre que sea posible. No cruce lneas de flujo. Use puntas de flechas para indicar direccin.
3. Mantenga el diagrama de flujo claro, legible, simple. Deje suficiente espacio entre los distintos
smbolos. Si la solucin a un problema es larga y compleja, divdala en varios diagramas de flujo.
4. Escriba mensajes sencillos para describir los distintos pasos a lo largo del diagrama de flujo.
5. Escriba en forma clara y legible los smbolos.
El pseudo cdigo es una especie de lenguaje de programacin que permite escribir: entrada de datos,
impresin de datos, operaciones matemticas, seleccin de alternativas, repeticin de pasos etc.
Recuerde que todas las computadoras digitales, independientemente de su tamao, son bsicamente
dispositivos electrnicos que pueden transmitir, almacenar y manipular informacin (datos).
1.6. EJECUCIN DE UN PROGRAMA.

La ejecucin de un programa supone lo siguiente:
1. Un conjunto de informacin conocida, los datos de entrada, se introducen en la computadora
(desde un teclado, un disquete, un disco duro, etc.) y se almacenan en una porcin de la memoria
de sta, tradicionalmente en la memoria RAM.
Para entender lo que es la memoria RAM observe la figura donde se representa a una computadora
que est pensando, de aqu se deduce que la memoria RAM es un medio de almacenamiento de datos
voltil ya que cuando se apaga la computadora, toda informacin que haba en la memoria RAM se
pierde, a menos de que la hayamos almacenado en otro dispositivo como un disco.
2. Los datos de entrada se procesarn para producir ciertos resultados deseados que se les llama los
datos de salida.
3. Los datos de salida, y probablemente algunos de los datos de entrada, se imprimirn en papel o se
presentarn en un monitor.
RAM
Por otro lado, el procesamiento de datos mediante un programa puede representarse con la siguiente
figura.
Salida de
datos
Entrada de Datos (resultados)
Proceso de Datos
Se introducen datos a la memoria RAM (desde el teclado), ah mismo de procesan y posteriormente se

genera un resultado (se presentan en el monitor o en papel).
1.7 Instalacin del Dev-C++.

Ya hemos comentado que el propio Dev-C++ no es un compilador en s, sino un entorno de programacin
que utiliza un compilador. Podramos bajarnos el IDE por un lado, y el compilador por el otro, instalarlo y
utilizarlo. Sin embargo teniendo en cuenta que en la pgina tenemos un paquete que lo rene todo, ser
cuestin de aprovechar la circunstancia y no complicarnos la vida.
Vamos a la pgina oficial del Dev-C++: http://www.bloodshed.net/dev/devcpp.html
En la seccin Downloads tenemos la siguiente versin: Dev-C++ 5.0 beta 8 (4.9.8.0) (12 MB) with
Mingw/GCC 3.2 y varios lugares para descargarlo. Pinchamos en cualquiera de ellos y a esperar; son unos
13 megas aproximadamente. Una vez descargado tendremos un ejecutable auto-instalable. Doble clic en l
y se podr a punto. Lo nico que tenemos que seleccionar es el directorio de destino as como si queremos
iconos en el escritorio, men inicio o quick-launch. Es recomendable dejar el directorio por defecto (c:\dev-
cpp) o al menos usar una ruta de directorios que no tenga espacios en los nombres de directorios.
Conociendo el entorno.
Antes que nada me gustara comenzar con la definicin de algo con lo que vamos a tratar mucho a lo
largo del documento: el concepto de proyecto.
Un proyecto no es ms que una agrupacin de todos los ficheros que requiere una aplicacin, as como de
su configuracin especfica. Cuando en el Dev-C++ creamos un proyecto se crea un fichero .dev. Es un
fichero de texto que contiene referencias a los ficheros necesarios para compilar nuestra aplicacin
(ficheros de cdigo, ficheros de encabezado) as como las opciones necesarias especficas de esa
aplicacin (como pueden ser referencias a bibliotecas no estndar que se necesitan para compilar).
Una vez ejecutado el programa tendremos algo as:

1. Men y barras de herramientas
Aqu tenemos los mens con los tpicos comandos de Windows (abrir, guardar, copiar y pegar) Tambin
tenemos una serie de iconos en las barras de herramientas que no son ms que una parte de las opciones que
tenemos en los mens, as que por tanto, no creo que haga falta explicarlos uno por uno. Si an as no te aclaras,
puedes dejar el ratn encima de un icono durante unos segundos y aparecer una ayuda emergente. En ella se
incluye una descripcin bsica y el atajo de teclado asociado a la funcin del icono, si este existe. (Como
veremos, los atajos de teclado tambin se pueden configurar)
2. Explorador de proyectos y clases e informacin de depuracin.

Dependiendo de la pestaa que seleccionemos en esta rea tendremos acceso a:
a) Explorador de proyectos, que muestra los archivos por los que est formado nuestro proyecto -y por tanto
nuestra aplicacin- bien sean de cdigo, de encabezados, o de recursos.
b) Explorador de clases, una de las funciones ms tiles y que ya conoceris si habis visto el Visual Studio. En
este caso veremos cada una de las estructuras/clases definidas en los ficheros de nuestro proyecto, as como los
mtodos y datos que forman parte de la estructura/clase, incluyendo sus argumentos y su tipo. Tambin veremos
una lista de las funciones globales que tenemos en el proyecto, tambin con sus argumentos. Pulsando doble clic
en un mtodo, funcin o clase, iremos directamente al archivo y lnea donde se ha definido.
c) Informacin de depuracin, aqu podremos definir las variables que queramos cuando estemos depurando un
programa.
3. rea de edicin.
Aqu aparecern los ficheros de cdigo que abras. Puedes tener abierto ms de un fichero a la vez, y seleccionarlo
por medio de las pestaas que aparecern en la parte superior de este rea.
4. Resultados de la compilacin y controles de depuracin.

En sta serie de pestaas encontraremos informacin acerca del proceso de compilacin y depuracin. Cuando
seleccionemos una pestaa se expandir para mostrarnos los resultados, al tiempo que aparecer una nueva
pestaa que se sumar a las cinco anteriores: la pestaa Cerrar. Pulsndola volveremos a tener el mismo espacio
que tenamos antes.
En la pestaa compilador veremos los errores y advertencias que ha generado la compilacin de nuestro cdigo
(si los hubiera). Pulsando doble clic en uno de ellos nos remitir directamente a la lnea que provoc dicho error
o advertencia. En la pestaa resultados del compilador, tendremos toda la salida que genera el compilador gcc
(que recordemos se maneja por lnea de comandos) Esto tambin incluye errores y avisos, al igual que en la
pestaa anterior. Sin embargo no tenemos la opcin del doble clic para ir directamente a la lnea que provoc
el error.
Men archivo:
- Nuevo: Aqu podemos crear un nuevo fichero de cdigo fuente en blanco (que no es otra cosa que un fichero
de texto); un nuevo proyecto seleccionado entre varios tipos un fichero de definicin de recursos (los recursos
se utilizan en la programacin con la API win32); o crear una plantilla a partir del cdigo que tenemos que se
convertir en otro tipo de proyecto. Una plantilla en este caso, es un nuevo tipo de proyecto, que nos sirve de
base para empezar a programar. Por ejemplo puedes definir una plantilla hola mundo que ya contenga los
ficheros y el cdigo necesario para imprimir en pantalla el famoso mensaje. De la misma manera los programas
en win32 tienen unas estructuras bsicas (funcin WinMain, definicin e inclusin de encabezados) que
poseen todos los programas. Puedes generar una plantilla, y as no tienes que teclear lo bsico cada vez.
- Propiedades: Muestra las caractersticas de los ficheros del proyecto (o del fichero actual si no hay proyecto)
como lneas totales, lneas de cdigo, lneas comentadas, tamao
- Importar: Solo tenemos la opcin de importar un proyecto de Visual C++. Lo que hace esta opcin es
transformar el proyecto de visual C++ en un proyecto de Dev-C++, con sus dependencias de bibliotecas y
ficheros de cdigo, pero no trasforma el cdigo para que sea posible su compilacin directamente con Dev-
C++. Slo lo he probado con proyectos simples y funciona bastante bien. Cabe decir que es intil trasformar un
proyecto de Visual C++ que utilice MFC, ya que Dev-C++ no tiene soporte para ellas. Su mayor utilidad reside
en trasformar un proyecto que utilice las API Win32, que s soporta el compilador.
- Exportar: Podemos exportar el fichero de cdigo actual a un fichero HTML o RTF, o exportar el proyecto a
HTML. Puede ser til para la distribucin o para colgar el cdigo en una pgina web de forma ordenada.
Men Edicin:
- Insertar: Tenemos las opciones de insertar la fecha y hora actual o una plantilla de una cabecera bsica para
la descripcin del fichero fuente. Sin embargo podemos agregar nuestros propios elementos a este men. Ms
adelante veremos cmo hacerlo. El icono insertar que aparece en una de las barras de herramientas cumple la
misma funcin que ste men.
- Intercambiar header/source: Conmuta entre los archivos de cdigo fuente y su archivo de encabezado
asociado. Para que esto funcione, ambos archivos deben tener el mismo nombre, y cambiar solamente en su
extensin (Por ejemplo: main.cpp y main.h) Esta opcin tambin est disponible haciendo clic derecho en el
rea de edicin y seleccionando la misma opcin (siempre que tengamos un fichero abierto, claro)
- Aadir o quitar marcador / ir a marcador. Sirve para crear una marca en una lnea concreta de un fichero
de cdigo (no tienen porqu estar todas en el mismo fichero) para luego desplazarnos a ella de una forma ms
rpida. Tambin tenemos un icono en la barra de herramientas con esta funcin.
- Agregar comentario: Agrega un comentario de C++ ( // ) si hacemos una seleccin y elegimos esta opcin,
comentar todas las lneas de la seleccin.
- Quitar comentario: Realiza la funcin contraria a la anterior.
- Poner/quitar margen: Hace una sangra a la lnea/seleccin.
Men Bsqueda:
Tiene las opciones tpicas de bsqueda y reemplazo. Cabe destacar una funcin de bsqueda en varios ficheros,
as como los comandos Ir a lnea y el siempre til comando Ir a funcin, que busca entre las funciones del
fichero actual.
Men Ver:
Nada del otro mundo. Podemos seleccionar qu barras de herramientas queremos que muestre el Dev-C++, as
como si queremos que muestre el explorador de proyectos/clases. Tambin podemos elegir si queremos que el
explorador de proyectos y clases, as como los resultados del compilador; se muestren anclados al programa
principal (por defecto) o como una ventana aparte. Por ltimo podemos cambiar las opciones de los resultados
del compilador para que est siempre visible, o slo cuando sea necesario (es decir, cuando compilemos nuestro
programa y surjan errores o advertencias) Yo os recomiendo la segunda opcin.
Men Proyecto:
- Nuevo cdigo fuente: crea un nuevo fichero de cdigo que se aada automticamente al proyecto. Cuando lo
salves por primera vez te pedir el nombre del fichero.
- Aadir al proyecto: permite aadir ficheros al proyecto.
- Quitar del proyecto: muestra un cuadro de dilogo con los ficheros pertenecientes a nuestro proyecto para
poder eliminar los que queramos (se eliminan del proyecto, no se borran de su ubicacin)
- Propiedades del proyecto: para cada proyecto podemos definir unas opciones diferentes de las comunes a
las definidas en el compilador. Por ejemplo podemos vincular con ms bibliotecas, aadir flags de compilacin
o activar la depuracin, de forma que todas estas configuraciones slo se aplicarn a nuestro proyecto.
Men Ejecutar:
- Compilar: compila y vincula el fichero o el proyecto entero para crear el ejecutable/librera. Como ya dije los
archivos que no fueron modificados no son recompilados.
- Compilar el archivo actual: compila el fichero que ests editando actualmente. No se vincula.
- Ejecutar: Ejecuta el programa (si existe ejecutable) Ojo! Este comando no compila, por lo que si has
modificado tu programa, pero no lo recompilas, y le das a este botn (suponiendo que ya tuvieras un ejecutable
en el directorio de trabajo) ejecutar la versin anterior. Puede parecer una tontera, pero considerando que me
ha pasado unas cuantas veces (la mayora de las cuales han acabado en intentos de suicidio) creo que es mejor
recalcarlo.
- Parmetros: Si queremos que nuestro ejecutable reciba algn tipo de parmetro se pone aqu. Slo los
parmetros, no hace falta repetir de nuevo el nombre del ejecutable.
- Compilar y ejecutar: Compila, vincula y automticamente ejecuta el programa (si no hubo ningn error,
claro)
- Reconstruir todo: Borra todos los archivos de cdigo objeto, para recompilar todos los ficheros de cdigo
fuente. Tambin vincula todos. En definitiva, reconstruye el proyecto de cero. Se consigue el mismo efecto que
pulsando Limpiar resultados y luego Compilar en este mismo men.
- Revisar sintaxis: Comprueba si la sintaxis del cdigo es correcta. No genera cdigo objeto alguno. Es lo
mismo que invocar al compilador con la opcin -fsyntax-only
- Limpiar resultados: Borra todos los archivos de cdigo objeto y el ejecutable, si existen.
- Anlisis de perfil. Muestra la informacin del profiler, que consiste en datos estadsticos acerca de las
funciones del programa, como el nmero de veces que son llamadas, el tiempo que tardan en ejecutarse, el
porcentaje de tiempo total del programa que se ejecutan etc. Sirve para encontrar las funciones ms utilizadas
o ms lentas, con el fin de optimizar stas. Aunque el IDE contempla estas opciones, no funcionan
correctamente en esta versin, aunque cuando actualicemos el programa a la versin 4.9.8.5 funcionarn
correctamente.
- Reiniciar ejecucin del programa: Esta opcin slo est disponible si ests ejecutando tu programa.
Seleccinalo para reiniciar el programa.
Men depurar:
Ya que veremos este asunto ms delante de forma detallada, no me voy a extender mucho. Espero que las
explicaciones que no se entiendan ahora sean respondidas entonces.
- Depurar: Creo que est claro, no? Inicia la depuracin del proyecto.
- Parar ejecucin. Finaliza la ejecucin del programa, as como el modo depuracin.
- Parmetros. Igual que la opcin del men compilar, pero slo se aplica cuando estemos depurando el
proyecto.
- Aadir quitar punto de ruptura: Aade un breakpoint, es decir, un punto
en el cual la ejecucin del programa se detendr.
- Siguiente paso: Siguiente instruccin del programa
- Avanzar paso a paso: Igual que el anterior, pero ejecuta los pasos dentro
de un procedimiento.
- Saltar paso: Esta opcin debera ser traducida como continuar. Contina
la ejecucin del programa hasta que se encuentre otro breakpoint o
finalice.
- Ir a cursor: Se ejecuta el programa hasta que llegue al punto donde est
el cursor (si no hay un breakpoint antes)
- Aadir watch: Abre un cuadro de dilogo para introducir la variable que
queremos observar en tiempo de ejecucin. La variable y su contenido
aparecer en el rea 2 (siempre que tengamos seleccionada esa pestaa.
- Observar variables: Selecciona la pestaa Depurar del rea 2.
- Ver ventana del CPU: Debug avanzado Podemos observar los registros de la mquina en un momento de
la ejecucin.
Men Herramientas
Aqu tenemos las opciones de configuracin del IDE y del compilador.

Tambin tenemos algunas herramientas ya incluidas con el programa,
aunque tambin podemos agregar objetos a este men para definir nuestras
propias herramientas, y tenerlas a mano.
1.8. PASOS PARA EJECUTAR (CORRER) UN PROGRAMA.

1. Escribir el cdigo en la pantalla de edicin.
2. grabar el programa en un disco y asignar un nombre, el cual debe ser de mximo ocho caracteres, sin
espacios, acepta letras, nmeros y guiones medios, tal y como se muestra en la siguiente figura.
3. Compilar hasta quitar todos los errores de sintaxis, para esto tendr que corregir, grabar el programa
y volver a compilar hasta que ya no halla errores. Para compilar el programa deber activar la primera
opcin que est en el men Compile. Cuando ya no hay errores de sintaxis aparecer una caja de
dilogo como en la siguiente figura
4. Correr el programa y verificar los resultados en la pantalla de ejecucin. Para ejecutar el programa
deber activar la primera opcin que est en el men Run. Los resultados del programa aparecern en
la ventana de ejecucin como en la siguiente figura.
Captulo #2
Variables, Constantes, Operadores y Expresiones
Las variables se utilizan para expresar una solucin generalizada a un problema, por el contrario las
constantes dan una solucin particularizada. Esto es, la siguiente operacin:
507 + 8 9 = 596
est compuesta por dos constantes los nmeros 507 y 89, y que por estar en una ecuacin matemtica se les
llama operandos, mismos que al sumarse generan una tercer constante que es 596. Adems, la operacin est
compuesta por dos operadores, el signo de ms y el igual. La anterior expresin, es una solucin particular
que involucra a dos nmeros. Sin embargo, para representar una solucin generalizada tendramos que utilizar
variables, entonces tendramos lo siguiente:
C=A+B
De esta forma, la expresin anterior involucra a tres variables (operandos), estas son A, B y C, de esta
manera, se representa una solucin generalizada ya que se puede dar diversos valores para A y B, generando
un valor diferente para C.
En un programa computacional, se hace uso de variables, constantes y operadores. De esta
forma, se genera un programa que puede solucionar muchos problemas de un mismo tipo, esto se debe gracias
a las variables.
2.1. LAS VARIABLES

Ahora bien, las variables deben recibir un nombre para poder identificarlas, obviamente, a estos
nombres se les llama identificadores. En Lenguaje C un identificador puede tener de uno a varios caracteres
(letras, nmeros o subrayados). El primer caracter debe ser una letra o un subrayado. Aqu hay ejemplos
de identificadores correctos e incorrectos. No se recomienda que los nombres de identificadores tengan ms
de 32 caracteres porque lenguaje C ya no reconoce los caracteres posteriores.
Correcto Incorrecto
Contador 8contador
Prueba23 Hola!tu
Alto_balance Alto..balance
2.1.1. Tipos de Datos

Las variables se deben declarar antes de ser utilizadas en un programa, generalmente al
principio del mismo de una funcin y antes de cualquier proposicin ejecutable. Una declaracin de
variable notifica sus propiedades. Consta de un nombre de tipo y uno o varios nombres de identificadores.
Los tipos de datos en C son:
Tipo Descripcin Ancho en bits Bytes Rango

char Carcter 8 1 -128 a 127
int Entero 16 2 -32,768 a 32,767
float Real simple precisin 32 4 3.4 E-38 a 3.4E+38
double Real doble precisin 64 8 1.7E-308 a 1.7E+308
void Nulo o Vaco 0 Sin valores
a) Se usan variables tipo caracter (char) para guardar caracteres ASCII, stos pueden ser letras, nmeros o
caracteres especiales, sin embargo, una variable char que contiene nmeros no se puede utilizar en
operaciones matemticas algebraicas.
b) Las variables tipo enteras (int) se usan para cantidades numricas enteras, es decir, que no necesitan
decimales, con este tipo de variables se controlan los ciclos repetitivos como for() y do{..}while().
c) Se usan variables reales (tambin llamadas de punto flotante) de simple y de doble precisin (float y
double) para valores numricos que requieran fraccin decimal o cuando la aplicacin requiera de valores
grandes. La diferencia entre float y double es la magnitud del nmero ms grande (o ms pequea) que
pueden almacenar, esto es, una variable double puede almacenar un nmero aproximadamente diez veces
ms grande que un float.
d) Se usan variables tipo void para ayudar a mejorar la comprobacin de tipos, se discutir ms adelante.
2.1.2. Modificadores del Tipo de Datos

Excepto para void, los tipos bsicos tienen varios modificadores que los preceden. Se usa un
modificador para alterar el significado de un tipo base y que pueda encajar con las necesidades de diversas
situaciones. Los modificadores son:
signed
unsigned
long
short
Se pueden aplicar los modificadores signed, unsigned, long y short para los tipos base char (caracter) e
int (entero). Sin embargo, se puede aplicar tambin long a double.
Enseguida, se muestra una lista de ejemplo de la forma en cmo se declaran variables.
long int matricula;

char nombre[30], hora[3];
float calficacion1, calificacion2, promedio;
int grupo, salon, frecuencia_semana;
En el ejemplo anterior tenemos la variable matricula como larga entera (long int), es decir, esta
variable no acepta decimales porque su tipo base es entera (int), pero adems se le agreg el modificador del
tipo de datos de largo (long). Con esto es posible dar valores con 6 o 7 dgitos. Si la variable matricula fuera
solamente entera (int), no podramos dar valores grandes porque estaramos fuera de rango (-32,768 a
32,767).
Tenemos la variable nombre de tipo caracter (char) con una longitud de 30, esto implica que
podemos manejar nombres con mximo 30 posiciones, contando letras y espacios en blanco, aunque es
conveniente utilizar slo 29 de ellos para dejar un caracter de control propia de lenguaje C. Posteriormente se
explicar su uso.
Dado que la variable hora aceptar valores como M1, M2,M3V1,V2..N1,N6, entonces es de tipo
caracter con tres posiciones, dejando la ltima posicin para el caracter de control.
La variables calificacion1, calificacion2 y promedio pueden presentarse con decimales, por eso se
declararon como reales (float).
La variable grupo aceptar valores como 01,02,0315 o ms pero en ningn momento aceptar
valores mayores a 32,767 por lo tanto es de tipo entero (int).
La variable salon recibir valores como 1101, 1102, 2101, 2202, 3101etc. y por el mismo motivo que
la anterior variable, es de tipo entero (int).
Finalmente, la variable frecuencia_semana tambin es entera e indica cuantas horas de clase de esa
materia se imparten por semana, por ejemplo, Programacin Bsica y Programacin Avanzada I y II tienen
una frecuencia de 3 horas-clase por semana, hay otras materias que sern de 2 5 horas-clase, pero ninguna
se imparte 2.5 o 3.40 horas-clase por semana, es decir, no hay fracciones de hora.
2.1.3 Turbo C es sensible al Tamao de las Letras
Turbo C es sensible al tamao de las letras, es decir, en el ejemplo anterior tenemos a la variable
matricula, escrita con letras minsculas, sin embargo, turbo C no es capaz de reconocer a Matricula o
MATRICULA como la misma variable, de este modo, se debe tener cuidado que durante toda la codificacin
de un programa, la variable se utilice de la misma forma de cmo fue declarada.
2.2. LAS CONSTANTES

En Turbo C las constantes se refieren a los valores fijos que el programa no puede cambiar;
ejemplos de constantes en la solucin de un problema hay muchos, tal como: la gravedad (9.8 m/s2 32
ft/s2), el valor de PI (3.1416), etc. De esta forma, las constantes pueden ser de cualquier tipo bsico. Las
constantes caracter estn encerradas entre comillas simples. Por ejemplo, a, %. Las constantes enteras son
nmeros sin componente decimal y las constantes reales requieren el uso del punto y la fraccin decimal.
Tipo de dato Constante de Ejemplo

char a, \n, 9
int 1, 123, 2100,-234
long int 37950, -51452
short int 10, -12, 90
unsigned int 10000, 987, 17953
float 123.23, 4.3e-3
double 123.23, 12312333, -0.9876324, 1.0E100
Las constantes dentro de un programa en Lenguaje C se declaran con la instruccin #define seguido del
nombre de la constante en mayscula y el valor que tomar dicha constante.
Sintaxis #define nombre valor
Ejemplos: #define MILLAS 0.62137
#define PI 3.1416
#define MAX_LONGITUD 100
2.2.1. Constantes Hexadecimales y Octales

Lenguaje C permite especificar constantes enteras en hexadecimal u octal en vez de decimal. Una
constante en hexadecimal debe comenzar por 0x (un cero seguido por una equis). Una constante octal
empieza con cero. Estos son algunos ejemplos:
int hex=0xFF
int oct=011
La primer constante hexadecimal es equivalente a 255 en decimal y la segunda constante en octal

equivale a 9 decimal.
2.2.2. Constantes de Cadena

Turbo C soporta otro tipo de constante adems de las de tipos de datos predefinidos: la cadena de
caracteres. Una cadena es un conjunto de caracteres que se encierran entre comillas dobles. Por ejemplo,
esto es una prueba. No se debe confundir las cadenas con los caracter, esto es, una constante caracter se
encierra en comillas simples: a, sin embargo, a es una cadena que contiene una sola letra.
2.2.3. Constantes de Caracteres de Diagonal Invertida

El uso de comillas simples para encerrar todas las constantes de caracteres funciona para la mayora de
los caracteres imprimibles, pero algunos, como retorno de carro es imposible introducir por teclado. Por esta
razn , Lenguaje C proporciona las constantes especiales de caracter de diagonal invertida
Cdigo Significado
\b Retroceso
\f Alimentacin de hoja
\n Nueva lnea
\r Retorno de carro
\t Tabulador horizontal
\ Doble comilla
\ Simple comilla
\0 Nulo
\\ Diagonal invertida
\v Tabulador vertical
\a Alerta
\N Constante octal (N es constante octal)
\x Constante hexadecimal
Nota: La constante \n significa avance de lnea y retorno de carro, en pocas palabras, es la tecla <ENTER>.
2.3. OPERADORES
Un operador es un smbolo que le dice a la computadora que realice manipulaciones matemticas o
lgicas especficas. Lenguaje C tiene tres clases generales de operadores: aritmticos, relacionales y
lgicos, y sobre bits. Adems tiene algunos operadores especiales para tareas particulares
2.3.1. Operadores Aritmticos

Los operadores aritmticos son:
Operador Accin
- Resta
+ Suma
* Multiplicacin
/ Divisin
% Mdulo divisin (residuo)
-- Decremento. Menos unario
++ Incremento. Ms unario.
Estos operadores se pueden subdividir en unarios (++, - - ) y binarios (+,-,*,/, %)

Hay dos operadores binarios que se refieren a una divisin: / y %, sin embargo, cuando se aplica la
divisin (/) a enteros o caracter el resultado se trunca, por ejemplo, 10/3 ser igual a 3 en la divisin entera.
El operador mdulo de la divisin (%) recoge el resto (residuo) de una divisin entera y tiene como
restriccin que no se puede usar sobre tipos float o double.
El operador + + aade un uno a su operando y, - - le resta uno, por lo tanto las siguientes operaciones son
equivalentes.
X + + es equivalente a X = X + 1
X - - es equivalente a X = X 1
Ahora bien, estos operadores pueden preceder o seguir al operando, es decir
X=X+1 se puede dar como X++ o ++X
En el primer caso se denomina posincremento y en el segundo caso se denomina preincremento, de esta

manera si tenemos:
X = 10
Y = ++X
El valor de Y sera 11, porque C incrementa primero X y despus lo asigna a Y, pero si tuviramos
X = 10
Y=X++
El valor de Y sera 10 y despus se incrementara X. En ambos casos, X estara a 11, la diferencia est en
el momento en que se hace, s antes o despus de la asignacin.
2.3.1.1 Reglas para la Evaluacin de Expresiones Aritmticas

1. Todas las subexpresiones deben ser evaluadas por separado. Las subexpresiones dentro de parntesis tienen
prioridad por encima de todas las dems.
2. La regla de prioridad de los operadores dice que los operadores en la misma subexpresin son evaluados
en el siguiente orden
unario ++, - - primero
binario *, /, % enseguida
binario +, - al ltimo
3. La regla de la asociatividad dice que los operadores unarios en la misma subexpresin y en el mismo
nivel de prioridad, tales como ++ y - -, son evaluados de derecha a izquierda (asociatividad a la derecha).
Por otro lado, los mismos operadores binarios en la misma subexpresin y en el mismo nivel de prioridad,
tales como + y -, son evaluados de izquierda a derecha (asociatividad a la izquierda).
4. Para alterar los niveles de prioridad se pueden usar parntesis. De esta forma, las subexpresiones dentro
de parntesis anidados se evalan de las ms interna a la ms externa
2.3.2. Operadores Relacionales y Lgicos
Los operadores relacionales se refieren a las relaciones que los valores pueden tener unos con otros, y
los lgicos se refieren a la manera en que tienen lugar estas relaciones. La clave de los conceptos relacionales
y lgicos es la idea de falso y verdadero. En Lenguaje C, verdad es cualquier valor distinto de cero,
mientras que cero es falso. De esta forma, las expresiones que usan operadores relacionales y lgicos
devolvern 0 para falso y 1 para verdadero.
Se usan los operadores relacionales para determinar las relaciones de una cantidad con otra. Siempre
devuelven 1 0, dependiendo del resultado de la prueba.
A Continuacin tenemos los operadores a los que nos hemos referido
Operadores Relacionales
Operador Accin
> Mayor que
>= Mayor o igual que
< Menor que
<= Menor o igual que
== Igual
!= No igual
Operadores Lgicos
Operador Accin
&& AND
|| OR
! NOT
Los operadores lgicos se usan para soportar las operaciones bsicas de AND, OR, NOT de acuerdo con
la siguiente tabla de verdad que usa 1 para verdad y 0 para falso.
p Q p AND q p OR q NOT p
0 0 0 0 1
0 1 0 1 1
1 1 1 1 0
1 0 0 1 0
Los operadores relacionales y lgicos tienen menor prioridad que los aritmticos. Esto significa que
C evala una expresin como 10 > 1 + 12 como si se escribiera 10 > (1+12) , el resultado de esta expresin es
cero, es decir, falso. As, 5==1 generar un cero que es falso, y 5>1 generar un uno, que es verdadero.
Lenguaje C permite combinar varias operaciones en una expresin como se muestra aqu:
10 > 5 && ! ( 10 < 9 ) || 3<= 4, esta expresin ser verdad.
solucin: 10>5 =1; 10<9=0 pero cambia a 1 por ! y finalmente 3<=4 = 1, entonces tenemos que:
1 && 1 || 1 que equivale a verdad
La prioridad relativa de los operadores relacionales y lgicos es la siguiente:
Ms alto !
>, >=, <, <=
= =, !=
Ms bajo ||, &&
2.3.3. Operador de Asignacin

El operador de asignacin es el signo igual (=), este operador es el que se utiliza para referirse a
frmulas matemticas, no debe confundirse con el doble igual ( = = ) el cual es un operador relacional.
Es conveniente recordar la diferencia entre una frmula y una ecuacin matemtica. Una frmula es
aquella en cual una variable est completamente despejada, por el contrario, una ecuacin puede tener
operadores y operandos en ambos lados de la igualdad.
Ejemplo de frmulas matemticas
Fuerza = masa * aceleracion

Area = base * altura / 2
Volumen = alto *largo * ancho
Ejemplo de ecuaciones matemticas
3x2+3y=2 k+5
C2=A2+B2
Vf 2 = 2*gravedad*altura
En Lenguaje C cuando se trata de frmulas matemticas, antes de un operador de asignacin debe haber
una variable completamente despejada y no puede haber operadores de ningn tipo, porque entonces ya no
sera una frmula sino una ecuacin matemtica.
2.4. EXPRESIONES ARITMTICAS

Los operadores, constantes y variables constituyen las expresiones aritmticas frmulas. Una
expresin en lenguaje C es cualquier combinacin vlida de estas piezas.
Cuando se mezclan constantes y variables de diferentes tipos en una expresin, lenguaje C las convierte
al mismo tipo. El compilador convertir todos los operandos al tipo de operando ms grande segn la base de
esta operacin, tal como se describe en estas reglas de conversin de tipos.
a) Todos los char y short int se convierten a int. Todos los float a double.
b) Para todo par de operandos, lo siguiente ocurre en secuencia. Si uno de los operandos es un long
double, el otro se convierte a long double. Si uno de los operandos es double, el otro se convierte
a double. Si uno de los operandos es long, el otro se convierte a long. Si uno de los operandos es
unsigned, el otro se convierte en unsigned.
Se puede forzar a una expresin a ser de un tipo especfico usando la construccin llamada cast . El
formato general de un cast es:
(tipo de dato) expresin
donde tipo es uno de los estndar de datos de lenguaje C. Por ejemplo si X es un entero y se quiere uno
asegurar que la computadora evaluara las expresin X/2 como de tipo float para garantizar un componente
fraccional, se escribira
(float) X / 2
Aqu el cast (float) se asocia con X, que provoca que la computadora convierta al 2 a float tambin y
el resultado ser float. Sin embargo, se debe ser cuidadoso si se trata de escribir el cast de esta forma
(float) (X/2)
En este caso, la computadora trae una divisin entera y convierte el resultado de esa a float.
Los cast son tiles cuando la variable que controla un ciclo, como for() la cual debe ser
forzosamente entera, se requiere para realizar una operacin de tipo float, por ejemplo:
int I;
float K;
for(I=1; I<=100; I++)
{
K = (float) I/3;
}
2.5. ESCRIBIENDO FRMULAS MATEMTICAS EN C

Frmula En C se escribe
A=BC A=B*C
yb
m= m=(y-b)/(x-c)
x c
d = b2 4ac d =b*b-4*a*c o d=pow(b,2)-4*a*c
D=A+B+C D=A+B+C
1
K= K=1/(1+sqrt(X))
1 X
A=BC A=B*C
yb
m= m=(y-b)/(x-c)
x c
d = b2 4ac d =b*b-4*a*c o d=pow(b,2)-4*a*c
D=A+B+C D=A+B+C
1
K= K=1/(1+sqrt(X))
1 X
Captulo #3
Operaciones de Entrada-Salida de Datos
3.1. ESTRUCTURA GENERAL DE UN PROGRAMA EN LENGUAJE C
Antes de seguir adelante, daremos un panorama general de la estructura de un programa en lenguaje C. La
primera parte de un programa en C son las directivas del preprocesador que empiezan con el smbolo # y
que son utilizadas por el preprocesador para que el compilador sepa que son instrucciones que debe obtener de
las bibliotecas o archivos que tiene lenguaje C, listos para usarlos, tales como <stdio.h> que proporciona a C
las bibliotecas estndar de entrada y salida.
La directiva de preprocesador <stdio.h> va a ser una de las directivas que va a estar presente en la mayora
de nuestros programas, generalmente al principio de estos, su significado es standard input-output, y es
necesaria para poder introducir datos al programa y para que ste mande informacin al usuario, que puede ser
en el monitor de la computadora o una impresora.
La siguiente parte del programa es la declaracin de variables y constantes. En esta seccin se establecen
los nombres de los identificadores as como su tipo de datos y en algunos casos su longitud.
En la ltima seccin del programa se escriben las instrucciones, indicando paso a paso el algoritmo definido
para dar solucin a un problema. Cabe mencionar que lenguaje C es un lenguaje orientado a funciones, donde
la funcin principal es llamada main() (principal), esta funcin estar presente en todos los programas que
se realicen.
Enseguida, se dar un pequeo programa de ejemplo y se le pide al alumno que corra ejecute el
programa.
Diagrama 3-1.
/* prog3-1.c */
#include <stdio.h>
main()
{
int edad;
edad=37;
printf("Mi edad es de %d aos \n",edad);
printf("\n\n Pulse cualquier tecla para regresar a la pantalla de edicion");
getche();
} /* fin de la funcion main() */
El anterior programa se desglosa de la siguiente manera

a) la primer lnea /* prog1.c */ es un comentario. Los comentarios sirven en un programa para ayudar, a una
persona que vea el cdigo, a entenderlo. Antes del comentario se coloca /* , enseguida se escribe el
comentario, y al final del mismo se coloca */. Los comentarios pueden ir en cualquier parte de un
programa y no tienen ejecucin alguna dentro de un programa. En este caso particular, el comentario de
este programa nos ayuda a saber que el nombre del programa es prog3-1.c.
b) La segunda lnea #include <stdio.h>, es la directiva del prepocesador que ya explicamos en prrafos
anteriores.
c) La tercer y cuarta lnea, main() y { , indican el inicio del programa..
d) La quinta lnea int edad; , indica que se declara una variable que se utilizar en el programa, esta variable
se llama edad y es de tipo entero, es decir, no aceptar nmeros decimales.
e) La sexta lnea edad=37; , indica que a la variable edad se le asigna el valor de 37, es decir, se le da el valor
de 37.
f) La sptima lnea printf("Mi edad es de %d aos \n",edad);. printf() es una funcin que enva datos a la
pantalla de la computadora. El mensaje, que est encerrado entre comillas, aparecer en el monitor de la
computadora, el %d es un especificador de formato que permite imprimir valores enteros. El \n es una
constante de caracter de diagonal invertida que indica nueva lnea
g) La octava lnea getche(), es una funcin que en este caso se utiliza para detener la ejecucin del programa
hasta que reciba un valor y poder ver los resultados del programa.
h) La ltima lnea } /* fin de la funcin main() */ , la llave } indica el final de la funcin main(), en
este caso particular indica tambin, el fin de la codificacin del programa, y el comentario es para recordar
que es el fin de la funcin main().
i) Todas las lneas que terminan con punto y coma son instrucciones y/o funciones de lenguaje C, sin
embargo, se debe tener cuidado porque no todas las lneas de cdigo llevan punto y coma.
3.2. ESPECIFICADORES DE FORMATO

Para poder visualizar los valores de las variables se deben utilizar funciones de salida de datos como el
printf(), ste debe ir acompaado de especificadores de formato los cuales varan segn el tipo de datos que se
desee visualizar.
Cdigo
Tipo de dato que visualiza
%d Decimal (entero).
%i Decimal.
%f Real o punto flotante de simple precisin.
%c Un solo caracter.
%s Cadena de Caracteres.
%e Notacin cientfica.
%g Usa %e o %f, la que sea ms corta.
%ld Long o largas enteras.
%u Decimal sin signo.
%o Octal.
%p Puntero.
%% Imprime un signo %.
%n El argumento asociado ser un puntero
entero en el que pondr el nmero de
caracteres escritos.
%x Hexadecimal.
3.3. ENTRADA Y SALIDA DE DATOS.

Los datos pueden almacenarse en variables de dos formas diferentes, por operaciones de asignacin o por
el uso de alguna instruccin de entrada de datos como scanf().
El bloque o smbolo utilizado en diagramas de flujo para representar una accin de
entrada de datos, es decir, la introduccin de un valor desde el teclado a la memoria
RAM de la computadora, es el siguiente:
Cuando se usa la funcin scanf(), sta lee el valor de un dispositivo de entrada, casi siempre del teclado,
y lo almacena en la celda asignada para recibir dicho valor. La sintaxis de esta funcin es:
SINTAXIS: scanf (cadena de control, lista de argumentos);
A continuacin, tenemos el bloque o smbolo que se utiliza para representar una operacin matemtica
y es el siguiente:
La operacin matemtica se ejecuta en la memoria RAM, para que esto sea posible, las variables de
una frmula aritmtica deben tener un valor.
Por otro lado, para poder visualizar valores de variables en el monitor de la

computadora (salida de datos), se debe utilizar la funcin printf(), la cual se representa en
diagrama de flujo de la siguiente manera:
Aunque esta visualizacin se muestra, generalmente, en el monitor de la computadora tambin puede

ser en una impresora. La sintaxis de esta funcin es:
SINTAXIS: printf (cadena de control, lista de argumentos);
3.4. EJEMPLOS DE PROGRAMAS CON ENTRADA-SALIDA DE DATOS Y

EXPRESIONES ARITMETICAS.
A continuacin se presentan algunos ejemplos de programas donde se pondr en prctica toda la teora
explicada hasta estos momentos. Se recomienda al maestro hacer primeramente, en el pizarrn, el diagrama de
flujo correspondiente y simultneamente explicar el cdigo a sus alumnos. Finalmente, los alumnos deben
practicar en las computadoras con el software apropiado.
Diagrama 3-2.
/* prog3-2.c */
#include<stdio.h>
#include<windows.h>
/* convierte de pies a metros */
main()
{
int PIES;
float METROS;
system("cls");
printf("introduzca en numero de pies a convertir \n");
scanf("%d", &PIES);
METROS = PIES * 0.3084; /* formula de conversion */
printf("%d pies son %f metros \n", PIES, METROS);
getche();
El programa prog3-2.c tiene dos variables: PIES y METROS, la primera es de tipo entero (int), la segunda es
real de simple precisin (float). La funcin system(cls) se utiliza para limpiar la pantalla donde se visualizan
los resultados del programa. Como se podr observar, en el scanf() se escribe el amperson & , este carcter
es necesario para que funcione adecuadamente, por el momento comentaremos que indica la direccin de
memoria donde se almacen el valor de la variable, sin embargo, por la complejidad de su conceptaulizacin
se dejar para posteriores explicaciones.
En lenguaje C es posible tener en las expresiones a variables de diferente tipo como est en la frmula
de este programa. La limitante de prog3-2.c es que no se puede hacer conversiones de pies con nmero reales,
solamente enteros. Adems, cuando se ejecute el programa se ver un resultado con 6 o 7 decimales. Para quitar
la limitante y permitir slo 2 decimales en el resultado, se tiene el siguiente programa prog3-3.c.
/* prog3-3.c */
#include<stdio.h>
#include<windows.h>
main()
{
float PIES, METROS;
system("cls");
scanf("%f", &PIES);
printf("%8.2f pies son %8.2f metros \n", PIES, METROS);
getche();
Las diferencias entre prog3-2.c y prog3-3.c se reflejan en la declaracin de variables, ahora ambas
son de tipo real de simple precisin (float). En el segundo printf() podemos observar, en el especificador de
formato, 8.2 entre % y f, esto indica que los valores que se vern en los resultados sern de mximo 8 caracteres,
los cuales sern de mximo cinco nmeros en la parte entera y dos en la parte decimal, el punto decimal tambin
se contabiliza entre los 8 caracteres. Con esto aparecern slo dos decimales en el resultado.
A continuacin, tenemos el programa prog3-4.c que calcula el rea de un cuadrado.
Diagrama 3-4.
/* prog3-4.c */
#include<stdio.h>
#include<windows.h>
/* calcula el area de un cuadrado */
main()
{
float AREA,LADO;
system("cls");
printf("Introduzca la longitud del lado \n");
scanf("%f",&LADO);
AREA = LADO * LADO;
printf("El area de un cuadrado con lado = %8.2f es %8.2f \n",LADO,AREA);
getche();
En seguida, con el programa prog3-5.c calcularemos el rea de un tringulo. El clculo del rea est
limitada por la longitud de los lados, esto es, si LADO1=31, LADO2=45 y LADO3=22 centmetros, entonces
estos lados si pueden formar un tringulo, pero si LADO1= 98, LADO2=45 y LADO3=12 centmetros,
entonces estos lados no pueden formar un tringulo. En Conclusin, si la sumatoria de los lados ms pequeos
es mayor al lado ms grande, se puede formar un tringulo. Para el primer caso 31+22=53, dado que 53 es
mayor a 45 se forma el tringulo, pero en el segundo caso donde 45+12=57 y dado que 57 es menor que 98, no
se puede formar el tringulo.
La frmula para determinar el rea es:
rea = LADOS(LADOS LADO1)(LADOS LADO2)(LADOS LADO3)
donde, LADOS =(LADO1+LADO2+LADO3)/2
Por lo tanto al ejecutar el programa prog3-5.c, si se dan tres lados que no forman un tringulo se generar
un error. La funcin sqrt() se utiliza para calcular la raz cuadrada, misma que necesita de la directiva del
preprocesador llamada <math.h> que se escribi al principio del programa indicando el uso de una funcin
matemtica.
Diagrama 3-5.
/* prog3-5.c */
#include <stdio.h>
#include <math.h>
#include <windows.h>
/* calcula el area de triangulo en base a sus lados */
main()
{
float LADO1,LADO2,LADO3,AREA,OPERACION,LADOS;
system("cls");
printf("Dame la longitud del lado # 1 \n");
scanf("%f",&LADO1);
scanf("%f",&LADO2);
scanf("%f",&LADO3);
LADOS=(LADO1+LADO2+LADO3)/2;
OPERACION=LADOS*(LADOS-LADO1)*(LADOS-LADO2)*(LADOS-LADO3);
AREA=sqrt(OPERACION);
printf("El area del triangulo es %8.2f \n",AREA);
getche();
En otro ejemplo tenemos el programa prog3-6.c en el cual encontrar la definicin de la constante PI
con valor de 3.1416, as mismo, encontrar la funcin pow() que permite elevar cualquier nmero a cualquier
potencia.
Diagrama 3-6.
/* prog3-6.c */
#include <stdio.h>
#include <math.h>
#define PI 3.1416
/* calcula el area de un circulo */
main()
{
float RADIO,AREA;
system("cls");
printf("Dame el radio del circulo \n");
scanf("%f",&RADIO);
AREA=PI*pow(RADIO,2);
printf("El area de un circulo con radio %8.2f es %8.2f \n",RADIO,AREA);
getche();
Por otro lado, en el programa prog3-7.c se plantea un problema de cada libre, en el cual una nia deja
caer su cartera desde el ltimo piso de la torre de Sears en Chicago cuya altura es de 1,454 pies. Calcule la
velocidad de impacto al llegar al suelo.
V = 2gh
Donde V es la velocidad final, g es la gravedad equivalente a 32 pies/seg2 y h es la altura

de la torre igual a 1,454 pies
En este programa encontramos la definicin de una constante llamada GRAVEDAD con un valor de
32, tambin se realiza una raz cuadrada con sqrt() y se incluye la directiva del preprocesador <math.h>
Diagrama 3-7.
/* prog3-7.c */
#include <stdio.h>
#include <math.h>
#define GRAVEDAD 32
/* resuelve un problema de caida libre */
main()
{
float ALTURA, VALOR,VEL_FINAL;
system("cls");
printf("Dame la altura de la torre \n");
scanf("%f",&ALTURA);
VALOR= 2*GRAVEDAD*ALTURA;
VEL_FINAL=sqrt(VALOR);
printf("La Velocidad Final es %8.2f pies/seg \n",VEL_FINAL);
getche();
Otro problema ser resuelto con el programa prog3-8.c el cual hace la conversin grados Fahrenheit
a centgrados. La frmula de conversin es C= (5/9) (F-32).
Diagrama 3-8.
/* prog3-8 */
#include <stdio.h>
/* convierte de grados fahrenheit a grados centigrados */
main()
{
float CENT,FAHR;
system("cls");
printf("Dame los grados fahrenheit a convertir \n");
scanf("%f",&FAHR);
CENT=(5.0/9.0)*(FAHR-32);
printf("%8.2f grados fahrenheit equivale %8.2f grados centigrados \n",FAHR,CENT);
getche();
Finalmente, en el programa prog3-9.c se resuelve el siguiente problema. Un avin que se encuentra

volando a una altura de 10,000 pies y a 150 millas por hora, desarrolla velocidades relativas con respecto al
viento de 300 millas por hora en la parte superior del ala y 80 millas por hora debajo del ala. Si el rea del ala
es de 160 pies2 , Cul ser la fuerza perpendicular a ella?
Suponiendo que la densidad a 10,000 pies de altura es p=0.001756 slugs/pies 3 . La frmula es
1
Fuerza = A * p (V12 V22 )
2
Donde A es el rea de la ala del avin: 160 pies2 ; p es la densidad a 10,000 pies de altura: 0.00175;
V1 es la velocidad relativa del viento en la parte superior del ala: 300 millas por hora, V2 es la velocidad relativa
del viento en la parte inferior del ala: 80 millas por hora. El factor que debe usarse para convertir las millas por
hora a pies por segundo es 44/30.
Diagrama 3-9.
/* prog3-9.c */
#include <stdio.h>
#include <math.h>
/* resuelve un problema de aviacion */
#define DENSIDAD 0.001756
main()
{
float AREA,V1,V2,FUERZA;
system("cls");
printf("Dame el area del ala \n");
scanf("%f",&AREA);
printf("Dame la velocidad relativa del viento en la parte superior del ala \n");
scanf("%f",&V1);
printf("Dame la velocidad relativa del viento en la parte inferior del ala \n");
scanf("%f",&V2);
/* convertir las millas por hora a pies por segundo */
V1=(44.0/30.0)*V1;
V2=(44.0/30.0)*V2;
FUERZA= AREA * (1.0/2.0) * DENSIDAD * (pow(V1,2)-pow(V2,2));
printf("la fuerza del viento perpendicular al ala es de %8.2f slugs-ft/seg2 \n",FUERZA);
getche();
3.5. ENTRADA Y SALIDA DE CARACTERES Y CADENAS DE CARACTERES.

Existen otras funciones semejantes a printf() y scanf(), que permiten la introduccin de datos a la
computadora desde el teclado. Estas funciones son:
Funcin Operacin
getchar() Lee un caracter desde el teclado, espera retorno de carro.
getche() Lee un caracter con eco, no espera retorno de carro.
getch() Lee un caracter sin eco, no espera retorno de carro.
putchar() Escribe un caracter en la pantalla
gets() Lee una cadena de caracteres desde el teclado
puts() Escribe una cadena de caracteres en la pantalla
La principal caracterstica de las funciones anteriores es que los valores insertados son caracteres y/o
cadenas de caracteres, mismas que pueden almacenar cualquier caracter incluyendo nmeros. Aun cuando en
la variables caracter se pueden almacenar nmeros, su utilizacin, generalmente, es para almacenar letras,
espacios en blancos y cualquier otro carcter.
Otra consideracin que se debe tener presente es que cuando se almacenan nmeros en variables de tipo
caracter no se pueden realizar operaciones algebraicas.
Ejemplo #1:
Sean operador1, operador2, variables de tipo enteras.
int operador1, operador2;
Se les asigna el valor de 40 y 20 respectivamente
operador1=40
operador2=20
Se realiza una operacin
resultado = operador1+operador2
La solucin a la anterior operacin es
resultado = 60
Ejemplo #2:
Por otro lado, sean operador1 y operador2 variables de tipo caracter
char operador1, operador2;
Se les asigna el valor de 40 y 20 respectivamente
operador1=40
operador2=20
Se realiza la operacin
resultado = operador1+operador2
La solucin a la anterior operacin es
resultado = 4020
En el ejemplo #1 se realiz una operacin algebraica, en el ejemplo #2 se realiz una concatenacin. De

hecho podemos ver que en la asignacin del ejemplo #2, los valores se escribieron entre comillas en un
intento por denotar que no es una asignacin algebraica.
En el programa prog3-10.c encontrar un ejemplo del uso de gets() y puts(), donde gets() se utiliza
para insertar el nombre de una persona
Diagrama 3-10.
/* prog3-10.c */
#include <stdio.h>
/* envia un saludo al usuario */
main()
{
char NOMBRE[30];
system("cls");
printf("Dame tu nombre \n");
gets(NOMBRE);
printf("Hola!, %s, Como Estas? \n",NOMBRE);
puts("Soy yo!, tu computadora...");
getche();
1. La lnea correspondiente a char NOMBRE[30] significa que se declara una variable llamada NOMBRE,
de tipo carcter, que permite insertar hasta 30 caracteres, por este motivo podemos decir que la variable
NOMBRE es una cadena de caracteres, tambin conocida como string. Ahora bien, aunque esta variable
permite insertar hasta 30 caracteres, se debe tomar en cuenta que lenguaje C coloca al final de una cadena
de caracteres un terminador nulo, esto significa que si usted corre el programa e inserta 30 o ms caracteres
el programa producir un error, por lo que recomendamos insertar mximo 29 caracteres.
2. La lnea que se refiere a gets(NOMBRE);, es la instruccin que permite insertar, desde el teclado, el
nombre de alguna persona.
3. La lnea correspondiente a printf("Hola!, %s, Como Estas? \n",NOMBRE), es la instruccin que
permite ver el nombre y un mensaje en la pantalla de su computadora. %s es un especificador de formato
que permite visualizar una cadena de caracteres.
4. La lnea que se refiere a puts("!Soy yo!, tu computadora..."); es una instruccin que se permite enviar
una cadena de caracteres al monitor de la computadora.
Ahora bien, aunque en este programa utilizamos gets() para introducir el nombre, desde el teclado, a la
computadora, esto no impide que utilicemos scanf(). Esto lo puede verificar en el siguiente programa llamado
prog3-11. C, donde se ha sustituido gets() por scanf(), y sustituimos puts() por printf().
/* prog3-11.c */
#include <stdio.h>
/* envia un saludo al usuario */
main()
{
char NOMBRE[30];
system("cls");
printf("Dame tu nombre \n");
scanf(" %[^\n]",NOMBRE);
printf("Hola!, %s, Como Estas? \n",NOMBRE);
printf("Soy yo!, tu computadora...");
getche();
En la lnea scanf( %[^\n], NOMBRE);, bien podra usarse el especificador de formato %s en lugar
de %[^\n]. La diferencia va estar en que con %s, al correr el programa, no se podr dar en espacios en blanco
entre el nombre y los apellidos, y con %[^\n] si podr hacerse. Para ver esta situacin se le pide que ejecute el
programa haciendo los cambios correspondientes.
La diferencia entre puts() y printf(), est en que puts() slo puede imprimir una cadena de caracteres,
no puede imprimir variables, printf() si puede hacerlo. Por lo tanto, SERA INCORRECTO ESCRIBIR:
puts(Hola!, %s, Cmo Estas? \n, NOMBRE), ya que esta lnea implica imprimir el valor de la variable
NOMBRE.
En el ltimo programa de este captulo se ver el uso de getchar() y getche(), el especificador de

formato %c y como convertir de letras maysculas a minsculas y viceversa. Observe el programa
prog3-12.c. En el caso de la funcin toupper() que convierte de minscula a mayscula, si se le pulsa una
letra que ya es mayscula no produce ningn cambio, lo mismo sucede con tolower() que convierte de
mayscula a minscula, si se le inserta una letra que ya es minscula no produce ningn cambio. En ambas
funciones, si se inserta un caracter que no es una letra, tampoco se har ningn cambio. Al ejecutar el
programa observar la diferencia entre getchar() y getche().
Diagrama 3-12.
/* prog3-12.c */
#include <stdio.h>
#include <ctype.h>
/* imprime una letra minuscula y mayuscula */
main()
{
char MIN,MAY,CMIN,CMAY;
system("cls");
puts("\n Dame un letra Minuscula \n");
MIN=getche();
puts("\n Dame un letra Mayuscula \n");
MAY=getchar();
CMIN=toupper(MIN); /* devuelve el equivalente en mayuscula */
CMAY=tolower(MAY); /* devuelve el equivalente en minuscula */
printf("\n La mayuscula de %c es %c \n", MIN, CMIN);
printf("\n La minuscula de %c es %c \n", MAY, CMAY);
getche();
3.6 DEFICIENCIAS EN LOS PROGRAMAS
La mayor parte de los programas realizados en este captulo presentan algunas deficiencias, las cuales en
la medida que avance el curso debern ser corregidas. La mayor parte de stas se deben a la posible insercin
de datos que arrojarn resultados incongruentes o que no tienen significados en la realidad, por ejemplo:
a) En los programas prog3-2.c y prog3-3.c que hacen la conversin pies a metros, si se insertan nmeros
negativos el resultado que se arrojara el programa no tiene ningn sentido en la realidad.
b) Lo mismo sucede en programa prog3-4.c, que calcula el rea de un cuadrado, pues al insertar un nmero
negativo, el resultado no tiene sentido alguno.
c) En el caso del programa prog3-5.c, que calcula el rea de un tringulo; si se insertan datos que no forman
un tringulo, el programa generar un error, pues la funcin que calcula la raz cuadrada: sqrt(), no
puede generar un resultado si el radical es negativo.
d) En el programa prog3-6.c, que calcula el rea de un crculo; si se inserta un radio negativo, el programa
arrojar un resultado sin sentido.
e) Lo mismo sucede en programa prog3-7.c que calcula la velocidad final de un objeto en cada libre cuando
ste llega al suelo; si se inserta una altura negativa, el resultado no tiene sentido.
f) En el caso del programa prog3-8.c, que realiza la conversin de la temperatura de grados farenheit
centgrados, no se presenta problema alguno, porque la conversin de valores negativos si tienen sentido
en la realidad.
g) Finalmente, en el programa prog3-9.c que calcula la fuerza perpendicular en la ala de un avin, se presenta
problemas similares, pues si se inserta una rea negativa del ala del avin, los resultados no tienen sentido
alguno en la realidad.
En algunos de estos programas, el programador deber decidir qu hacer cuando se inserten valores de
cero, pues por ejemplo, no se puede calcular el rea de un cuadro con lado=0, porque no existe un cuadrado
con esas dimensiones.
Por otro lado, es necesario que el alumno sepa diferenciar entre lo que significa que un programa arroje
resultados sin sentido que genere un error, ya que son situaciones completamente diferentes. Se dejar que
el maestro aborde el tema y explique esto, as como que el mismo alumno experimente con los programas.
3.7 PROBLEMAS PROPUESTOS.

a) Realice un programa que eleve al cuadrado y al cubo cualquier nmero, y que imprima el nmero junto a
su cuadrado y su cubo.
b) Antes de despegar un avin, el piloto anuncia el tiempo estimado de vuelo en minutos, realice un programa
que le ayude a determinar el porcentaje de avance del vuelo, teniendo como dato conocido al tiempo
transcurrido del vuelo en minutos.
c) Un maestro desea determinar el porcentaje de aprobados y reprobados en un grupo; slo sabe cuntos
alumnos han aprobado y cuntos han reprobado. Realice un programa que le ayude a calcular estos
porcentajes.
d) Una maestra midi la altura de Juanito al principio y al final de ao escolar. Realice un programa que le
ayude a determinar el porcentaje de crecimiento de Juanito.
Captulo #4
Estructuras Selectivas
if() y switch()
La programacin estructurada maneja instrucciones selectivas, repetitivas y secuenciales. A estas

instrucciones se les llama estructuras porque tienen un principio y un fin bien definido. La finalidad de la
programacin estructurada es que las instrucciones se ejecuten secuencialmente.
Existe una instruccin llamada goto. El uso que se le da a esta instruccin es para alterar la secuencia
de ejecucin normal de un programa. Anteriormente, cuando no existan los lenguajes estructurados, la
sentencia goto era muy utilizada. Sin embargo, desde que este tipo de lenguajes aparecieron, la instruccin goto
qued relegada y su uso descontinuado. La razn de esto es porque rompe la estructuracin de un programa,
hacindolo ms difcil de entender y de modificar. De hecho, utilizar goto, en un programa, es sinnimo de un
programa obsoleto y de mala calidad. Por lo tanto, no se recomienda su uso.
Aqu surge la polmica, cundo un programa es de buena calidad?. Para empezar, este tema est ms
ampliamente explicado en la rama de la ingeniera que se denomina Ingeniera de Software. Solamente
diremos que el buen programa es aqul que es fcil de entender, fcil de modificar y que arroja los
resultados correctos. Por lo tanto, cuando hagamos un programa debemos hacernos la siguiente consideracin:
Si este programa que estoy haciendo, lo ve una persona que tiene conocimientos medios-avanzados acerca del
lenguaje, ser capaz de entenderlo?.
4.1 SENTENCIA if()

Volviendo al tema de las estructuras selectivas. Estas son utilizadas en un programa cuando tenemos
que decidir entre dos caminos (alternativas) ms.
En el caso de if() se utiliza cuando tenemos que elegir entre dos caminos: Falso y Verdadero. Muchas
son las situaciones, dentro de la programacin, que enfrentan esta situacin, por ejemplo, un alumno slo puede
estar aprobado o reprobado, una persona slo puede ser del sexo masculino o femenino, una mercanca puede
estar entregada o no, una mujer puede estar embarazada o no, etc. en fin, hay muchas situaciones que son
binarias, es decir, slo tienen dos alternativas.
Dentro de la instruccin if() haremos uso de los operadores relacionales y los lgicos. Durante este
punto abordaremos programas que se enfrentan a situaciones binarias.
La sentencia if() escoge entre dos caminos segn sea la condicin: Falso o Verdadero. Ahora bien, es
necesario recalcar que el if() puede tener solamente parte verdadera, mientras que la parte falsa se puede omitir.
La parte falsa del if() comienza con la clusula else, de este modo tanto la parte falsa como la parte verdadera
estn delimitados por llaves { }.
La figura para representar la sentencia if(), en diagramas de flujo, es la siguiente:

PROCESO 1
CONDICION
V F
PROCESO 2 PROCESO 3
PROCESO 4
Lo que se debe destacar de la anterior figura es que las lneas de falso y verdadero se unen para
continuar un mismo camino.
Prog.4-1
Prog.4-2
Prog.4-3
Prog.4-4
Prog.4-5
Prog.4-6
Prog.4-7
Prog.4-8
Prog.4-9
Prog.4-10
Prog.4-11
Prog.4-12
Prog.4-13
Prog.4-14
Prog.4-15
Prog.4-16
Prog.4-17
En el primer programa de este captulo prog4-18.c se trata de conocer la situacin acadmica de un
alumno en una materia segn las calificaciones en dos exmenes parciales, de este modo, encontrar que si el
PROMEDIO es mayor o igual que 70, la variable SITUACION tendr el valor de APROBADO, pero si el
PROMEDIO es menor a 70, la variable SITUACION tendr el valor de REPROBADO. En este caso en
particular, el if() tiene parte falsa y parte verdadera.
Observe que la variable SITUACION es del tipo carcter con mximo 30 caracteres, as mismo,
observe que para asignar valor a la variable SITUACION se utiliz la funcin strcpy(), que significa copiar
una cadena de caracteres: STRING COPY. Para que esta funcin funcione adecuadamente se debe agregar, al
principio del programa, la directiva del preprocesador <string.h>.
/* prog4-18.c */
#include<stdio.h>
#include<string.h>
#include<conio.h>
#include<windows.h>
/* programa determina, en base a las calificaciones de los parciales, el promedio del

alumno y si esta aprobado o reprobado */
main()
{
long int MATRICULA;
char NOMBRE[30], SITUACION[30];
float PARCIAL1, PARCIAL2, PROMEDIO;
system("cls");
printf("Dame la matricula \n");
scanf("%ld",&MATRICULA);
printf("Dame el nombre \n");
printf("Dame la calificacion del primer parcial \n");
scanf("%f",&PARCIAL1);
printf("Dame la calificacion del segundo parcial \n");
PROMEDIO=(PARCIAL1+PARCIAL2)/2;
if(PROMEDIO>=70)
{
strcpy(SITUACION,"APROBADO");
}
else
{
strcpy(SITUACION,"REPROBADO");
} /* fin del if */
printf("El alumno con matricula %ld Se llama %s \n",MATRICULA,NOMBRE);
printf("tiene promedio de :%8.2f y esta %s\n", PROMEDIO,SITUACION);
getche();
En el siguiente programa prog4-19.c encontrar un if() que compara si dos valores son iguales.
Observe que la comparacin se realiza con doble igual (= =).
/* prog4-19.c */
#include<stdio.h>
#include<conio.h>
#include<windows.h>
main()
{
int VALOR1,VALOR2;
system("cls");
printf("Dame el primer numero \n");
scanf("%d",&VALOR1);
printf("Dame el segundo numero \n");
if(VALOR1==VALOR2)
{
printf("Los numeros son iguales\n");
}
else
{
printf("Los numeros son diferentes\n");
} /* fin del if */
getche();
En seguida tenemos el programa prog4-20.c en l encontrar un if() que compara si dos cadenas de
caracteres son iguales. Este programa es muy delicado, por lo que le recomendamos ser muy cuidadoso, por
ejemplo, si la primer cadena es FIME y la segunda fime, el resultado ser que las cadenas son diferentes porque
una tiene letras maysculas y la otra minsculas, esto es, la computadora no reconoce que es lo mismo. Por otro
lado, si la primer cadena es FIME y la segunda FIME, pero por error, al teclear la segunda cadena, dimos un
espacio en blanco despus de la E, el resultado ser que las cadenas son diferentes. Por eso, al correr el
programa, asegrese de teclear exactamente iguales las dos cadenas.
Tambin observe que la comparacin se realiz con la funcin strcmp(), que significa comparacin
de cadenas: STRING COMPARE. El signo de admiracin significa una negacin. Observe que no se utilizan
los signos de igual como en el anterior programa.
/* prog4-20.c *
/#include<stdio.h>
#include<conio.h>
#include<windows.h>
/* */
main()
{
char CADENA1[30],CADENA2[30];
system("cls");
printf("Dame la primer cadena \n");
scanf(" %[^\n]",CADENA1);
printf("Dame la segunda cadena \n");
if(!strcmp(CADENA1,CADENA2))
{
printf("Las cadenas son iguales\n");
}
else
{
printf("Las cadenas son diferentes\n");
} /* fin del if */
getche();
A continuacin tenemos el programa pro4-21.c el cual hace una comparacin para determinar, a partir
de dos nmeros, cul es mayor. Si se introducen dos nmeros iguales el programa arrojar un resultado
incongruente. Como ejercicio, se dejar al alumno que modifique el programa, de forma que no se presente
esta incongruencia.
/* prog4-21.c */
#include<stdio.h>
#include<conio.h>
#include<windows.h>
main()
{
int VALOR1,VALOR2;
system("cls");
if(VALOR1>VALOR2)
{
printf("El valor1: %d es mayor que el valor2: %d\n",VALOR1,VALOR2);
}
else
{
} /* fin del if */
getche();
Ahora tenemos el programa prog4-22.c el cual hace una comparacin entre dos cadenas para
determinar cul es mayor. Si se teclean dos cadenas exactamente iguales, el programa arrojar un
resultado incongruente. Al igual que el programa anterior, se dejar al alumno la modificacin del programa
para que no se presente esta incongruencia.
/* prog4-22.c */
#include<stdio.h>
#include<conio.h>
#include<windows.h>
/* determina, a partir de dos cadenas de caracteres, cual es mayor */

main()
{
int RESULTADO;
system("cls");
RESULTADO=strcmp(CADENA1,CADENA2);
if(RESULTADO>0)
{
printf("La cadena1: %s es mayor a la cadena2: %s \n",CADENA1,CADENA2);
}
else
{
printf("La cadena2: %s es mayor a la cadena1:%s \n",CADENA2,CADENA1);
} /* fin del if */
getche();
Auxiliados con los programas prog4-22.c y prog4-23.c analizaremos como funciona internamente el
if(). De esta manera, cuando se ejecuta un if(), se realiza una operacin que puede devolver un valor de cero o
diferente de cero.
Observe que El programa prog4-6.c es el mismo que el prog4-2.c pero est modificado. Aqu se
agreg la variable RESULTADO, y la operacin RESULTADO=VALOR1==VALOR2. De tal forma que
si VALOR1 es igual a VALOR2, RESULTADO tendr valor de uno, si no es as, RESULTADO tendr valor
igual a cero.
De este modo, para el if(), si la operacin da resultado de uno es verdadero, si da resultado
diferente a uno es falso.
/* prog4-23.c */
#include<stdio.h>
#include<conio.h>
/* */
/* este programa es el mismo que prog4-2.c pero modificado */
main()
{
int VALOR1,VALOR2, RESULTADO;
RESULTADO=VALOR1==VALOR2;
if(RESULTADO)
{
printf("Los numeros son iguales\n");
}
else
{
printf("Los numeros son diferentes\n");
}
/* fin del if */
printf("Resultado %d \n", RESULTADO);
getche();
}
/* fin de la funcion main() */
Si en el anterior programa cambiramos la frmula y tuviramos
RESULTADO=VALOR1>VALOR2, donde VALOR1=53 y VALOR2=21, el RESULTADO sera igual
uno, pero si VALOR1=23 y VALOR2=59, el RESULTADO sera igual a cero. Todo esto es vlido cuando
se trata de variables numricas.
Sin embargo, cuando se trata de una comparacin de cadenas de caracteres resulta lo siguiente:
RESULTADO=strcmp(CADENA1, CADENA2)
En estas condiciones tenemos tres posibles resultados

Primero, la variable RESULTADO es igual cero cuando las cadenas son iguales.
Segundo, la variable RESULTADO es mayor a cero cuando la CADENA1 es mayor a la CADENA2.
Y finalmente, la variable RESULTADO es menor a cero cuando la CADENA1 es menor a la CADENA2.
Por otro lado, si CADENA1=A y CADENA2=a y RESULTADO=str(CADENA1,CADENA2),

la variable resultado sera menor que cero porque le cdigo ASCII de A=65 y el cdigo ASCII de a=97. Por lo
tanto a es mayor que A.
4.1.1 . Funciones de Cadena de Caracteres.

Con el siguiente programa prog4-24.c se ver el uso de funciones de cadena, en este caso la funcin
isdigit() que determina si una cadena es un dgito (nmero) o no.
/* prog4-24.c */
#include<stdio.h>
#include<ctype.h>
#include<conio.h>
/* determina si un caracter es un digito (numero) */
main()
{
char CARACTER;
printf("Dame un caracter \n");
CARACTER=getchar();
if(isdigit(CARACTER))
{
printf("Si es digito: %c \n",CARACTER);
}
else
{
printf("No es digito: %c \n",CARACTER);
} /* fin del if */
getche();
Como ejercicio se dejar que el alumno investigue y utilice las siguientes funciones de cadena:
isalnum()
isalpha()
iscntrl()
isgraph()
islower()
isprint()
ispunct()
isspace()
isupper()
isxdigit()
strcat()
strchr()
En el siguiente programa prog4-25.c, se ver el uso del % como operador matemtico binario. En
necesario recalcar, que no se debe confundir el signo del porciento (%) cuando se usa dentro de la funcin
scanf() o printf() y cuando se usa en una operacin matemtica. Esto es, cuando se usa dentro de la funcin
scanf() o printf() este signo es parte del especificador de formato, pero cuando se usa dentro de una operacin
matemtica este signo es una operacin de mdulo (residuo) de una divisin entre nmeros enteros.
De este modo, si tuviramos lo siguiente:
Resultado=25/5 entonces Resultado=5

Resultado=25%5 entonces Resultado=0
Resultado=25/4 entonces Resultado=6.25
Resultado=25%4 entonces Resultado=1
Para resolver el siguiente problema del programa prog4-25.c, el cual determina si un nmero es par
impar, se utiliz, en la frmula matemtica, el mdulo (%) del nmero dado dividindolo entre dos.
Posteriormente, dentro del if() se invirti la salida con el signo de exclamacin (!). Un inconveniente de este
programa es que cuando el nmero analizado sea cero se imprimir un resultado incongruente.
/* prog4-25.c */
#include<stdio.h>
#include<conio.h>
#include<stdio.h>
/* */
main()
{
int NUMERO,RESULTADO;
printf("Dame un numero \n");
scanf("%d",&NUMERO);
RESULTADO=NUMERO%2;
if(!RESULTADO)
{
printf("El numero %d es par \n",NUMERO);
}
else
{
printf("El numero %d es impar \n", NUMERO);
} /* fin del if */
getche();
Hasta el momento hemos utilizado el if() con parte falsa y verdadera. Como dijimos anteriormente,
hay ocasiones que el if() puede tener solamente parte verdadera. Para ver este ejemplo desarrollaremos el
programa prog4-26.c, el cual tiene la siguiente redaccin.
Se desea calcular el pago del recibo de luz de una persona. Los datos de entrada son: Nmero de
Medidor, Cantidad de Kilowatts con consumidos, costo del kilowatt y saldo anterior. Si no se pago el recibo
anterior habr un recargo de quince pesos. La manera de saber si el recibo anterior se pag o no, es preguntar
si el saldo anterior es mayor a cero. Por lo tanto, el pago se calcula multiplicando la cantidad de kilowatts
consumidos por el costo del kilowatt, y si el recibo anterior no fue pagado se agrega el recargo y el saldo
anterior.
/* prog4-26.c */
#include<stdio.h>
#include<conio.h>
/* */
main()
{
long int MEDIDOR;
float KILOWATT,COSTO_KWT,SALDO_ANTERIOR, PAGO;
printf("Dame el numero de medidor \n");
scanf("%ld",&MEDIDOR);
printf("Dame la cantidad de kilowatts consumidos \n");
scanf("%f",&KILOWATT);
printf("Dame el costo por kilowatt \n");
scanf("%f",&COSTO_KWT);
printf("Dame el saldo anterior\n");
scanf("%f",&SALDO_ANTERIOR);
PAGO=KILOWATT*COSTO_KWT;
if(SALDO_ANTERIOR>0)
{
PAGO=PAGO+15+SALDO_ANTERIOR;
} /* fin del if */
printf("El Pago a realizar por el medidor # %ld es $ %8.2f \n",MEDIDOR,PAGO);
getche();
4.2 if() s ANIDADOS
Los if()s anidados se refiere al hecho de que hay una instruccin if() dentro de otra instruccin if().
Para entender este concepto analizaremos el programa prog4-27.c en el que podemos ver que por la parte falsa
del primer if() hay otro if(). Otro detalle que se debe observar es que los dos if() tienen parte falsa y verdadera,
esto no siempre sucede as. Este programa es el mismo que el prog4-21.c pero est modificado.
/* prog4-27.c */
#include<stdio.h>
#include<conio.h>
/* determina, a partir de dos valores, cual es mayor */
main()
{
int VALOR1,VALOR2;
if(VALOR1==VALOR2)
{
printf("No se puede determinar cual numero es mayor porque son iguales \n");
}
else
{
if(VALOR1>VALOR2)
{
printf("El valor1: %d esmayor que el valor2: %d\n",VALOR1,VALOR2);
}
else
{
} /* fin del if(VALOR1>VALOR2) */
} /* fin del if(VALOR1==VALOR2) */
getche();
A continuacin tenemos el programa prog4-28.c es el mismo que prog4-22.c pero modificado para
mostrar el uso de los if() anidados.
/* prog4-28.c */
#include<stdio.h>
/* */
#include<conio.h>
#include<stdlib.h>
#include<string.h>
main()
{
int RESULTADO;
system("cls");
RESULTADO=strcmp(CADENA1,CADENA2);
if(!RESULTADO)
{
printf("No se puede determinar cual cadena es mayor porque son iguales \n");
}
else
{
if(RESULTADO>0)
{
printf("La cadena1: %s es mayor a la cadena2: %s \n",CADENA1,CADENA2);
}
else
{
printf("La cadena2: %s es mayor a la cadena1:%s \n",CADENA2,CADENA1);
} /* fin del if(RESULTADO>0) */
} /* fin del if(!RESULTADO) */
getche();
Continuando con los ejemplos de if() anidados tenemos el programa prog4-29.c, que es el mismo
programa prog4-26.c pero modificado.
/* prog4-29.c */
#include<stdio.h>
/* determina si un numero es par o impar */
#include<stdlib.h>
#include<conio.h>
main()
{
int NUMERO,RESULTADO;
system("cls");
printf("Dame un numero \n");
if(NUMERO==0)
{
printf("No se puede determinar si el numero es par o impar porque es CERO
\n");
}else
{
RESULTADO=NUMERO%2;
if(!RESULTADO)
{
printf("El numero %d es par \n",NUMERO);
}
else
{
printf("El numero %d es impar \n", NUMERO);
} /* fin del if(!RESULTADO) */
} /* fin del if(NUMERO) */
getche();
Por otro lado, tenemos el programa prog4-30.c que determina el grado del acero cuando se conocen
los valores para T1 Y T2. De esta manera, el acero se considera de grado 1 si T1 excede a 0.95 y T2 excede a
0.75; de grado 2 si T1 excede a 0.95 pero T2 no excede a 0.75; y de grado 3 si T1 no es mayor que 0.95.
/* prog4-30.c */
#include<stdio.h> /* determina el grado del acero */
#include<conio.h>
main()
{
float T1,T2;
printf("Dame el valor de T1 \n");
scanf("%f",&T1);
printf("Dame el valor de T2 \n");
scanf("%f",&T2);
if(T1>0.95 && T2>0.75)
{
printf("El grado del acero es #1 \n");
}
else
{
if(T1>0.95 && T2<0.76)
{
} /* fin del if(T1>0.95 && T2<0.76) */
else
{
if(T1<0.96)
{
} /* fin del if(T1<.096) */
} /* fin del if(T1>0.95 && T2>0.75) */
} /* fin del if(T1>0.95 && T2>0.75) */
getche();
En el anterior programa prog4-30.c se utiliz, dentro de algunos if(), el operador lgico AND (doble
amperson) &&, el cual se utiliza para comprobar una doble condicin. No se debe confundir el amperson que
se utiliza dentro del scanf() porque tienen diferente funcin.
En seguida tenemos el programa prog4-31.c que calcula los pagos de los recibos de luz en base a las
siguientes tarifas:
14 KWH o menos $30 pesos
Los siguientes 51 KWH $0.50 por KWH
Exceso sobre 65 KWH $0.25 por KWH
/* prog4-31.c */
#include<stdio.h> /* calcula los pagos de los recibos de luz */
#include<conio.h>
main()
{
float KWH,PAGO,EXCESO;
printf("Dame los Kilowatts-hora consumidos\n");
scanf("%f",&KWH);
if(KWH<=14)
{
PAGO=30;
}
else
{
if(KWH>65)
{
EXCESO=KWH-65;
PAGO=30+51*0.50+EXCESO*0.25;
}
else
{
EXCESO=KWH-14;
PAGO=30+EXCESO*.50;
} /* fin del if(KWH>65) */
} /* fin del if(KWH<=14) */
printf("El pago debe ser de $%8.2f pesos\n",PAGO);
getche();
Para poner fin a este punto de los if() anidados, en el programa prog4-32.c se resuelve un problema
para determinar si tres longitudes pueden formar un tringulo.
/* prog4-32.c */
#include<stdio.h>
#include<conio.h>
/* */
main()
{
float LADO1,LADO2,LADO3,LADOS,LARGO;
printf("Dame lalongitud del lado 1\n");
scanf("%f",&LADO1);
scanf("%f",&LADO2);
scanf("%f",&LADO3);
if(LADO1!=0 && LADO2!=0 && LADO3!=0)
{
if(LADO1==LADO2)
{
if(LADO1>LADO3)
{
LADOS=LADO2+LADO3;
LARGO=LADO1;
}
else
{
LADOS=LADO1+LADO2;
LARGO=LADO3;
} /* fin del if(LADO1>LADO3) */
} /* fin del if(LADO1==LADO2) */
if(LADO1==LADO3)
{
if(LADO1>LADO2)
{
LADOS=LADO2+LADO3;
LARGO=LADO1;
}
else
{
LADOS=LADO1+LADO3;
LARGO=LADO2;
if(LADO2==LADO3)
{
if(LADO2>LADO1)
{
LADOS=LADO1+LADO3;
LARGO=LADO2;
}
else
{
LADOS=LADO2+LADO3;
LARGO=LADO1;
if(LADO1!=LADO2 && LADO1!=LADO3 && LADO2!=LADO3)

{
if(LADO1>LADO2 && LADO1>LADO3)
{
LADOS=LADO2+LADO3;
LARGO=LADO1;
}
else
{
{
LADOS=LADO1+LADO3;
LARGO=LADO2;
}
else
{
{
LADOS=LADO2+LADO1;
LARGO=LADO3;
} /* fin del if(LADO3>LADO1 && LADO3>LADO2) */
}/* fin del if(LADO1!=LADO2 && LADO1!=LADO3 && LADO2!=LADO3)*/
if(LADOS>LARGO)
{
printf("Si pueden formar un triangulo \n");
}
else
{
printf("No pueden formar un triangulo \n");
} /* if(LADOS>LARGO) */
}
else
{
printf("\n\nUno o mas de los numeros insertados son CERO\n");
printf("por lo tanto no es triangulo\n");
}
getche();
4.3 SENTENCIA switch()
La sentencia switch() se utiliza cuando tenemos dos opciones ms a elegir, as como dos ms
posibilidades a escoger segn un determinado problema.
La figura para representar la sentencia switch(), en diagramas de flujo, es la siguiente:
PROCESO 1
SALIDA 3 VARIABL SALIDA 1

E
SALIDA 2
PROCESO 4 PROCESO 3 PROCESO 2

PROCESO 5
Nota: Todas las salidas se unen para seguir un mismo camino.
En el siguiente programa prog4-33.c podemos elegir entre varias opciones para calcular el rea de
diversas figuras geomtricas.
/* prog4-33.c */
#include<stdio.h>
#include<math.h>
#include<conio.h>
#include<windows.h>
#define PI 3.1416 /* programa menu para obtener el area de diversas figuras */
void gotoxy(int x,int y); /*Declaracin de funcin gotoxy(x,y)*/
main()
{
int OPCION;
float RADIO,AREA,LADO,BASE,ALTURA;
system("cls");
gotoxy(20,5); printf("Menu para obtener el Area de diversas figuras\n");
gotoxy(10,8); printf("1.-Circulo");
gotoxy(10,10); printf("2.-Esfera");
gotoxy(10,12); printf("3.-Cuadrado");
gotoxy(10,14); printf("4.-Triangulo");
gotoxy(15,20); printf("Elija una opcion: ");
scanf("%d",&OPCION);
switch(OPCION)
{
case 1:
{
system("cls");
printf("Dame el radio \n");
scanf("%f",&RADIO);
printf("El area del circulo con radio=%8.2f es %8.2f\n",RADIO,AREA);
break;
} /* fin del case 1 */
case 2:
{
system("cls");
scanf("%f",&RADIO);
AREA=4*PI*pow(RADIO,2);
printf("El area de la esfera con radio=%8.2f es %8.2f\n",RADIO,AREA);
break;
case 3:
{
system("cls");
printf("Dame la longitud del lado \n");
scanf("%f",&LADO);
AREA=LADO*LADO;
printf("El area del cuadrado con lado=%8.2f es %8.2f\n",LADO,AREA);
break;
case 4:
{
system("cls");
printf("Dame la longitud de la Base\n");
scanf("%f",&BASE);
printf("Dame la Altura\n");
AREA=BASE*ALTURA/2.00;
printf("El area del triangulo con base=%8.2f, altura=%8.2f es
%8.2f\n",BASE,ALTURA,AREA);
break;
default:
{
printf("La opcion elegida no esta disponible\n");
} /* fin del default */
} /* fin del switch */
getche();
/*funcion gotoxy(x,y)*/
void gotoxy(int x, int y) {
COORD coord;
coord.X = x;
coord.Y = y;
SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), coord);
} /*fin de la funcion gotoxy(x,y)*/
Al realizar los siguientes programas establezca mecanismos para impedir el clculo de operaciones
matemticas que arrojen resultados irreales o errneos.
a) Auxiliado de las estructuras selectivas, modifique los programas del captulo #3. Elimine algunas
deficiencias sealadas en el apartado correspondiente. Tome como ejemplo, el cdigo siguiente
que se refiere prog3-2.c. Observe las modificaciones que se incluyeron, en el caso del if(), no permite
calcular la conversin con valores negativos.
/* prog3-2.c */
/* Programa modificado para eliminar deficiencias utilizando if() */
#include<stdio.h>
main()
{
int PIES;
float METROS;
clrscr();
scanf("%d", &PIES);
if(PIES<=0)
{
printf("el numero insertado es cero o menor a cero \n");
printf("no tiene sentido hacer conversiones con este numero\n");
printf("si desea intentar de nuevo debera de ejecutar otra vez el programa\n");
}
else
{
printf("%d pies son %f metros \n", PIES, METROS);
} /* fin del if */
getche();
b) Usted conoce el espacio total en un disco duro y tambin conoce el espacio ocupado. Realice un
programa que calcule el espacio disponible.
c) Usted est leyendo un libro. Realice un programa que le ayude a calcular el avance de lectura en
cualquier momento.
d) Se ha dejado caer, desde el reposo, una billetera de una torre. Realice un programa que le ayude a
calcular el porcentaje de distancia recorrido a los 2.3 segundos.
Los siguiente problemas propuestos son los mismos del captulo 3, ahora deber eliminar las deficiencias
correspondientes, utilizando las estructuras selectivas.
e) Realice un programa que eleve al cuadrado y al cubo cualquier nmero, y que imprima el nmero junto
a su cuadrado y su cubo.
f) Antes de despegar un avin, el piloto anuncia el tiempo estimado de vuelo en minutos, realice un
programa que le ayude a determinar el porcentaje de avance del vuelo, teniendo como dato conocido
al tiempo transcurrido del vuelo en minutos.
g) Un maestro desea determinar el porcentaje de aprobados y reprobados en un grupo; slo sabe cuntos
alumnos han aprobado y cuntos han reprobado. Realice un programa que le ayude a calcular estos
porcentajes.
h) Una maestra midi la altura de Juanito al principio y al final de ao escolar. Realice un programa que
le ayude a determinar el porcentaje de crecimiento de Juanito.
Captulo #5
Estructuras Repetitivas
for(), do{}while() y while(){}
Las estructuras repetitivas permiten que una serie de pasos, instrucciones o funciones se repitan con una
secuencia predeterminada.
Existen dos clases de estructuras repetitivas, las que se controlan por centinela y las que lo hacen
por contador. La diferencia es que en las estructuras controladas por centinela no se conoce de antemano las
veces en que se repetir un proceso y en las controladas por contador, esto s se conoce.
Lenguaje C tiene dos funciones repetitivas que se controlan por centinela y son: do{}while() y
while(){}, en las cuales el proceso se repite mientras la condicin es verdadera, sin embargo, entre estas
dos, la diferencia es que en el caso del do{}while(), la condicin para repetir el proceso est al final del
mismo, y en el caso del while() {}, la condicin est el principio. Aqu surge la pregunta obvia, Cundo y
en qu caso utilizar una la otra?. La respuesta es que se debe ver la situacin particular de cada programa ya
que en algunos casos es indiferente cul se utilice, pero en otros, es ms til una que otra. Esto se puede
determinar con la experiencia que cada programador tenga.
Por otro lado, lenguaje C tiene una funcin que se controla por contador en este caso es el for().
Es necesario comentar que en una buena parte de los problemas a que se enfrenta un programador, se
pueden utilizar ambas estructuras, es decir, las controladas por centinela o por contador, sin embargo, no son
pocas las ocasiones en que slo se puede utilizar una de las dos. Por ejemplo, analizaremos el problema a que
se refiere el programa prog5-1.c.
Finalmente, antes de pasar a ejemplos de programas en este captulo, haremos una importante
aclaracin. Esta es que, as como existen if()s anidados, es decir un if() dentro de otro if(), tambin existen
for() anidados, do{}while() y while(){} anidados etc. Es necesario tener esto en mente porque aunque en
este folleto no halla programas que exhiban estos ejemplos, dichas estructuras anidadas existen y son de uso
comn.
5.1 CICLO do{}while(condicin);

Esta sentencia es un ciclo repetitivo controlado por centinela donde la condicin para que se repita el
proceso se encuentra al final del mismo. Esta estructura se utiliza cuando no se conoce de antemano cuntas
veces se repetir un proceso que est inmerso en este ciclo. Es conveniente recordar que el proceso se
repetir mientras la condicin sea verdadera. Por ejemplo:
do{
Instruccin 1;
Instruccin 2;
Instruccin 3;
Instruccin 4;
Instruccin 5;
}while(centinela!=0)
El anterior ciclo puede entenderse as: Repita las instrucciones 1,2,3,4 y 5 mientras centinela sea
diferente a cero.
La secuencia para representar la sentencia do{}while(condicin);, en diagramas de

flujo, es la siguiente:
RAPTOR
PROCESO
CONDICION
La manera en que se trabaja con do/while en raptor es la misma primero el proceso despus la condicin.
De la anterior figura cabe mencionar que el falso y el verdadero NO se unen para continuar un solo
camino. Esta es la principal diferencia con el if(), que utiliza el mismo smbolo (un tringulo) pero en el if(), el
falso y el verdadero s se unen.
Es importante sealar que algunos autores prefieren utilizar un tringulo para sealar
una estructura selectiva como lo es el if() y un rombo para referirse a una estructura repetitiva
como lo son do{}while(condicin) y while(condicin){}, sin embargo, esa distincin
es innecesaria pues con la experiencia en la programacin, se puede determinar de antemano,
con relativa facilidad, cmo habr de codificarse. Se recomienda analizar, dentro de este
captulo, cmo las estructuras selectivas y repetitivas se complementan para la validacin de
campos o variables.
Entonces comenzaremos con una serie de programas que utilicen el do{}while(condicin);
En el programa prog5-1.c se tiene la siguiente situacin: Se deja caer una pelota desde una altura de
determinada (en metros), rebota y cada vez su altura es de dos tercios de su altura en el rebote anterior. Elabore
un programa que determine el nmero del rebote en el que la altura de la pelota es igual o inferior cincuenta
centmetros. Adems, deber imprimir el nmero de cada rebote y su correspondiente altura.
Para resolver este problema, necesariamente utilizaremos una estructura de repetitiva controlada por
centinela ya que no se puede utilizar la controlada por contador; de las dos disponibles utilizaremos
do{}while() por ser la que tiene la condicin al final del proceso repetitivo y se ajusta ms a nuestro problema.
Se utiliza una estructura controlada por centinela porque no sabemos cuntas veces se tendr que
calcular la nueva altura de la pelota despus de cada rebote ya que esto depende de la altura de la que se deja
caer la pelota. Por lo tanto, no sabemos cuntas veces se repetir el proceso, entonces, para este caso en
particular, utilizar una estructura controlada por centinela es la nica opcin para resolver el problema. Observe
la siguiente codificacin.
/* prog5-1.c*/
#include<stdio.h>
#include<conio.h>
/* Pelota que rebota 2/3 partes de su altura anterior */
main()
{
int REBOTE;
float ALTURA;
REBOTE=0;
printf("Dame la altura inicial de donde se deja caer la pelota, en metros\n");
if(ALTURA>0)
{
printf("Rebote Altura\n");
do{
REBOTE=REBOTE+1;
ALTURA=ALTURA*2/3;
/* imprimir todos los rebotes con sus alturas */
printf("%d %8.2f\n",REBOTE,ALTURA);
}while(ALTURA>0.50);
printf("Despues del rebote # %d, la altura es %8.2f\n",REBOTE,ALTURA);
}
else
{
printf("La altura insertada es cero o menor a cero \n");
printf("no tiene sentido hacer calculos con este numero \n");
printf("si dese intentar de nuevo debera de ejecutar, otra vez, el programa\n");
} /* fin del if */
printf("\n\n pulse cualquier tecla para regresar a la pantalla de edicion");

getche();
} /* fin de la funcion main */
Otro ejemplo lo tenemos en el programa prog5-2.c el cual es una adaptacin del programa prog3-
5.c., es este caso, al final del programa se pregunta si se desea continuar; si la respuesta es afirmativa deber
insertarse el nmero 1.
/* prog5-2.c */
#include <stdio.h>
#include <math.h>
#include<conio.h>
#include<stdlib.h>
main()
{
int OPCION;
do{
system("cla");
A continuacin tenemos el programa prog5-3.c, que es una adaptacin del programa prog3-8.c. En esta
ocasin, tambin se pregunta al final del programa si se desea continuar y si la respuesta fuere afirmativa deber
insertarse una S, ya sea mayscula o minscula. Por lo tanto, observe como en la condicin del while() se
coloc una doble condicin de S mayscula s minscula con el objetivo de no generar errores cuando
se pulse una u otra. Adems, se debe negar la condicin con (!) para que funcione adecuadamente.
/* prog5-3.c */
#include <stdio.h>
#include<stdlib.h>
#include <string.h>
/* convierte de grados fahrenheit a grados centigrados */
main(){
float CENT,FAHR;
char OPCION[2];
do{
system(cls);
printf("Dame los grados fahrenheit a convertir \n");
scanf("%f",&FAHR);
CENT=(5.0/9.0)*(FAHR-32);
printf("%8.2f grados fahrenheit equivale %8.2f grados centigrados \n",FAHR,CENT);
printf("Deseas continuar haciendo conversiones? \n");
printf("\n\n Pulsa la letra 'S' para continuar o cualquier otra letra para terminar\n");
scanf(" %[^\n]",OPCION);
}while( !strcmp(OPCION,"S") || !strcmp(OPCION,"s"));
5.2 CICLO while(condicin){ }
El modo de operacin de este ciclo es semejante al do{}while(condicion); . La diferencia est en el
lugar que ocupa la condicin. En el do{}while(condicion); el proceso siempre se ejecutar por lo menos una
vez porque la condicin se encuentra al final del proceso. Por el contrario, con el ciclo while(condicin){}
puede suceder que el proceso no se ejecute ni siquiera una vez porque la condicin se encuentra al principio del
proceso.
La secuencia para representar la sentencia while(condicin){...}, en diagramas de flujo, es la

siguiente:
RAPTOR
Al trabajar con raptor es posible el uso de un while, de forma parecida a la de un do/while excepto que primero
hay que declarar una variable ya sea por el creador del programa o por el usuario para que la condicin se
cumpla o no y al final del proceso volver a preguntar por la condicin para saber si se seguir ejecutando o se
terminara el programa.
Veamos el siguiente programa prog5-4.c. Observe como antes de while(OPCION==1) tuvimos que
incluir la operacin de asignacin OPCION=1, esto con la finalidad de que el proceso se ejecute por lo menos
una vez. Si no se hubiera incluido esta operacin el proceso nunca se ejecutara. Compare cuidadosamente con
el Programa prog5-2.c.
/* prog5-4.c */
#include <stdio.h>
#include<stdlib.h>
#include <math.h>
main(){
int OPCION;
OPCION=1;
while(OPCION==1)
{
system(cls);
scanf("%f",&LADO1);
scanf("%f",&LADO2);
scanf("%f",&LADO3);
LADOS=(LADO1+LADO2+LADO3)/2;
OPERACION=LADOS*(LADOS-LADO1)*(LADOS-LADO2)*(LADOS-LADO3);
AREA=sqrt(OPERACION);
printf("El area del triangulo es %8.2f \n",AREA);
printf("\n \n Deseas analizar otro triangulo? \n");
printf("Pulsa el numero 1 para continuar o cualquier otro numero para terminar\n");
} /* fin del while */
5.3 VALIDACIN DE CAMPOS O VARIABLES.
La validacin de campo o variables es asegurarse que el ingreso de datos tiene un rango o forma que
no puede violentarse porque entonces se cae en un error o inconsistencia. Por ejemplo, si estamos capturando
calificaciones, stas slo deben de estar entre cero y cien, de otra forma se vuelve un dato incongruente para el
contexto en el que se est utilizando.
Por otro lado, se mencion que algunos autores prefieren utilizar un tringulo para sealar una
estructura selectiva como lo es el if() y un rombo para referirse a una estructura repetitiva como lo son
do{}while(condicin); y while(condicin){}.
Sin embargo, el autor de este folleto considera que esa distincin es innecesaria, pues con la
experiencia en la programacin, se puede determinar de antemano, con relativa facilidad, cmo habr de
codificarse dicho tringulo.
Por ejemplo, cuando en un tringulo de diagrama de flujo, el falso y el verdadero se unen,

invariablemente la codificacin ser una estructura selectiva, es decir, es un if(), pero, cuando no se unen, la
codificacin corresponder a una estructura repetitiva, en este caso, do{}while(condicin);
while(condicin){}. Sin embargo, se debe ser muy cuidadoso, porque hay ocasiones en que un tringulo de
condicin deber codificarse en ambas formas, esto es, como estructura selectiva y repetitiva.
Para sostener esta afirmacin, se analizar el siguiente programa prog5-5.c que es el mismo que el
prog4-1.c, sin embargo se han quitado algunas deficiencias.
En este caso se desea calcular el promedio de la calificacin a partir de dos calificaciones parciales; el
programa est mejorado pues no permitir que se inserten, a la memoria RAM de la computadora, calificaciones
menores a cero mayores a cien. Si se inserta una calificacin invlida, el programa imprimir en el monitor
un mensaje de error y pedir que se inserte otra calificacin, de esta manera, el programa no avanzar hasta
que se tecle una calificacin vlida.
Observe la codificacin y ver que se utiliz un if() para imprimir el mensaje de error y un
do{}while(condicin); para que se pueda pedir nuevamente otra calificacin.
/* prog5-5.c */
#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
#include<string.h>
/* programa determina, en base a las calificaciones de los parciales,
el promedio del alumno y si esta aprobado o reprobado */
/* En este programa se observa como se complementan las estructuras
selectivas y repetitivas */
main(){
long int MATRICULA;
system(cls);
do{
if(PARCIAL1<0 ||PARCIAL1>100)
{
printf("Calificacion del Primer parcial Invalida,");
printf("favor de insertar otro numero\n\n");
} /* fin del if del PARCIAL1 */
}while(PARCIAL1<0 ||PARCIAL1>100);
do{
if(PARCIAL2<0 ||PARCIAL2>100)
{
printf("Calificacion del Segundo parcial Invalida,");
} /* fin de if del PARICIAL2 */
}while(PARCIAL2<0 ||PARCIAL2>100);
if(PROMEDIO>=70)
{
}
else
{
} /* fin del if */
system(cls);
printf("El alumno con matricula %ld Se llama %s \n",MATRICULA,NOMBRE);
printf("tiene promedio de :%8.2f y esta %s\n", PROMEDIO,SITUACION);
getche();
Este mecanismo de validacin se utiliza para impedir que se inserte a la computadora, informacin
que no tiene sentido para una organizacin, por ejemplo, los meses del ao slo pueden ser del 1 al 12; el ao
de nacimiento de una persona no puede ser mayor al ao que transcurre; la edad de una persona no puede ser
negativa ni ms grande de lo lgicamente aceptable, etc.
5.4 SENTENCIA for()
La funcin for() es una estructura repetitiva que se controla por contador y la figura
que se utiliza para representarla en diagramas de flujo es:
F PROCESO 2
INICIA
CONDICIO
INCREMENTO O
DECREMENTO V
PROCESO 1
FOR tambin puede ser interpretado en
raptor usando un do/while pero de
distinta forma. Lo que se hace en este
caso es declarar el valor de I despus
poner un do/while donde la condicin
ser con respecto a I, despus el RAPTOR
proceso y al terminarlo poner el
aumento de I.
Es conveniente recordar que en las estructuras controladas por contador, si se conoce de antemano
las veces en que un proceso se repetir, y slo se repetir mientras la condicin es verdadera.
La codificacin de la anterior figura es:
for(INICIAR; CONDICION; INCREMENTO o DECREMENTO)

{
PORCESO1;
} /* fin del for */
Observe que INICIAR est separada de CONDICION con un punto y coma, lo mismo sucede con
CONDICION e, INCREMENTO o DECREMENTO
As mismo, se puede apreciar un apartado de iniciar que es la parte donde se coloca el valor inicial
del contador. En el apartado de condicin se coloca el nmero de veces en que se repetir el proceso1. El
apartado de incremento o decremento indica el nmero en que el contador, se incrementar o decrementar,
con cada repeticin de Proceso1. Por ltimo, el Proceso2 se realizar despus de que se haya cumplido la
condicin. Por ejemplo: La siguiente instruccin:
for(Contador=1; Contador<25 ; Contador++)

{
instruccin 1
instruccin 2
instruccin 3
instruccin 4
instruccin 5
} /* fin del for */
El anterior ciclo puede leerse de la siguiente forma: Realiza las instrucciones 1,2,3,4,y 5 desde que el
contador vale uno mientras que sea menor a veinticinco, con incrementos de uno.
Con el programa prog5-6.c resolver la siguiente ecuacin cuadrtica para cuando X toma diez
valores diferentes a partir que X=15 con incrementos de 3. La ecuacin es la siguientes: Y=6X 2 +4X-3, en
este programa se utiliza la funcin for(), que es una estructura repetitiva controlada por contador.
/* prog5-6.c */
#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
#include<math.h>
/* imprime la tabulacion de la ecuacion cuadratica */
/* y=6x2+4x-3 */
main(){
float x,y;
int I;
system(cls); /* limpiar la pantalla de ejecucion */
printf("Tabular la ecuacion cuadratica y=6x2+4x-3 \n");
printf("introduzca el valor de X \n");
scanf("%f",&x);
for(I=1;I<=10;I++){
y=6*pow(x,2)+4*x-3; /* ecuacion cuadratica a tabular */
Con el programa prog5-7.c se resolver el programa anterior pero ahora se utilizar una estructura
repetitiva controlada por centinela.
/* prog5-7.c */
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
#include<math.h>
/* imprime la tabulacion de la ecuacion cuadratica */
/* y=6x2+4x-3 */
main(){
float x,y;
int I;
printf("Tabular la ecuacion cuadratica y=6x2+4x-3 \n");
printf("introduzca el valor de X \n");
scanf("%f",&x);
I=1;
do{
y=6*pow(x,2)+4*x-3; /* ecuacion cuadratica a tabular */
printf("Cuando X=%8.2f, Y= %8.2f \n",x,y);
x=x+3;
I=I+1;
}while(I<=10);
printf("\n Pulse cualquier tecla para regresar a la pantalla de edicion");
getche();
Con los programas prog5-8.c y prog5-9.c vamos a determinar la sumatoria de los primeros cien
nmeros enteros, es decir, del uno al cien. En el prog5-8.c se utiliza una estructura repetitiva controlada por
contador y en el prog5-9.c se utiliza una controlada por centinela.
/* prog5-8.c */
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
/* suma los primeros cien numeros enteros */
main(){
int SUMA,I;
printf("Calcular la sumatoria del 1 al 100 \n");
SUMA=0;
for(I=1;I<=100;I++){
/* prog5-9.c */
#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
/* suma los primeros cien numeros enteros */
main(){
int SUMA,I;
printf("Calcular la sumatoria del 1 al 100 \n");
SUMA=0;
I=1;
do{
SUMA=SUMA+I;
I=I+1;
}while(I<=100);
printf("La sumatoria es %d\n",SUMA);
getche();
Como se ver, estos ltimos programas pueden resolverse con estructuras repetitivas controladas por
contador y por centinela, esto no siempre es as, por lo que el alumno deber aprender a utilizar ambas
estructuras.
Los programas del prog5-10.c al prog5-15.c, resolvern algunos problemas con la estructura
repetitiva controlada por contador, es decir, el for(), se dejar que el alumno practique hacindolos de nuevo
con la estructura controlada por centinela, si es que esto fuera posible.
El programa prog5-10.c permite leer un valor para A, luego calcula e imprime la suma de los ocho
nmeros: 1, 1+A, 1+2A, 1+3A, 1+7A .
/* prog5-10.c */
#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
/* suma 1,1+A, 1+2A, 1+3A+...+1+7A */
main(){
int SUMA,I,A;
printf("Calcular la sumatoria 1,1+A, 1+2A, 1+3A+...+1+7A \n");
printf("Dame el Valor de A\n");
scanf("%d",&A);
El programa prog5-11.c calcula el promedio de N nmeros.
/* prog5-11.c */
#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
/* obtiene el promedio de N numeros */
main()
{
int I,N;
float SUMA,NUMERO,PROMEDIO;
printf("Obtener el promedio de N numeros \n");
printf("Cuantos numeros son?\n");
scanf("%d",&N);
SUMA=0;
for(I=1;I<=N;I++)
{
printf("Dame el numero %d: \n",I);
scanf("%f",&NUMERO);
SUMA=SUMA+NUMERO;
} /* fin del for */
PROMEDIO=SUMA/N;
printf("Sumatoria=%8.2f y el promedio= %8.2f\n",SUMA,PROMEDIO);
getche();
El programa prog5-12.c determina si un nmero es primo o no.
/* prog5-12.c */
#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
/* Determinar si un numero es primo */
main()
{
int I,N,NUMERO,PRIMO,RESIDUO;
printf("Determinar si un numero es primo \n");
printf("Dame el numero a analizar \n");
RESIDUO=0;
N=NUMERO/2;
for(I=2;I<=N;I++)
{
RESIDUO=NUMERO%I;
printf("Cuando I=%d, Residuo=%d \n",I,RESIDUO);
if(RESIDUO==0)
{
I=N;
PRIMO=0;
} /* fin del if RESIDUO==0 */
} /* fin del for */
if(PRIMO==0)
{
printf("\n El Numero=%d No es primo \n",NUMERO);
}
else
{
printf("\n El Numero=%d Si es primo \n",NUMERO);
} /* fin del if PRIMO==0 */
getche();
El programa prog5-13.c calcula el factorial de un nmero.
/* prog5-13.c */
#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
/* Calcular el factorial de un numero */
main(){
int I,NUMERO;
long int FACT;
printf("Calcular el factorial de un numero \n");
printf("Dame el numero \n");
FACT=1;
for(I=2;I<=NUMERO;I++){
FACT=FACT*I;
} /* fin del for */
printf("\n El Factorial de %d es: %ld \n",NUMERO,FACT);
getche();
El programa prog5-14.c permite imprimir la tabla de multiplicar de cualquier nmero.
/* prog5-14.c */
#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
/* Imprime la tabla de multiplicar de un numero */
main(){
int I,TABLA,RES;
printf("Imprimir la tabla de multiplicar de un numero \n");
printf("Dame el numero \n");
scanf("%d", &TABLA);
for(I=1;I<=10;I++){
RES=TABLA*I;
printf("\n %d * %d = %d \n",TABLA,I,RES);
} /* fin del for */
getche();
El programa prog5-15.c permite determinar el elemento mayor de una lista de N nmeros.
/* prog5-15.c */
#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
/* Determinar el elemento mayor de una lista de N numeros */
main(){
int I,N;
float NUMERO,MAY;
printf("Determinar el elemento mayor de una lista de N numeros \n");
printf("Cuantos numeros son?\n");
scanf("%d",&N);
printf("Dame el elemento # 1: \n");
MAY=NUMERO;
for(I=2;I<=N;I++){
printf("Dame el elemento # %d: \n",I);
if(NUMERO>MAY)
{
MAY=NUMERO;
} /* fin del if */
} /* fin del for */
printf("\n El elemento mayor es: %8.2f \n",MAY);
getche();
A continuacin tenemos el programa prog5-16.c que es el mismo de prog5-5.c, pero ahora se puede
calcular el promedio de varios alumnos en una misma corrida del programa.
/* prog5-16.c */
#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
#include<string.h>
/* programa que determina, en base a las calificaciones de los parciales,
el promedio de varios alumnos y si estan aprobados o reprobados */
main()
{
long int MATRICULA;
int I,N;
system(cls);
printf("Cuantos alumnos son?\n");
scanf("%d",&N);
for(I=1;I<=N;I++)
{
system(cls);
printf("Introduzca los datos del alumno # %d \n",I);
do{
if(PARCIAL1<0 || PARCIAL1>100)
{
printf("Calificacion del Primer parcial Invalida,");
}while(PARCIAL1<0 || PARCIAL1>100);
do{
if(PARCIAL2<0 || PARCIAL2>100)
{
printf("Calificacion del Segundo parcial Invalida,");
}while(PARCIAL2<0 || PARCIAL2>100);
if(PROMEDIO>=70)
{
}
else
{
} /* fin del if */
printf("El alumno %s tiene promedio:%8.2f esta %s\n", NOMBRE,PROMEDIO,SITUACION);
printf("\n \n Pulse cualquier tecla para continuar\n");
getche();
} /* fin del for */
printf("\n \n Pulse cualquier tecla para regresar a la pantalla de edicion\n");
getche();
El siguiente programa es el prog5-17.c que es una adaptacin del prog4-14.c, pero ahora se puede
calcular el pago de varios recibos en una misma corrida del programa.
/* prog5-17.c */
#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
/* calcula los pagos de los recibos de luz */
main()
{
float KWH,PAGO,EXCESO;
int I,N;
system(cls);
printf("Cuantos recibos de luz son? \n");
scanf("%d",&N);
for(I=1;I<=N;I++)
{
system(cls);
printf("Dame los Kilowatts-hora consumidos por el recibo #%d\n",I);
scanf("%f",&KWH);
if(KWH<=14)
{
PAGO=30;
}
else
{
if(KWH>65)
{
EXCESO=KWH-65;
PAGO=30+51*0.50+EXCESO*0.25;
}
else
{
EXCESO=KWH-14;
PAGO=30+EXCESO*.50;
} /* fin del if(KWH>65) */
} /* fin del if(KWH<=14) */
printf("El pago debe ser de $%8.2f pesos\n",PAGO);
printf("\n \n Pulse cualquier tecla para continuar \n");
getche();
} /* fin del for */
5.5 LA SENTENCIA break;
La sentencia break; se utiliza para terminar la ejecucin de ciclos o salir de una sentencia switch(). Se
puede utilizar dentro de las sentencias do{}while(),while(), for() o switch().
5.6 LA SENTENCIA continue;

La sentencia continue; se utiliza para saltarse el resto de la pasada actual a travs de un ciclo. El ciclo
no termina cuando se encuentra una sentencia continue, sencillamente no se ejecutan las sentencias que se
encuentran a continuacin en l y se salta directamente a la siguiente pasada a travs del ciclo. Se puede utilizar
dentro de una sentencia do{}while(),while(), for() o switch()..

a) Loenardo Fibonacci, un rico comerciante italiano del siglo XIII, introdujo una serie de nmeros conocidos
hoy en da como nmeros de Fibonacci. Los primeros 16 de ellos son:
1,1,2,3,5,8,13,21,34,55,89,144,233,377,610. Cada nmero de una secuencia de nmeros de fibonacci es la
suma de los dos nmeros que preceden inmediatamente al nmero considerado. Esto es:
1+1=2
1+2=3
2+3=5
3+5=8
5+8=13
8+13=21 etc.
Esta secuencia tiene aplicaciones prcticas en botnica, teora de redes elctricas y otros campos.
Realice el programa que determine los primeros 50 nmeros de la serie de Fibonacci.
b) Realice un programa que calcule la sumatoria de la siguiente serie:
C= ai bi= a1b1+a2b2+a3b3+a4b4, desde que i=1 hasta que i=4.
c) Una dama de edad avanzada desea pintar el piso del kiosco sin desperdiciar nada de pintura. Ella sabe por
experiencia que se necesita un cuarto de pintura para cubrir 37 pies cuadrados de rea. Si el piso del kiosco
tiene diez pies de dimetro qu cantidad de pintura debera comprar?. Realice un programa que resuelva
el anterior problema.
d) Realice un programa que calcule los valores desde que N=1 hasta N=20 en incrementos de uno e imprima
encabezados de lo siguiente:
3
N N2 N 10 N N3 N
e) Realice un programa que calcule la depreciacin de un automvil
Valor del Auto=$ 1,800,000
Vida=6
Rescate=$ 120,000
Imprima los siguientes encabezados
Ao Depreciacin Depreciacin Acumulada Valor Anual
La frmula de la depreciacin anual constate para cada ao de vida til
Costo Valorde Re scate

Depreciacin =
VidaUtil
f) En la fbrica de sillas Bibliomodel, el pago a sus empleados est basado en una tarifa diaria ms un
incentivo, el cual depende del nmero de sillas producidas durante el da. Calcule el salario de cada
empleado. Por ejemplo, a un salario bsico de $3.50 dlares por hora y con 60 centavos de incentivo por
cada silla producida por encima de 50 unidades, un empleado que ensamble 76 sillas recibir:
(3.50)(8)+(76-50)(0.60)=28.00+15.60=$43.60
g) Dado un conjunto de nmeros (mnimo 20, mximo 50), realice un programa que:
1. Sume los nmeros dados.
2. Muestre cul es el nmero menor.
3. Muestre cul es el nmero mayor.
4. Muestre el cantidad de valores iguales a 25.
5. Muestre la cantidad de valores mayores a 20 y menores a 70.
h) Utilizando el teorema de Pitgoras, realice un programa que determine las tercia de nmeros menores a
cien y que formen un tringulo rectngulo, por ejemplo, 05-12-13, 40-50-30 y 26-24-10, son tercias de
nmeros que cumplen dicha condicin.
i) Asuma que ha invertido $1,000 pesos en una caja popular. La junta directiva le ha asegurado que usted
duplicar su inversin en cada dos aos. Elabore un programa que calcule su inversin cada ao. El
procedimiento deber imprimir una lista semejante a la siguiente:
2 aos $ 200
4 aos $ 400
6 aos $ 800
8 aos $ 1,600
10 aos $ 3,200
12 aos $ 6,400
14 aos $12,800
j) Realice un programa dirigido a los nios de educacin primaria. El programa deber hacer diez preguntas
sencillas de historia, biologa o matemticas. As mismo, en cada pregunta se debern establecer por lo
menos 4 opciones de respuesta, si se inserta una opcin invalida, el programa deber advertir al nio para
que escoja slo entre las opciones ofrecidas. Despus de cada respuesta, el programa deber mostrar un
registro de la cantidad de preguntas contestadas correctamente, de las incorrectas y de las que faltan por
contestar. Al terminar deber imprimir una calificacin.
k) El nmero de sonido emitidos por un grillo en un minuto es una funcin de la temperatura. Como resultado
de esto, es posible determinar el nivel de temperatura utilizando al grillo como termmetro!. La frmula
N
de la funcin es: t = +40, donde t representa la temperatura en grados Fahrenheit y n representa el
4
nmero de sonidos emitidos en un minuto. Elabore un programa que determine e imprima los valores para
t cuando n toma los valores de 40,50,60,70,,140,150.
l) El tiempo que requiere un satlite para dar una revolucin completa alrededor de la tierra y a una
1.540
determinada altura es una funcin de su velocidad. La frmula para una altitud de 100 millas es t= ,
s
donde t es el tiempo y s es la velocidad del satlite en miles de millas por hora. Elabore un programa que
calcule e imprima t para los valores de s 18,19,20,24.
Captulo #6
Funciones Definidas por el Usuario sin Parmetros
Lenguaje C es un lenguaje orientado a funciones, de tal forma que printf(), scanf(), for(), if(),
switch(), do{}while(), while(), getche(), main(), pow(), sqrt(), etc. son funciones. A estas funciones se les
llama predeterminadas porque ya existen en lenguaje C.
De esta manera, lenguaje C permite que el programador haga sus propias funciones, a stas les llama
funciones definidas por el usuario. As mismo, dentro de estas funciones hay de dos tipos, las que tienen y las
que no tienen parmetros.
En este captulo utilizaremos las funciones definidas por el usuario sin parmetros por ser las ms
sencillas y fciles, es recomendable que los alumnos interesados, estudien por cuenta propia las funciones
definidas por el usuario con parmetros.
En el siguiente programa prog6-1.c que es el mismo que el prog4-16.c pero ahora est hecho con
funciones. Aqu podemos encontrar las siguientes cosas:
En los programas anteriores las variables han sido declaradas dentro de la funcin main(), en este
programa estn declaradas afuera y para ser precisos antes de la funcin main(), cuando esto sucede a estas
variables se les llama variables globales. Por lo tanto cuando, hay variables declaradas dentro de una funcin
se les llama variables locales a la funcin.
En resumen, en un programa puede haber variables locales y globales. Su funcin, su uso y manejo
tienen una diferencia notable por lo que es conveniente que los alumnos interesados en este tema lo estudien
por cuenta propia.
Por otro lado, cuando se manejan funciones se deben considerar tres cosas: La declaracin (prototipo)
de la funcin, la llamada a la funcin y la definicin de la funcin. As mismo, se utilizaron lneas de
comentario para identificar cada una de estas tres partes. Observe que tanto en la declaracin como en la
definicin de la funcin se anota void, lo cual indica que las funciones no contienen parmetros, tambin se
dice que estas funciones no retornan ningn valor.
En la definicin de la funcin se escriben las instrucciones que estn dentro de la funcin, a esto
tambin se le llama cuerpo de la funcin, estas instrucciones se ejecutarn cuando se llame a la funcin. Al
final del cuerpo de funcin se escribe la sentencia return; que indica el regreso a la posicin de donde fue
llamada la funcin.
Compare el programa prog6-1.c con el programa prog4-16.c para que observe las diferencias entre
un programa con y sin funciones.
DIAGRAMAS DE FLUJO
FUNCION MAIN
MENU
CIRCULO ESFERA
CUADRADO TRIANGULO
/* prog6-1.c */
#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#define PI 3.1416
/* programa menu para obtener el area de diversas figuras
utilizando funciones*/
/* declaracion de las funciones */

void menu();
void circulo();
void esfera();
void cuadrado();
void triangulo();
/* declaracion de variables globales */

int OPCION;
float RADIO,AREA,LADO,BASE,ALTURA;
main()
{
menu(); /* llamada a la funcion menu() */
system("pause");
/* definicion de funciones */
void menu()
{
system("cls");
printf("\tMenu para obtener el Area de diversas figuras\n\n");
printf("\t\t\t1.-Circulo\n");
printf("\t\t\t2.-Esfera\n");
printf("\t\t\t3.-Cuadrado\n");
printf("\t\t\t4.-Triangulo\n\n");
printf("\t\tElija una opcion: ");
switch(OPCION)
{
case 1:
{
circulo(); /* llamada a la funcion circulo() */
break;
case 2:
{
esfera(); /* llamada a la funcion esfera() */
break;
case 3:
{
cuadrado(); /* llamada a la funcion cuadrado() */
break;
case 4:
{
triangulo(); /* llamada a la funcion triangulo() */
break;
default:
{
printf("La opcion elegida no esta disponible\n");
} /* fin del default */
} /* fin de la funcion menu() */
void circulo()
{
system("cls");
scanf("%f",&RADIO);
printf("El area del circulo con radio=%8.2f es %8.2f\n",RADIO,AREA);
return;
} /* fin de la funcion circulo() */
void esfera()
{
system("cls");
scanf("%f",&RADIO);
AREA=4*PI*pow(RADIO,2);
printf("El area de la esfera con radio=%8.2f es %8.2f\n",RADIO,AREA);
return;
} /* fin de la funcion esfera */
void cuadrado()
{
system("cls");
printf("Dame la longitud del lado \n");
scanf("%f",&LADO);
AREA=LADO*LADO;
printf("El area del cuadrado con lado=%8.2f es %8.2f\n",LADO,AREA);
return;
} /* fin de la funcion cuadrado */
void triangulo()
{
system("cls");
printf("Dame la longitud de la Base\n");
scanf("%f",&BASE);
printf("Dame la Altura\n");
AREA=BASE*ALTURA/2.00;
printf("El area del triangulo con base=%8.2f, altura=%8.2f es %8.2f\n",BASE,ALTURA,AREA);
return;
} /* fin de la funcion triangulo */
Las funciones pueden ser concebidas como programas pequeos dentro de un

programa o mejor dicho subprogramas. El smbolo que se utiliza para representar a una
funcin es el siguiente:
Programa 6.2
El Seor Lpez ha recibido una oferta de empleo de la Compaa de juguetes Ensueo con la
oportunidad elegir entre dos sistemas de pago. Puede recibir un salario mensual de $5,000 y $50 de aumento
cada mes, o puede recibir un salario mensual de $5,000 con un aumento anual de $800. Realice un programa
que determine el salario mensual para los siguientes tres aos. El programa debe determinar los salarios
acumulados despus de cada mes y a partir de esta informacin determinar el mejor mtodo de pago.
DIAGRAMA DE FLUJO
FUNCION MAIN DATOS
ECISION
/* prog6-2.c */
#include<stdio.h>
/* Determinar cual opcion de salario es mejor */
/* declaracion de las funciones */

void datos();
void opcion_1();
void opcion_2();
void decision();

float SALARIO_MENSUAL, SALARIO_MENSUAL2, AUMENTO_MENSUAL, AUMENTO_ANUAL;
float TOTAL_1, TOTAL_2,MESES;
int MES,CAMBIO_ANUAL, PERIODO;
main()
{
TOTAL_1=0;
TOTAL_2=0;
datos(); /* llamada a la funcion datos() */
opcion_1(); /* llamada a la funcion opcion_1() */
opcion_2(); /* llamada a la funcion opcion_2() */
decision(); /* llamada a la funcion decision() */
printf("\n\n Pulse cualquier tecla para regresar a la pantalla de edicion\n");
getche();
void datos()
{
do{
clrscr();
printf("Dame el salario mensual\n");
scanf("%f",&SALARIO_MENSUAL);
SALARIO_MENSUAL2=SALARIO_MENSUAL;
printf("Dame el aumento mensual\n");
scanf("%f",&AUMENTO_MENSUAL);
printf("Dame el aumento anual\n");
scanf("%f",&AUMENTO_ANUAL);
printf("A cuantos aos desea hacer el calculo?\n");
scanf("%d",&PERIODO);
MESES=PERIODO*12;
if(SALARIO_MENSUAL<=0 || AUMENTO_MENSUAL<=0 || AUMENTO_ANUAL<=0 || PERIODO<=0)
{
printf("\n\n Uno o mas datos insertados NO son validos,");
printf("\n favor de revisarlos e intentar de nuevo\n");
printf(" Pulse cualquier tecla para continuar\n");
getche();
} /* fin del if */
}while(SALARIO_MENSUAL<=0 || AUMENTO_MENSUAL<=0 || AUMENTO_ANUAL<=0 || PERIODO<=0);
} /* fin de la funcion datos */
void opcion_1()
{
clrscr();
printf("Calculo de la Primera Opcion\n");
printf("Mes Salario Mensual Acumulado\n");
for(MES=1;MES<=MESES;MES++)
{
TOTAL_1=TOTAL_1+SALARIO_MENSUAL;
SALARIO_MENSUAL=SALARIO_MENSUAL+AUMENTO_MENSUAL;
printf("%d %8.2f %8.2f\n",MES,SALARIO_MENSUAL,TOTAL_1);
} /* fin del for */
printf("OPCION 1: TOTAL DE SUELDO FINAL DEL AO %d :$%12.2f \n",PERIODO,TOTAL_1);
printf("Pulse cualquier tecla para continuar\n");
getche();
return;
} /* fin de la funcion opcion_1 */
void opcion_2()
{
clrscr();
printf("Calculo de la Segunda Opcion\n");
printf("Mes Salario Mensual Acumulado\n");
for(MES=1;MES<=MESES;MES++)
{
TOTAL_2=TOTAL_2+SALARIO_MENSUAL2;
CAMBIO_ANUAL=CAMBIO_ANUAL+1;
if(CAMBIO_ANUAL==13)
{
SALARIO_MENSUAL2=SALARIO_MENSUAL2+AUMENTO_ANUAL;
CAMBIO_ANUAL=1;
} /* fin del if */
printf("%d %8.2f %8.2f\n",MES,SALARIO_MENSUAL2, TOTAL_2);
} /* fin del for */
getche();
return;
} /* fin de la funcion opcion_2 */
void decision()
{
clrscr();
if(TOTAL_1==TOTAL_2)
{
printf("\n\n Ninguna opcion es mejor que la otra\n");
}
else
{
if(TOTAL_1>TOTAL_2)
{
printf("\n\n La mejor opcion es la numero 1\n");
}
else
{
printf("\n\n La mejor opcion es la numero 2\n");
} /* fin del if TOTAL_1>TOTAL_2 */
} /* fin del if TOTAL_1==TOTAL_2 */
return;
} /* fin de la funcion decision */
Captulo #7
Arreglos de Memoria
Un arreglo es una coleccin de variables del mismo tipo que se referencian utilizando un nombre
comn.
Un arreglo de memoria le permite a la computadora recordar valores pasados.
7.1 ARREGLOS DE MEMORIA UNIDIMENSIONALES

El formato general para la declaracin de un arreglo unidimensional es
tipo nombre_variable [tamao]
Aqu tipo declara el tipo de variable del arreglo. El nombre_variable es el nombre de la variable que
es arreglo de memoria. El tamao es la cantidad de elementos que guardar el arreglo. Por ejemplo, el siguiente
arreglo llamado lista podr almacenar 15 elementos enteros.
int Lista[15];
No debe confundirse con la forma de declarar un variable de cadena de caracteres. Por ejemplo:
char nombre[30];
char nombre[15][30];
En el primer caso se declar una variable que es una cadena de caracteres y que puede almacenar hasta
30 caracteres.
En el segundo caso se declar un arreglo de cadena de caracteres; este arreglo de memoria podr
almacenar hasta quince cadenas con 30 caracteres cada cadena.
Problema 7.1: Realice un programa que lea e imprima los elementos de una lista de N nmeros. Prog7-1.c.
Funcin main
Funcin leer_elementos
Funcin imprimir_elementos
/* prog7-1.c */
#include<stdio.h> /* declaracion de funciones */
void Leer_Elementos();
void Imprimir_Elementos();

int I,N,Lista[100];
main()
{
/* llamar a la funciones */
Leer_Elementos();
Imprimir_Elementos();
/* -------------------------------------- */
/* definicion de las funciones */
void Leer_Elementos()
{
system("cls");
printf("Cuantos elementos tiene la lista de numeros? \n");
scanf("%d",&N);
for(I=1;I<=N;I++)
{
clrscr();
printf("Dame el Elemento[%d] \n",I);
scanf("%d",&Lista[I]);
} /* fin del for */
return;
} /* fin de la funcion Leer_Elementos() */
/* -------------------------------------- */
void Imprimir_Elementos()
{
system("cls");
for(I=1;I<=N;I++)
{
printf("Elemento[%d]=%d \n",I,Lista[I]);
} /* fin del for */
getche();
return;
} /* fin de la funcion Imprimir_Elementos() */
Problema7.2: Realice un programa que sume los elementos de una lista de N nmeros. Prog7-2.c.
Funcin main
Funcin leer_elementos
Funcin sumar_elementos
/* prog7-2.c */
#include<stdio.h>
/* declaracion de funciones */
void Sumar_Elementos();

int I,N,Lista[100],Sumatoria;
main()
{
/* llamar a las funciones */
Leer_Elementos();
Sumar_Elementos();
/* -------------------------------------- */
/* defincion de las funciones */
{
system("cls");
scanf("%d",&N);
for(I=1;I<=N;I++)
{
system("cls");
} /* fin del for */
return;
/* -------------------------------------- */
void Sumar_Elementos()
{
Sumatoria=0;
for(I=1;I<=N;I++)
{
Sumatoria=Sumatoria+Lista[I];
} /* fin del for */
return;
} /* fin de la funcion Sumar_Elementos() */
/* -------------------------------------- */
{
system("cls");
for(I=1;I<=N;I++)
{
} /* fin del for */
printf("La sumatoria de los elementos es %d \n",Sumatoria);
getche();
return;
} /* fin de la funcion Imprimir_Elementos() */
Problema 7.3: Realice un programa que determine el elemento mayor de una lista de N nmeros. Prog7-
3.c.
Funcin main
Funcin Leer_Elementos
Funcin Imprimir_Elementos
Funcin Elemento_mayor
/* prog7-3.c */
#include<stdio.h>
void Elemento_Mayor();

int I,N,Mayor,Lista[100];
main()
{
/* llamar a la funciones */
Leer_Elementos();
Elemento_Mayor();
/* -------------------------------------- */
{
system("cls");
scanf("%d",&N);
for(I=1;I<=N;I++)
{
system("cls");
} /* fin del for */
return;
/* -------------------------------------- */
void Elemento_Mayor()
{
Mayor=Lista[1];
for(I=2;I<=N;I++)
{
if(Lista[I]>Mayor)
{
Mayor=Lista[I];
} /* fin if(Lista[I]>Mayor) */
} /* fin del for */
return;
} /* fin de la funcion Elemento_Mayor() */
/* -------------------------------------- */
{
system("cls");
for(I=1;I<=N;I++)
{
} /* fin del for */
printf("El elemento mayor de esta lista es; %d \n",Mayor);
getche();
return;
} /* fin del funcion Imprimir_Elementos() */
Problema 7.4: Realice un programa que haga la bsqueda secuencial de un nmero en una lista de N nmeros
e imprima si fue encontrado o no. Suponga que ningn elemento se repite en la lista. Prog7-4.c. En este
programa se puede observar que la variable Encontrado se utiliza como una variable de control que implica
que si Encontrado=0 no se encontr el nmero buscado en la lista, pero si Encontrado=1 implica que el
nmero buscado si est en la lista.
Por otro lado, en la funcin Busqueda() se utiliz la sentencia continue que implica que termine el
for() sin terminar su ejecucin.
Funcin main
Funcin Leer_Elementos
Funcin busqueda
/* prog7-4.c */
/*#include<stdio.h>
prog7-4.c */
#include<stdio.h>
/*void
declaracion de funciones */
Leer_Elementos();
void
voidLeer_Elementos();
Busqueda();
void
voidBusqueda();
/*int
declaracion de variables globales */
I,N,Buscado,Encontrado,Lista[100];
int I,N,Buscado,Encontrado,Lista[100];
char OPCION[2];
char OPCION[2];
main()
main()
{
{ /* llamar a las funciones */
/*Leer_Elementos();
llamar a las funciones */
Leer_Elementos();
do{
do{ system("cls");
system("cls");
Busqueda();
Busqueda();
printf("\n \n Deseas hacer otra busqueda en la misma lista de numeros? \n");
printf("\n \n Deseas
printf("Pulse hacer
la letra 'S' otra
para busqueda en olacualquier
continuar, misma lista
otradeletra
numeros?
para \n");
printf("Pulse la letra 'S' para continuar, o cualquier otra letra para terminar\n
terminar\n");
scanf("
scanf("%[^\n]",OPCION);
%[^\n]",OPCION);
}while(!strcmp(OPCION,"S")
}while(!strcmp(OPCION,"S")||||!strcmp(OPCION,"s"));
!strcmp(OPCION,"s"));
} }/*/*fin
findedelalafuncion
funcionmain()
main()*/*/
/*/*--------------------------------------
--------------------------------------*/*/
/*/*definicion
definiciondedelas lasfunciones
funciones*/*/
void
voidLeer_Elementos()
Leer_Elementos()
{{
system("cls");
system("cls");
printf("Cuantos
printf("Cuantoselementos
elementostiene
tienelalalista
listadedenumeros?
numeros?\n");
\n");
scanf("%d",&N);
scanf("%d",&N);
for(I=1;I<=N;I++)
for(I=1;I<=N;I++)
{{
system("cls");
system("cls");
printf("Dame
printf("DameelelElemento[%d]
Elemento[%d]\n",I);
\n",I);
} }/*/*fin
findel
delfor
for*/*/
return;
return;
} }/*/*fin
findedelalafuncion
funcionLeer_Elementos()
Leer_Elementos()*/*/
/*/*--------------------------------------
--------------------------------------*/*/
void
voidBusqueda()
Busqueda()
{{
Encontrado=0;
Encontrado=0;
printf("Dame
printf("Dameelelnumero
numerobuscado:
buscado:\n");
\n");
scanf("%d",&Buscado);
scanf("%d",&Buscado);
for(I=1;I<=N;I++)
for(I=1;I<=N;I++)
{{
if(Buscado==Lista[I])
if(Buscado==Lista[I])
{{
Encontrado=1;
Encontrado=1;
continue;
continue;
} }/*/*fin
findel
delif(Buscado==Lista[I])
if(Buscado==Lista[I])*/*/
} }/*/*fin
findel
delfor
for*/*/
if(Encontrado==1)
if(Encontrado==1)
{{
printf("\n
printf("\n\n\nElElnumero
numeroSISIfue
fueencontrado
encontrado\n");
\n");
}}
else
else
{{
printf("\n
printf("\n\n\nElElnumero
numeroNONOfue
fueencontrado
encontrado\n");
\n");
} }/*/*fin
finif(Encontrado)
if(Encontrado)*/*/
Imprimir_Elementos();/*/*llamada
llamadaa alalafuncion
funcionImprimir_Elementos()
Imprimir_Elementos()*/*/
printf("\n
printf("\n\n\nPulse
Pulsecualquier
cualquiertecla
teclapara
paracontinuar
continuar\n");
\n");
getche();
getche();
return;
return;
} }/*/*fin
findedelalafuncion
funcionBusqueda
Busqueda*/*/
/*/*--------------------------------------
--------------------------------------*/*/
void
voidImprimir_Elementos()
Imprimir_Elementos()
{{
for(I=1;I<=N;I++)
for(I=1;I<=N;I++)
{{
printf("Elemento[%d]=%d\n",I,Lista[I]);
} }/*/*fin
findel
delfor
for*/*/
return;
return;
} }/*/*fin
findedelalafuncion
funcionImprimir_Elementos()
Imprimir_Elementos()* *
Problema 7.5. Utilice Funciones Definidas por el Usuario sin Parmetros y arreglos de memoria
unidimensionales. Se deja caer una pelota desde una altura de 50 metros, rebota y cada vez su altura es de dos
tercios de su altura en el rebote anterior.
a) Elabore un programa que determine e imprima la altura de la pelota desde el primer rebote
hasta que la altura de la pelota sea igual menor a un centimetro.
b) Determine e imprima en cul nmero del rebote en la altura de la pelota ya es igual o inferior
a cincuenta centmetros.
c) Calcule e imprima la altura promedio de la pelota en todos los rebotes.
d) Calcule e imprima cuantos rebotes le proporcionan a la pelota una altura superior al promedio.
Funcin main
Funcin inciso_a
Funcin inciso_b
Funcin inciso_c
Funcin inciso_d
/*/*prog7-5.c
prog7-5.c*/*/
/*/*Pelota
Pelotaque
querebota
rebota2/3
2/3partes
partesdedesusualtura
alturaanterior
anterior*/*/
#include<stdio.h>
#include<stdio.h>
/*/*declaracion
declaraciondedefunciones
funciones*/*/
voidinciso_a();
void inciso_a();
voidinciso_b();
void inciso_b();
voidinciso_c();
void inciso_c();
voidinciso_d();
void inciso_d();
/*/*declaracion
declaraciondedevariables
variablesglobales
globales*/*/
floatALTURA[1000],ALTO,ALT_PROM;
float ALTURA[1000],ALTO,ALT_PROM;
intI,REBOTE,POSICION,ARRIBA;
int I,REBOTE,POSICION,ARRIBA;
main()
main()
{{
system("cls");
system("cls");
/*/*llamar
llamara alas
lasfunciones
funciones*/*/
inciso_a();
inciso_a();
while(ALTO>0)
while(ALTO>0)
{{
inciso_b();
inciso_b();
inciso_c();
inciso_c();
inciso_d();
inciso_d();
break;/*/*romper
break; romperelelciclo
ciclowhile
while*/*/
}}/*
/*fin
findel
delwhile
while*/*/
}} /*
/*fin
finde
dela
lafuncion
funcionmain()
main()*/
*/
/*
/*--------------------------------------
--------------------------------------*/
*/
/*
/*definicion
definicionde
delas
lasfunciones
funciones*/
*/
void
voidinciso_a()
inciso_a()
{{
system("cls");
system("cls");
REBOTE=0;
REBOTE=0;
ALTO=1;
ALTO=1;
printf("Dame
printf("Damelalaaltura
alturainicial
inicialde
dedonde
dondese
sedeja
dejacaer
caerla
lapelota,
pelota,en
enmetros\n");
metros\n");
scanf("%f",&ALTO);
scanf("%f",&ALTO);
if(ALTO>0)
if(ALTO>0)
{{
do{
do{
REBOTE=REBOTE+1;
REBOTE=REBOTE+1;
ALTO=ALTO*2.0/3.0;
ALTO=ALTO*2.0/3.0;
ALTURA[REBOTE]=ALTO;
ALTURA[REBOTE]=ALTO;
}while(ALTO>0.01);
}while(ALTO>0.01);
/*
/*imprimir
imprimirtodos
todoslos
losrebotes
rebotescon
consus
susalturas
alturas*/
*/
printf("\n\nImprimir
printf("\n\nImprimirloslosRebotes
Rebotesyysus
susAlturas\n");
Alturas\n");
printf("Rebote
printf("Rebote Altura\n");
Altura\n");
for(I=1;I<=REBOTE;I++)
{{
printf("%d
printf("%d %8.4f\n",I,ALTURA[I]);
%8.4f\n",I,ALTURA[I]);
}}/*/*fin
findel
delfor
for*/
*/
printf("Respuesta
printf("RespuestaaalalaPregunta
Preguntadel
delinciso
incisoA\n");
A\n");
printf("\nTotal
printf("\nTotaldedeRebotes
Rebotes%d
%dhasta
hastaalcanzar
alcanzaraltura=1
altura=1cm.
cm.oomenor\n",REBOTE);
menor\n",REBOTE);
}}
else
else
{{
printf("La
printf("Laaltura
alturainsertada
insertadaesescero
cerooomenor
menoraacero
cero\n");
\n");
printf("no
printf("notiene
tienesentido
sentidohacer
hacercalculos
calculoscon
coneste
estenumero
numero\n");
\n");
printf("si
printf("sidese
deseintentar
intentarde
denuevo
nuevodebera
deberade
deejecutar,
ejecutar,otra
otravez,
vez,el
elprograma\n");
programa\n");
}}/*
/*fin
findel
delif
if*/*/
printf("\n\n
printf("\n\npulse
pulsecualquier
cualquiertecla
teclapara
paracontinuar");
continuar");
getche();
getche();
return;
return;
}}/*
/*fin
finde
dela
lafuncion
funcioninciso_a
inciso_a*/*/
/*
/*--------------------------------------
--------------------------------------*/
*/
void
voidinciso_b()
inciso_b()
{{
system("cls");
system("cls");
{{
if(ALTURA[I]<=0.50)
if(ALTURA[I]<=0.50)
{{
POSICION=I;
POSICION=I;
I=REBOTE;
I=REBOTE;
}}/*
/*fin
findel
delif
if*/*/
}}/*/*fin
findel
delfor
for*/
*/
printf("Respuesta
printf("Respuestaaala
laPregunta
Preguntadel
delinciso
incisoB\n");
B\n");
printf("\nEl
printf("\nEl rebote
rebote en
en que
que la
la altura
altura es 50 50 cms
cms oo menor es
menor es %d,con
%d,con altura
altura
%8.4f\n",POSICION,ALTURA[POSICION]);
%8.4f\n",POSICION,ALTURA[POSICION]);
printf("\n\n
printf("\n\npulse
pulsecualquier
cualquiertecla
teclapara
paracontinuar");
continuar");
getche();
getche();
return;
return;
}}/*
/*fin
finde
dela
lafuncion
funcioninciso_b
inciso_b*/
*/
/*
/*--------------------------------------
--------------------------------------*/
*/
void
voidinciso_c()
inciso_c()
{{
system("cls");
system("cls");
ALT_PROM=0;
ALT_PROM=0;
{{
ALT_PROM=ALT_PROM+ALTURA[I];
ALT_PROM=ALT_PROM+ALTURA[I];
} }/*/*fin
findel
delfor
for*/*/
ALT_PROM=ALT_PROM/REBOTE;
ALT_PROM=ALT_PROM/REBOTE;
printf("Respuestaa alalaPregunta
printf("Respuesta Preguntadeldelinciso
incisoC\n");
C\n");
printf("Laaltura
printf("La alturaPromedio
Promedioeses%8.4f\n",ALT_PROM);
%8.4f\n",ALT_PROM);
printf("\n\npulse
printf("\n\n pulsecualquier
cualquiertecla
teclapara
paracontinuar");
continuar");
getche();
getche();
return;
return;
} }/*/*fin
findedelalafuncion
funcioninciso_c
inciso_c*/*/
/*/*--------------------------------------
--------------------------------------*/*/
voidinciso_d()
void inciso_d()
{{
system("cls");
system("cls");
ARRIBA=0;
ARRIBA=0;
{{
if(ALTURA[I]>ALT_PROM)
if(ALTURA[I]>ALT_PROM)
{{
ARRIBA=ARRIBA+1;
ARRIBA=ARRIBA+1;
} }/*/*fin
findel
delifif*/*/
} }/*/*fin
findel
delfor
for*/*/
printf("Respuestaa alalaPregunta
printf("Respuesta Preguntadeldelinciso
incisoD\n");
D\n");
printf("Laaltura
printf("La alturaPromedio
Promedioeses%8.4f\n",ALT_PROM);
%8.4f\n",ALT_PROM);
printf("TotaldedeRebotes
printf("Total Rebotes%d\n",REBOTE);
%d\n",REBOTE);
printf("Numerodederebotes
printf("Numero rebotessuperior
superioralalpromedio:
promedio:%d\n",ARRIBA);
%d\n",ARRIBA);
printf("\n\npulse
printf("\n\n pulsecualquier
cualquiertecla
teclapara
pararegresar
regresara alalapantalla
pantalladedeedicion");
edicion");
getche();
getche();
return;
return;
} }/*/*fin
findedelalafuncion
funcioninciso_d
inciso_d*/*/
7.2 PROBLEMAS PROPUESTOS: Arreglos de Memoria Unidimensionales

Problema 7.6. Realice un programa que imprima la tabla de multiplicar de cualquier nmero.
Problema 7.7. Realice un programa que haga la bsqueda secuencial de un nmero en una lista de N nmeros
e imprima si fue encontrado o no. Suponga que los elementos de la lista se pueden repetir, si se repite imprima
el nmero de veces que est repetido.
Problema7.8. Realice un programa que sume los elementos de dos listas de nmeros y guarde los valores en
una tercera lista.
Problema 7.9. Utilice Funciones Definidas por el Usuario sin Parmetros. En dos arreglos unidimensionales
se tiene la siguiente informacin de N personas. En el primero, se tiene la altura en metros. En el segundo, se
tiene el peso en kilogramos.
En un tercer arreglo unidimensional deber calcular el ndice de Masa Corporal (IMC) segn la
siguiente frmula. IMC=Peso/ Altura2
En un cuarto arreglo unidimensional deber almacenar el resultado de acuerdo al IMC segn la
siguiente tabla:
IMC Resultado
Menos de 19 Bajo en Peso
19 a 25 Peso Normal
25 a 30 Sobre Peso
Mayor de 30 Obesidad
a) Elabore un programa que determine e imprima el ndice de Masa Corporal (IMC) promedio.
b) Determine e imprima cuntas y cules personas estn por encima o igual al promedio, y
cuntas y cules por debajo del mismo.
c) Determine e imprima en cuntas personas pertenecen a cada categora y el porcentaje que
representan del total.
7.3 ARREGLOS DE MEMORIA BIDIMENSIONALES.

Los arreglos bidimensionales permiten contemplar filas y columnas tal como sucede una matriz
matemtica como en el siguiente ejemplo:
-25 30 89 -45
12 90 -25 50
-70 -36 79 -81
63 42 78 -27
La matriz de posiciones sera la siguiente, considere (Filas, Columnas)
1,1 1,2 1,3 1,4

2,1 2,2 2,3 2,4
3,1 3,2 3,3 3,4
4,1 4,2 4,3 4,4
En el ejemplo anterior tenemos una matriz con dimensin de 4 por 4, pero como ya sabemos pueden
ser de N por N.
Problema 7.10: Para ver un ejemplo de la forma como se manejan los arreglos bidimensionales haremos un
programa que sume los elementos de la diagonal principal de la matriz (prog7-11.c). Para el caso de la matriz
presentada como ejemplo, los elementos que forman parte de la diagonal principal son: -25 + 90 + 79 - 27 =
117, las posiciones que ocupan dichos elementos son (1,1) (2,2) (3,3) y (4,4). Es importante notar que en este
programa estamos usando for() anidados.
Funcin main
Funcin carga_matriz
Funcin suma_diagonal
Funcin imprimir_resultado
/* prog7-10.c */
/* prog7-10.c */
#include <stdio.h> /* suma la diagonal principal de una matriz */
#include <stdio.h> /* suma la diagonal principal de una matriz */
void carga_matriz();
void carga_matriz();
void suma_diagonal();
void suma_diagonal();
void imprime_resultado();
void imprime_resultado();
int Matriz[10][10], I, J, N, SUMA, fila, columna;
int Matriz[10][10], I, J, N, SUMA, fila, columna;
main()
main()
{
{
clrscr();
clrscr();
/* llamada a las funciones */
/* llamada a las funciones */
carga_matriz();
carga_matriz();
suma_diagonal();
suma_diagonal();
imprime_resultado();
imprime_resultado();
/* ------------------------------------------- */
/* ------------------------------------------- */
void carga_matriz()
void carga_matriz()
{
{
clrscr();
clrscr();
printf("Dame la dimension de la matriz \n");
printf("Dame la dimension de la matriz \n");
scanf("%d",&N);
scanf("%d",&N);
for(I=1;I<=N;I++)
for(I=1;I<=N;I++)
{
{
for(J=1;J<=N;J++)
for(J=1;J<=N;J++)
{
{
printf("Dame el elemento[%d,%d] \n",I,J);
printf("Dame el elemento[%d,%d] \n",I,J);
scanf("%d",&Matriz[I][J]);
scanf("%d",&Matriz[I][J]);
} /* fin del for(J=1;J<=N;J++) */
} /* fin del for(J=1;J<=N;J++) */
} /* fin del for(I=1;I<=N;I++) */
} /* fin del for(I=1;I<=N;I++) */
return;
return;
} /* fin de la funcion carga_matriz */
} /* fin de la funcion carga_matriz */
/* ------------------------------------------- */
/* ------------------------------------------- */
void suma_diagonal()
void suma_diagonal()
{
{
SUMA=0;
SUMA=0;
for(I=1;I<=N;I++)
for(I=1;I<=N;I++)
{
{
for(J=1;J<=N;J++)
for(J=1;J<=N;J++)
{
{
if(I==J)
if(I==J)
{
{
SUMA=SUMA+Matriz[I][J];
SUMA=SUMA+Matriz[I][J];
} /* fin del if(I==J) */
} /* fin del if(I==J) */
} /* fin del for(J=1;J<=N;J++) */
} /* fin del for(J=1;J<=N;J++) */
} /* fin del for(I=1;I<=N;I++) */
} /* fin del for(I=1;I<=N;I++) */
return;
return;
} /* fin de la funcion suma_matriz */
} /* fin de la funcion suma_matriz */
/* ------------------------------------------- */
/* ------------------------------------------- */
void imprime_resultado()
void imprime_resultado()
{
{
system("cls");
system("cls");
fila=5;
fila=5;
for(I=1;I<=N;I++)
for(I=1;I<=N;I++)
{
{
columna=5;
columna=5;
for(J=1;J<=N;J++)
for(J=1;J<=N;J++)
{
{
//gotoxy(columna,fila);
//gotoxy(columna,fila);
printf("%d",Matriz[I][J]);
printf("%d",Matriz[I][J]);
columna=columna+10;
columna=columna+10;
} /* fin del for(J=1;J<=N;J++) */
} /* fin del for(J=1;J<=N;J++) */
printf("\n");
printf("\n");
fila=fila+1;
fila=fila+1;
}} /*
/* fin
fin del
del for(I=1;I<=N;I++)
for(I=1;I<=N;I++) */
*/
printf("\n
printf("\n \n
\n La
La suma
suma de
de la
la diagonal
diagonal principal
principal es
es %d\n",SUMA);
%d\n",SUMA);
printf("Pulse
printf("Pulse cualquier
cualquier tecla
tecla para
para continuar
continuar \n");
\n");
getche();
getche();
return;
return;
}} /*
/* fin
fin de
de imprime_resultado
imprime_resultado */
*/
Problema 7.11. Realizar el siguiente programa con funciones sin parmetros. En un arreglo bidimensional de
30x6 se tiene almacenadas las calificaciones de treinta alumnos en seis exmenes diferentes. Realice un
programa que obtenga lo siguiente.
a) El promedio de calificaciones de los treinta alumnos en los seis exmenes.
b) El alumno o alumnos que obtuvieron la mayor calificacin en el tercer examen, en cualquier
caso deber imprimir cuantos alumnos fueron.
c) El examen en el que el promedio del grupo fue el ms alto.
d) Cuntos alumnos estn aprobados y cuntos reprobados as como el porcentaje que
representa.
/*
/* prog7-11.c
prog7-11.c */
*/
#include
#include <stdio.h>
<stdio.h>
/*
/* declaracion
declaracion de
de funciones
funciones */
*/
void
void leer_datos();
leer_datos();
void
void inciso_a();
inciso_a();
void
void inciso_b();
inciso_b();
void
void inciso_c();
inciso_c();
void
void inciso_d();
inciso_d();
/*
/* declaracion
declaracion de
de variables
variables globales
globales */
*/
int
int I,
I, J,
J, FILA,
FILA, COLUMNA,
COLUMNA, EXAMENES,
EXAMENES, ALUMNOS,MAYORES[10];
ALUMNOS,MAYORES[10];
int
int CONTAR,POSICION;
CONTAR,POSICION;
float
float CAL[10][10],
CAL[10][10], PROMEDIO[10],MAYOR,PROM_EX[10],SUMA;
PROMEDIO[10],MAYOR,PROM_EX[10],SUMA;
float
float APROBADOS,REPROBADOS,PORC_APROBADOS,
APROBADOS,REPROBADOS,PORC_APROBADOS, PORC_REPROBADOS;
PORC_REPROBADOS;
main()
main()
{{
system("cls");
system("cls");
/*
/* llamada
llamada aa las
las funciones
funciones */
*/
leer_datos();
leer_datos();
inciso_a();
inciso_a();
inciso_b();
inciso_b();
inciso_c();
inciso_c();
inciso_d();
inciso_d();
}} /*
/* fin
fin de
de la
la funcion
funcion main()
main() */
*/
/*
/* -------------------------------------------
------------------------------------------- */
*/
/*
/* definicion
definicion de
de funciones
funciones */
*/
void
void leer_datos()
leer_datos()
{{
system("cls");
system("cls");
printf("Cuantos
printf("Cuantos Alumnos
Alumnos son?
son? \n");
\n");
scanf("%d",&ALUMNOS);
scanf("%d",&ALUMNOS);
printf("Cuantos
printf("Cuantos Examenes
Examenes son?
son? \n");
\n");
scanf("%d",&EXAMENES);
scanf("%d",&EXAMENES);
for(I=1;I<=ALUMNOS;I++)
{{
system("cls");
system("cls");
printf("Dame
printf("Dame las
las Calificaciones
Calificaciones del
del Alumno
Alumno ## %d\n",I);
%d\n",I);
for(J=1;J<=EXAMENES;J++)
{{
do{
do{
printf("Dame
printf("Dame la
la calififacion
calififacion del
del Examen
Examen %d\n",J);
%d\n",J);
scanf("%f",&CAL[I][J]);
scanf("%f",&CAL[I][J]);
if(CAL[I][J]<0 || CAL[I][J]>100)
if(CAL[I][J]<0 || CAL[I][J]>100)
{if(CAL[I][J]<0 || CAL[I][J]>100)
{ printf("Calificacion Invalida,");
printf("favor de insertar
printf("Calificacion otro numero\n");
Invalida,");
} /*printf("favor
fin del if */de insertar otro numero\n");
}while(CAL[I][J]<0 || CAL[I][J]>100);
} /* fin del if */
} /* }while(CAL[I][J]<0
fin del for(J=1;J<=EXAMENES;J++) */
|| CAL[I][J]>100);
} /*}fin del for(I=1;I<=ALUMNOS;I++) */
/* fin del for(J=1;J<=EXAMENES;J++) */
printf("\n\nPulse cualquier tecla para*/
} /* fin del for(I=1;I<=ALUMNOS;I++) continuar\n");
getche();
printf("\n\nPulse cualquier tecla para continuar\n");
return;
getche();
} /* fin de la funcion leer_datos */
return;
} /* fin de la funcion leer_datos */
/* ------------------------------------------- */
void inciso_a()
/* ------------------------------------------- */
{void inciso_a()
{ system("cls");
SUMA=0;
system("cls");
SUMA=0;
{for(I=1;I<=ALUMNOS;I++)
{for(J=1;J<=EXAMENES;J++)
{ SUMA=SUMA+CAL[I][J];
} /* SUMA=SUMA+CAL[I][J];
fin del for(J=1;J<=EXAMENES;J++) */
PROMEDIO[I]=SUMA/EXAMENES;
} /* fin del for(J=1;J<=EXAMENES;J++) */
SUMA=0;
PROMEDIO[I]=SUMA/EXAMENES;
} /* fin del for(I=1;I<=ALUMNOS;I++) */
SUMA=0;
printf("Promedios por Alumno\n");
printf("Promedios por Alumno\n");
{ printf(" EX%d\t",J);
} /*printf("
fin del for(J=1;J<=EXAMENES;J++)*/
EX%d\t",J);
printf("\tPromedio\n");
} /* fin del for(J=1;J<=EXAMENES;J++)*/
printf("\tPromedio\n");
printf("%8.2f",CAL[I][J]);
{
printf("%8.2f",CAL[I][J]);
printf("\tAlumno #%d=%8.2f\n",I,PROMEDIO[I]);
} /*printf("\tAlumno
fin del for(I=1;I<=ALUMNOS;I++) */
#%d=%8.2f\n",I,PROMEDIO[I]);
printf("\n\nPulse cualquier tecla para
} /* fin del for(I=1;I<=ALUMNOS;I++) */continuar\n");
getche();
printf("\n\nPulse cualquier tecla para continuar\n");
return;
getche();
} /* fin de la funcion inciso_a */
return;
} /* fin de la funcion inciso_a */
/* ------------------------------------------- */
void inciso_b()
/* ------------------------------------------- */
{void inciso_b()
{ /* tercer examen */
J=3;
/* tercer examen */
MAYOR=CAL[1][J];
J=3;
MAYOR=CAL[1][J];
{ if(CAL[I][J]>MAYOR)
{if(CAL[I][J]>MAYOR)
{ MAYOR=CAL[I][J];
} /*MAYOR=CAL[I][J];
fin del if() */
} /* }fin
/*del
finfor(I=1;I<=ALUMNOS;I++)
del if() */ */
{ if(CAL[I][J]==MAYOR)
{if(CAL[I][J]==MAYOR)
{ MAYOR=CAL[I][J];
CONTAR=CONTAR+1;
MAYOR=CAL[I][J];
MAYORES[CONTAR]=I;
CONTAR=CONTAR+1;
} /* MAYORES[CONTAR]=I;
fin del if() */
} /* }
fin
/*del
finfor(I=1;I<=ALUMNOS;I++)
del if() */ */
printf("Alumnos
printf("Alumnoscon conlalacalificacion
calificacionmas
masAlta
AltaenenelelTercer
TercerExamen\n");
Examen\n");
for(I=1;I<=CONTAR;I++)
for(I=1;I<=CONTAR;I++)
{{
printf("AlumnoNumero
printf("Alumno Numero%d\n",MAYORES[I]);
%d\n",MAYORES[I]);
} }/*/*fin
findeldelfor(I=1;I<=CONTAR;I++)
for(I=1;I<=CONTAR;I++)*/*/
printf("\n\nPulsecualquier
printf("\n\nPulse cualquiertecla
teclapara
paracontinuar\n");
continuar\n");
getche();
getche();
return;
return;
} }/*/*fin
findedelalafuncion
funcioninciso_b
inciso_b*/*/
/*/*-------------------------------------------
-------------------------------------------*/*/
voidinciso_c()
void inciso_c()
{{
SUMA=0;
SUMA=0;
{{
{{
PROM_EX[J]=PROM_EX[J]+CAL[I][J];
PROM_EX[J]=PROM_EX[J]+CAL[I][J];
} }/*/*fin
findel
delfor(J=1;J<=EXAMENES;J++)
for(J=1;J<=EXAMENES;J++)*/*/
} }/*/*fin
findel
delfor(I=1;I<=ALUMNOS;I++)
for(I=1;I<=ALUMNOS;I++)*/*/
{{
PROM_EX[J]=PROM_EX[J]/EXAMENES;
PROM_EX[J]=PROM_EX[J]/EXAMENES;
printf("Promedioenenelelexamen
printf("Promedio examen#%d
#%d= =%8.2f\n",J,PROM_EX[J]);
%8.2f\n",J,PROM_EX[J]);
} }/*/*fin
findel
delfor
forfor(J=1;J<=EXAMENES;J++)
for(J=1;J<=EXAMENES;J++)*/*/
MAYOR=PROM_EX[1];
MAYOR=PROM_EX[1];
{{
if(PROM_EX[I]>MAYOR)
if(PROM_EX[I]>MAYOR)
{{
MAYOR=PROM_EX[I];
MAYOR=PROM_EX[I];
POSICION=I;
POSICION=I;
} }/*/*fin
findel
delif()
if()*/*/
} }/*/*fin
findel
printf("ElExamen
printf("El Examendel
delpromedio
promediomasmasalto
altoeses%d%dcon
con%8.2f\n",POSICION+1,MAYOR);
%8.2f\n",POSICION+1,MAYOR);
printf("\n\nPulsecualquier
printf("\n\nPulse cualquiertecla
teclapara
paracontinuar\n");
continuar\n");
getche();
getche();
return;
return;
} }/*/*fin
findedelalafuncion
funcioninciso_c
inciso_c*/*/
/*/*-------------------------------------------
-------------------------------------------*/*/
voidinciso_d()
void inciso_d()
{{
system("cls");
system("cls");
{{
if(PROMEDIO[I]>=70)
if(PROMEDIO[I]>=70)
{{
APROBADOS=APROBADOS+1;
APROBADOS=APROBADOS+1;
}}
else
else
{ { REPROBADOS=REPROBADOS+1;
REPROBADOS=REPROBADOS+1;
} }/*/*fin
findel
delif()
if()*/*/
} }/*/*fin
findel
PORC_APROBADOS=APROBADOS/ALUMNOS*100;
PORC_APROBADOS=APROBADOS/ALUMNOS*100;
PORC_REPROBADOS=REPROBADOS/ALUMNOS*100;
PORC_REPROBADOS=REPROBADOS/ALUMNOS*100;
printf("Aprobados = =%8.2f
printf("Aprobados %8.2f Porcentaje
PorcentajeAprobados=%8.2f\n",APROBADOS,PORC_APROBADOS);
Aprobados=%8.2f\n",APROBADOS,PORC_APROBADOS);
printf("Reprobados= =%8.2f
printf("Reprobados %8.2f Porcentaje
PorcentajeReprobados=%8.2f\n",REPROBADOS,PORC_REPROBADOS);
Reprobados=%8.2f\n",REPROBADOS,PORC_REPROBADOS);
printf("\n\nPulse cualquier tecla para volver a la pantalla de edicion \n");
printf("\n\nPulse cualquier tecla para volver a la pantalla de edicion \n");
getche();
getche();
return;
} /* return;
fin de la funcion inciso_d */
} /* fin de la funcion inciso_d */
7.4 PROBLEMAS PROPUESTOS: Arreglos de Memoria Bidimensionales
Problema 7.12: Realice un programa que sume los elementos de la diagonal secundaria de una matriz.
Problema 7.13: Realice un programa que sume los elementos centrales de una matriz.
Problema 7.14: Realice un programa que sume los elementos perifricos de una matriz.
Problema 7.15: Realice un programa que sume los elementos de la matriz triangular superior.
Problema 7.16: Realice un programa que sume los elementos de la matriz triangular inferior.
Problema 7.17: Realice un programa que sume dos matrices y guarde el resultado en una tercera matriz.
Problema 7.18: Realice un programa que determine cuntos elementos pares y cuntos impares hay en una
matriz y cuntos de ellos son Cero.
Problema 7.19: Realice un programa que suma las filas y las columnas de una matriz. Se deber imprimir la
sumatoria por fila y por columnas.
Problema 7.20: Realice un programa que determine el elemento mayor de una matriz as como su posicin
Problema 7.21: Realice un programa que multiplique matrices.
Problema 7.22: Realice un programa que resuelva un problema de ecuaciones simultaneas a travs del mtodo:
Gauss-Jordan y Montante.
Problema 7.23. En este programa utilice variables enumeradas. En un arreglo bidimensional de 12x3 se tiene
los costos de produccin de tres departamentos: dulces, bebidas y conservas. Los costos de produccin
corresponden a cada mes de ao anterior.
Escriba un programa que pueda proporcionar la siguiente informacin.
e) En qu mes se registro el mayor costo de produccin de dulces?.
f) Promedio anual de los costos de produccin de bebidas.
g) En qu mes se registr el mayor costo de produccin en bebidas y en que mes el de menor
costo.
h) Cul fue el rubro que tuvo el menor costo de produccin en diciembre?
Captulo #8
Funciones definidas por el usuario con Parmetros
Hasta el momento, al nombre de todas las funciones que han sido definidas por el usuario se les
antepone la palabra void, esto en la declaracin y la definicin de la funcin; en la llamada de la funcin esta
palabra se omite. Cuando se escribe void, se est diciendo que la funcin no regresa valores, por eso al final de
la funcin se escribe return. La funcin main () tambin puede llevar void y funciona igual.
La palabra void puede ser sustituida por cualquier tipo de datos: int, char, float, etc. Esto indica el
tipo de datos que la funcin puede regresar., y cuando la funcin devuelve valores se escribe return y entre
parntesis la variable que est regresando.
Durante el presente capitulo se presentarn una serie de programas que intentarn que se vea de forma
prctica el paso de parmetros entre funciones.
En el programa prog8-1.c con la declaracin de la funcin: char minusc_a_mayusc (char minusc);

se puede deducir que esta funcin regresa una variable de tipo carcter y lleva como parmetro la variable
minusc que tambin es de tipo carcter. En la definicin de la funcin se puede observar que hay una variable
local llamada c1 misma que va a tomar el valor que tenga la variable minusc. Tambin, dentro de esta funcin
aparece un if() simplificado: c2=(c1>='a' && c1<='z') ?('A'+c1-'a'):c1;. Si este if() simplificado no se logra
entender no se preocupe, ms adelante podr hacerlo.
Por ltimo, observe que al final de la definicin de la funcin aparece la instruccin return(c2) donde
se indica que c2 contiene el equivalente en mayscula de la letra que se puls y este valor de regresa para ser
depositado su valor en la variable mayusc.
/* prog8-1.c */
#include<stdio.h>
#include<conio.h>
/* convertir un caracter en minuscula a mayscula utilizando una funcion definida por el usuario */
main()
{
char minusc,mayusc;
/* declaracion de la funcion */
char minusc_a_mayusc(char minusc);
printf("Por favor, introduce una letra minuscula : ");
scanf("%c",&minusc);
/* llamada a la funcion */
mayusc=minusc_a_mayusc(minusc);
printf("\nLa mayuscula equivalente es %c\n\n",mayusc);

getche();
} /* termina la funcion main() */
/* ---------------------------------------------------- */
/*definicion de la funcion */
char minusc_a_mayusc(char c1)
{
char c2;
c2=(c1>='a' && c1<='z') ?('A'+c1-'a'):c1;
return(c2);
} /* termina funcion minusc_a_mayusc */
En el Programa prog8-2.c, con la declaracin de la funcin int mximo (int a, int b); se puede
observar que esta funcin regresa una variable de tipo entero y lleva como parmetros a las variables a y b
que tambin son de tipo entero. Ya en la definicin de la funcin: int mximo (int x, int y), estn las variables
x y y, donde x tomar el valor de a y y tomar el valor de b. Dentro de esta funcin hay un if()
simplificado que en esta ocasin es ms fcil de entender que en el ejemplo anterior. La variable z es una
variable local a la funcin maximo(), misma que tomar el valor del nmero mayor de los dos valores que
hayan sido introducidos. Observe que la funcin puede pero no regresa ningn valor, esto es fcilmente
deducible porque el final de la funcin maximo() slo esta: return 0;.
/* prog8-2.c */
#include<stdio.h>
#include<conio.h>
/* determina el valor maximo de dos valores */

main()
{
int a,b;
int maximo(int a,int b);
printf("dame el valor de a : \n");

scanf("%d",&a);
printf("dame el valor de b : \n");
scanf("%d",&b);
/* llamada a la funcion maximo */

maximo(a,b);
getche();
} /* termina la funcion main() */
/* ---------------------------------------------- */
/* definicion de la funcion */
int maximo(int x,int y)
{
/* variable local a la funcion maximo */
int z;
z=(x>=y) ? x:y;
printf("\n\nValor maximo = %d\n",z);
return 0;
} /* termina funcion maximo */
Diagrama.
En el programa prog8-3.c tenemos que con la declaracin de la funcin: long int factorial(int n); se
puede deducir que esta funcin regresa un valor largo entero y lleva como parmetro a la variable n que es
de tipo entero. Con la definicin de la funcin: long int factorial(int m) podemos ver que la variable m
tomar el valor de variable n. La funcin calcular el factorial del nmero mismo que se almacenar en la
variable prod, y con la instruccin return(prod) el valor de prod se regresar y se almacenar en la variable
res.
/* prog8-3.c */
#include<stdio.h>
main()
{
int n;
long int res;
long int factorial(int n);
printf("Dame n para factorial : ");

scanf("%d",&n);
/* llamada a la funcion factorial */

res=factorial(n);
printf("\nel factorial de %d = %ld\n\n",n,res);
getche();
} /* termina funcion main() */
/* ----------------------------------- */
/*definicion de la funcion */
long int factorial(int m)
{
int i;
long int prod=1;
if(m > 1)
for(i=2 ; i<=m ; ++i)
prod *=i;
return(prod);
} /* termina funcion factorial */
Diagrama.
Observe en el programa pro8-4.c como la funcin maximo() se llama la primera vez y se lleva como
parmetros a las variables a y b, y el nmero mayor de estos dos se guarda en d, despus se llama la
segunda ocasin y se lleva como parmetros a c y d, y se imprime el valor mas grande de los tres valores
que inicialmente se haban tecleado. Observe que a diferencia a lo que pas en programa prog8-2.c, ahora la
funcin maximo() si regresa un valor, lo podemos deducir porque ahora, al final de la funcin aparece:
return(z);.
/* prog8-4,c */
#include<stdio.h>
/* determinar la mayor de tres cantidades enteras */
main()
{
int a,b,c,d;
/* leer las tres cantidades enteras */
printf("dame el valor de a : \n");
scanf("%d",&a);
printf("dame el valor de b : \n");
scanf("%d",&b);
printf("dame el valor de c : \n");
scanf("%d",&c);
/* calcular y visualisar el valor maximo */

d=maximo(a,b);
printf("\n\nmaximo = %d\n",maximo(c,d));
getche();
} /* termina funcion main() */
/* ------------------------------------------------ */
maximo (x,y) /* determinar el mayor de dos cantidades enteras */
int x,y;
{
int z;
z=(x>=y) ? x:y;
return(z);
} /* termina funcion maximo */
Diagrama.
En el programa prog8-5.c observe como la variable a es un variable local a la funcin main() pero
tambin es una variable local a la funcin modificar(). Corra este programa y vea el comportamiento de esta
variable dentro y fuera de la funcin main().
/* prog8-5.c */
#include<stdio.h>
/* ver comportamiento de una variable global y una local */
main()
{
int a=2;
printf("\n a = %d (desde main, antes de llamar a la funcion)",a);
/* llamada a la funcion modificar*/

modificar(a);
printf("\n a = %d (desde main, despues de llamar a la funcion)",a);
getche();
}/* fin de la funcion main() */
/* ------------------------------------------------- */
modificar(a)
int a;
{
a*=3;
printf("\n a = %d (desde la funcion, despues de modificar el valor)",a);
return;
} /* termina funcion modificar */
Diagrama.
RECURSIVIDAD
Se llama recursividad a un proceso mediante el que una funcin se llama as misma de forma repetida,
hasta que se satisface alguna determinada condicin. El proceso se utiliza para computaciones recursivas en las
que cada accin se determina en funcin de un resultado anterior. Se pueden escribir en esta forma muchos
problemas iterativos.
La recursividad es una tcnica de programacin importante. Se utiliza para realizar una llamada a una funcin
desde la misma funcin. Como ejemplo til se puede presentar el clculo de nmeros factoriales.
La recursividad y la iteracin estn muy relacionadas, cualquier accin que pueda realizarse con la
recursividad puede realizarse con iteracin y viceversa. Normalmente, un clculo determinado se prestar a
una tcnica u otra, slo necesita elegir el enfoque ms natural o con el que se sienta ms cmodo.
Podemos distinguir dos tipos de recursividad:
Directa: Cuando un subprograma se llama a s mismo una o ms veces directamente.
Indirecta: Cuando se definen una serie de subprogramas usndose unos a otros.
Un algoritmo recursivo consta de una parte recursiva, otra iterativa o no recursiva y una condicin de
terminacin. La parte recursiva y la condicin de terminacin siempre existen. En cambio la parte no
recursiva puede coincidir con la condicin de terminacin.
Se deben satisfacer dos condiciones para que se pueda resolver un problema recursivamente. Primero,
el problema se debe escribir en forma recursiva, y segundo, la sentencia del problema debe incluir una condicin
de fin.
En el programa prog8-6.c se puede ver un programa que utiliza recursividad, es decir una funcin que
se llama as misma. Observe como en la declaracin de la funcin void inverso(void); la funcin no regresa
valores y adems se lleva una argumento vaco (void).
/* prog8-6.c */
#include<stdio.h>
#define EOLN '\n'
/* leer una linea de texto y escrbirla en orden inverso
utilizando recursividad */
main()
{
void inverso(void);
printf("introduce una linea de texto\n");
/* llamada a la funcion inverso */

inverso();
getche();
}/* fin de la funcion main() */
/* ------------------------------------ */
void inverso(void)
/* leer una linea de caracteres y escribirla en orden inverso */
{
char c;
if((c=getchar())!=EOLN)
{
inverso(); /* la funcion se llama asi misma */
putchar(c);
} /* fin del if((c=getchar())!=EOLN) */
return;
} /* termina funcion inverso */
Problema 8.1: Realice el programa que calcule el factorial de un nmero utilizando recursividad.
Problema 8.2: Realice el programa que calcule la serie de Fibonacci utilizando recursividad.
Captulo #9
Apuntadores, Tipos de Datos definidos
por el usuario y Archivos de Datos.
9.1 APUNTADORES
El entendimiento y correcto uso de los apuntadores es crtico para la creacin correcta de la mayora
de los programas de C. Hay tres razones para ello: Primera, los apuntadores proporcionan los medios mediante
los que las funciones modifican sus argumentos de la llamada. Segunda, se pueden utilizar para soportar las
rutinas de asignacin dinmica de C. Tercera, se pueden sustituir por arreglos de memoria en muchas
situaciones para incrementar la eficiencia.
Adems de ser una de las caractersticas ms poderosas de C, los apuntadores son tambin una de las
ms peligrosas. Por ejemplo, usando apuntadores sin inicializar o fuera de control se puede provocar la cada
del sistema. Quiz peor, es ms comn el usar incorrectamente los apuntadores, que provocar errores que son
difciles de encontrar.
9.1.1 Conceptos Bsicos

Dentro de la memoria de la computadora cada dato almacenado ocupa una o ms celdas contiguas de
memoria, por ejemplo palabras o bytes adyacentes. El nmero de celdas de memoria requeridas para almacenar
un dato depende de su tipo. As, un carcter (char) ser normalmente almacenado en un byte (8 bits) de
memoria; un entero (int) usualmente necesita dos bytes contiguos; un nmero real de simple presicin (float)
cuatro bytes contuiguos, y una cantidad en doble precisin (double) puede requerir 8 bytes contiguos.
Antes de seguir adelante es necesario recalcar que la memoria de una computadora est organizada por
celdas adyacentes numeradas consecutivamente, desde el principio hasta el fin del rea de memoria. La mayora
de la compuadtoras usan el sistema de numeracin hexadecimal para asignar las direcciones de celdas de
memoria consecutivas, aunque algunas computadoras usan el sistema octal de numeracin.
De esta forma, supongamos que v es una variable que representa que representa un determinado dato.
El compilador automticamente asignar celdas de memoria para este dato. El dato puede ser accedido si
conocemos su localizacin (la direccin) de la primera celda de memoria. La direccin de memoria de v puede
ser determinada mediante la expresin &v, donde & es un operador unario, llamado operador de direccin,
que proporciona la direccin del operando. En la siguiente expresin vamos a asignar a la variable pv la
direccin de v.
pv = & v
Esta nueva variable pv es un apuntador a v, desde su posicin hasta el lugar donde v est almacenada
en memoria. Se debe recordar que pv representa la direccin de v y no su valor. La relacin de pv y v est
ilustrada en la siguiente figura.
Direccin de v Valor de v
pv v
El dato representado por v (el dato almacenado en las celdas de memoria de v) puede ser accedido
mediante la expresin *pv, donde * es un operador unario, llamado operador de indireccin, que opera slo
sobre una variable apuntador. Por tanto *pv y v representan el mismo dato (el contenido de las mismas
celdas de memoria). Adems, si escribimos pv=&v y u=pv , entonces u y v representan el mismo valor, por
ejemplo, el valor de v puede ser indirectamente asignado a u (se asume que u y v estn declaradas del mismo
tipo).
En resumen, un apuntador es una variable que contiene una direccin de memoria. Normalmente esta
direccin es una posicin de otra variable en la memoria. Aunque podra ser la direccin de un puerto o de la
RAM de propsito general, tal como la memoria intermedia de vdeo (buffer). Si una variable contiene la
direccin de otra variable se dice que la primera variable apunta a la segunda.
9.1.2 Declaracin de Apuntadores
Los apuntadores como cualquier otra variable, deben ser declarados antes de ser usados dentro de un
programa en C. Sin embargo, la interpretacin de una declaracin de apuntador es un poco diferente de la
declaracin de otras variables. Cuando una variable apuntador es definida, el nombre de la variable debe ir
precedido por un asterisco (*). Este identifica que la variable es un apuntador. El tipo de dato que aparece en la
declaracin se refiere al tipo de objeto del apuntador, esto es, el tipo de dato que se almacena en la direccin
representada por el apuntador, en vez del apuntador mismo.
Observe el programa prog9-1.c.
/* prog9-1.c */
#include <stdio.h>
#include<conio.h>
main()
{
/* declaracion de variables */
int u;
int v;
int *pu; /* apuntador a un entero */
int *pv; /* apuntador a un entero */
u=3; /* asigna a u el valor de 3 */
pu=&u; /* asigna direccion de u a pu */
v=*pu; /* asina valor de u a v */
pv=&v; /* asigna direccion de v a pv */
printf("\n \n u=%d &u=%d pu=%d *pu=%d \n",u,&u,pu,*pu);

printf("\n \n v=%d &v=%d pv=%d *pv=%d \n",v,&v,pv,*pv);
getche();
Con el programa prog9-2.c observe como se realiza una operacin matemtica comn y corriente, y
despus una operacin matemtica usando un apuntador.
/* prog9-2.c */
#include<stdio.h>
#include<conio.h>
main()
{
int u1, u2;
int v;
int *pv; /* variable apuntador */
v=3;
u1=2*(v+5); /* expresion matematica comun */
pv=&v; /* pv apunta a v */
u2=2*(*pv+5); /* expresion matematica equivalente usado el apuntador*/
printf(" u1=%d u2=%d \n",u1,u2);
getche();
En el programa prog9-3.c, observe como la variable v cambia de valor por medio de una reasignacin
indirecta, es decir, utilizando el apuntador.
/* prog9-3.c */
#include<stdio.h>
#include<conio.h>
main()
{
int v;
int *pv; /* variable apuntador */
v=3;
pv=&v; /* pv apunta a v */
printf(" *pv=%d v=%d \n",*pv,v);
*pv=7; /* reasignacion indirecta */

printf(" *pv=%d v=%d \n",*pv,v);
getche();
9.2 TIPOS DE DATOS DEFINIDOS POR EL USUARIO

Lenguaje C permite crear cinco clases diferentes de tipos de datos personalizados:
1. Tipo de Datos Estructurado. Es un grupo de variables bajo un mismo nombre.
2. Tipo de Datos de Campo Bit. Es una variacin del estructurado y permite un acceso fcil a los
bits de una palabra.
3. Tipo de Datos Unin. Habilita para definir el mismo trozo de memoria como dos o ms tipos
diferentes de variables.
4. Tipo de Datos de Enumeracin. Es una lista de smbolos
5. El ltimo tipo de datos se crea usando: typedef., y simplemente crea un nuevo nombre para un
tipo existente.
Como prembulo al manejo de archivos de datos nos enfocaremos es este ltimo, utilizando typedef.
Como dijimos anteriormente. Lenguaje C permite definir nuevos nombres de datos explcitamente usando la
palabra clave typedef. Realmente no est creando una nueva clase datos, sino definiendo un nuevo nombre para
un tipo existente. Los siguientes son ejemplos de cmo se puede declarar este tipo de datos.
typedef struct{
long int matricula;
char nombre[15];
char ap_paterno[15];
char ap_materno[15];
} alumno;
alumno universidad;
Con el anterior ejemplo podemos decir que la estructura se llama alumno (tambin se dice que el
nombre del registro es alumno) y tiene las siguientes variables: matricula, nombre, ap_paterno y
ap_materno. Enseguida se declar a la variable universidad como del tipo alumno. En este caso se dice que
la variable universidad es una variable de tipo registro.
Otro ejemplo sera:

typedef struct{
long int No_cuenta;
char nombre_cliente[15];
char calle[30];
int numero;
char colonia[30];
char ciudad[30];
char estado[30];
} direccion;
direccion cliente;
La estructura se llama direccion con las siguientes variables: No_cuenta, nombre_cliente, calle,
numero, colonia, ciudad y estado. Enseguida, se declar la variable cliente del tipo de direccion. Como
anteriormente se hizo la aclaracin la variable cliente es una variable tipo registro.
En el programa pro9-4.c, la estructura se llama jornada con las siguientes variables: Num_Empleado,
Nombre, Horas_Trab y Num_Depto. As mismo, la variable tipo registro se llama empleado. En este
programa se puede ver como se utiliz la variable tipo registro. Dentro de los scanf() se escribi la variable tipo
registro, despus un punto y por ltimo un nombre de variable de la estructura, por ejemplo:
empleado.Num_Empleado.
Nota el programa prog9-4.c es el mismo que prog6-2.c en el que se muestra el uso de typedef
/* prog9-4.c */
#include <stdio.h>
#include <string.h>
#include<conio.h>
void inicializar();
void proceso();
void sueldos();
void departamentos();
/* declaracin de variables globales */
typedef struct{
long int Num_Empleado;
char Nombre[30];
float Horas_Trab;
int Num_Depto;
} jornada;
jornada empleado;
char Descripcion[30];
int Empleados, Contador;
int Cantidad1, Cantidad2, Cantidad3;
float Horas_Norm, Horas_Ext, Sueldo;
float Acum1, Acum2,Acum3;
main()
{
/* llamadas a la funcion */
inicializar();
proceso();
departamentos();
/* ----------------------------------------- */
void inicializar()
{
Cantidad1=0;
Cantidad2=0;
Cantidad3=0;
Acum1=0;
Acum2=0;
Acum3=0;
return;
}/* fin de la funcion inicializar() */
/* ----------------------------------------- */
void proceso()
{
printf("Cuantos empleados son? \n");

scanf("%d",&Empleados);
for(Contador=1;Contador<=Empleados;Contador++)
{
printf("Introduzca los datos del empleado: %d \n",Contador);

printf("Dame el numero de Empleado \n");
scanf("%ld",&empleado.Num_Empleado);
printf("Dame el nombre del Empleado \n");
scanf(" %[^\n]",empleado.Nombre);
printf("Dame las horas trabajadas \n");
scanf("%f",&empleado.Horas_Trab);
do{
printf("Dame el numero de Departamento <1 al 3> \n");
scanf("%d",&empleado.Num_Depto);
if(empleado.Num_Depto<1 || empleado.Num_Depto>3)
{
printf("\n \n -ERROR! -Departamento NO Existe! \n");
printf("Pulse un numero de departemento existente <1 al 3>\n");
}
else
{
sueldos(); /* llamada a la funcion sueldo */
}
}while(empleado.Num_Depto<1 || empleado.Num_Depto>3);
} /* fin del for */
return;
} /* fin de la funcion proceso() */
/* ----------------------------------------- */
void sueldos()
{
if(empleado.Horas_Trab>48)
{
Horas_Norm=48;
Horas_Ext=empleado.Horas_Trab - 48;
}
else
{
Horas_Norm=empleado.Horas_Trab;
Horas_Ext=0;
} /* fin if(Hrs_Trab>48) */
switch(empleado.Num_Depto)
{
case 1:
{
Sueldo=Horas_Norm*10+Horas_Ext*18;
strcpy(Descripcion,"Ventas");
Cantidad1=Cantidad1+1;
Acum1=Acum1+Sueldo;
break;
case 2:
{
strcpy(Descripcion,"Produccion");
Acum2=Acum2+Sueldo;
break;
case 3:
{
strcpy(Descripcion,"Sistemas");
Acum3=Acum3+Sueldo;
break;
printf("Numero de Empleado: %ld \n",empleado.Num_Empleado);

printf("Nombre del Empleado: %s \n",empleado.Nombre);
printf("Del Departamento : %s \n",Descripcion);
printf("Tiene un sueldo de $%8.2f \n",Sueldo);
getche();
return;
} /* fin de la funcion sueldos */
/* ----------------------------------------- */
void departamentos()
{
printf("\n \n El departamento de Ventas tiene %d empleados \n",Cantidad1);

printf("Los cuales ganan en conjunto $%10.2f pesos\n",Acum1);
printf("\n \n El departamento de Produccion tiene %d empleados \n",Cantidad2);
printf("\n \n El departamento de Sistemas tiene %d empleados \n",Cantidad3);
getche();
return;
} /* fin de la funcion departamentos */
9.3 ARCHIVOS DE DATOS.

Muchas aplicaciones requieren leer informacin de un perifrico auxiliar de almacenamiento. Tal
informacin se almacena en el perifrico en la forma de un archivo de datos. Por tanto, los archivos de datos
permiten almacenar informacin de modo permanente, para ser accedida o alterada cuando sea necesario.
En C existen dos tipos de archivos de datos: Archivos secuenciales de datos (o estndar) y archivos
orientados a sistema (o de bajo nivel). Generalmente es ms fcil trabajar con archivos de datos secuenciales
que con los orientados a sistema, y por tanto son los ms usados.
Los archivos de datos secuenciales se pueden dividir en dos categoras: Los archivos que contienen
caracteres consecutivos y los archivos sin formato.
En este apartado nos enfocaremos a los archivos secuenciales de datos que contienen caracteres
consecutivos.
9.3.1 Apertura y Cierre de un Archivo

Cuando se trabaja con archivos secuenciales de datos, el primer paso es establecer un rea de
buffer, donde la informacin se almacena temporalmente mientras se est transfiriendo entre la memoria de
la computadora y el archivo de datos. Esta rea de buffer permite leer y escribir informacin del archivo ms
rpidamente de lo que sera posible de otra manera. El rea de buffer se establece escribiendo
FILE *ptvar;
donde FILE (escribe con maysculas) es un tipo especial de estructuras que establece el rea de buffer y ptvar
es la variable apuntador que indica el principio de esta rea.
Un archivo de datos debe ser abierto antes de ser creado o procesado. Esto asocia el nombre del archivo
con el rea de buffer (con el archivo secuencial). Tambin se especifica cmo se va a usar el archivo: slo
para lectura, slo para escritura, para lectura/escritura, en el que se permite las dos operaciones.
Para abrir un archivo se usa la funcin de biblioteca fopen(). Esta funcin se escribe tpicamente como:
ptvar = fopen(nombre-archivo,tipo-archivo);
donde nombre-archivo y tipo-archivo son cadenas que representan, respectivamente, el nombre del archivo y
la manera en la que el archivo ser utilizado.
Tipo-archivo Significado
r Abrir un archivo existente slo para lectura
w Abrir un nuevo archivo slo para escritura. Si existe el archivo ser
destruido y creado uno nuevo en su lugar.
a Abrir un archivo existente para aadir informacin. Se crear uno
nuevo sino existe.
r+ Abrir un archivo existente para lectura y escritura.
w+ Abrir un archivo nuevo para escritura y lectura. Si existe el archivo
ser destruido y creado uno nuevo en su lugar.
a+ Abrir un archivo existente para leer y aadir informacin. Se crear un
archivo nuevo sino existe.
Cuando ya no se va trabajar con los archivos, estos deben cerrase con:
fclose(puntero del archivo)
Las funciones ms comunes para manipular un archivo son:
fopen() : Abre un archivo.

fclose() : Cierra un archivo.
fwrite() : Escribe en el archivo.
fread() : Lee el archivo.
feof(): Detecta el final de archivo.
sizeof() : Mide la longitud del registro del archivo.
unlink() : borra un archivo.
rename() : La cambia nombre a un archivo.
9.3.2 Creacin de un Archivo

Un archivo debe crearse antes de ser procesado. Un archivo secuencial de datos puede crearse de dos
formas distintas. Una es crear el archivo directamente, usando un procesador de textos o un editor. La otra es
escribir un programa que introduzca informacin en la computadora y la escriba en un archivo.
En este caso nos enfocaremos en el segundo caso, es decir, crearemos los archivos desde un
programa y desde el programa introduciremos datos al archivo.
Los programas prog9-5.c y prog9-6.c son complementarios; el primero inserta datos en el archivo y
el segundo los imprime en la pantalla.
En el programa prog9-5.c podemos ver lo siguiente:
1. El nombre de la estructura (tambin se le dice nombre del registro) es alumno.
2. Las variables de la estructura alumno son: matricula, nombre[30], carrera[4];
3. ADVERTENCIA!, Cuando inserte el nombre recuerde que no debe escribir mas de 29
caracteres porque lenguaje C necesita el ltimo espacio para un carcter de control. Si no respeta
esto se producir un error en el programa. Lo mismo sucede con carrera, puede escribir las
cerreras de la siguiente forma. IAS, IEC, ICC, IMA etc. slo tres caracteres.
4. El nombre de la variable tipo registro es fime.
5. La variable apuntador al archivo se llama fpt.
6. fpt=fopen("c:datos.dat","w") con esta instruccin se abre el archivo, donde c: es el disco donde
se va a grabar el archivo. datos.dat es el nombre del archivo y w significa que el archivo se abre
para slo escritura.
7. fwrite(&fime,sizeof(alumno),1,fpt). Con esta instruccin estamos escribiendo en el archivo,
donde con &fime estamos accesando la direccin de la variable tipo registro. Con sizeof(alumno)
se indica el tamao del bloque que ser escrito en el archivo, en este caso el tamao del bloque
ser igual a la longitud de alumno. El # 1 significa que se escribir slo un bloque en el archivo
y con ftp estamos diciendo que se escriba el archivo datos.dat.
8. La funcin strset() se utiliz para limpiar los valores anteriores de las variables de cadena de
caracteres.
/* prog9-5.c */
#include<stdio.h>
#include<string.h>
#include<conio.h>
/* programa de almacena datos en un archivo de datos */
typedef struct {
long int matricula;
char nombre[30];
char carrera[4];
} alumno; /* nombre de la estructura */
/* apuntador al archivo */
FILE *fpt;
main()
{
char OPCION[2];
/* declaracion de la variable tipo registro */
alumno fime;
/* abrir el archivo */
fpt=fopen("c:datos.dat","w");
do{
printf("dame la matricula : ");
scanf("%ld",&fime.matricula);
printf("dame el nombre : ");
scanf(" %[^\n]",fime.nombre);
printf("dame la carrera : ");
scanf("%s",fime.carrera);
/* escribir en el archivo */
fwrite(&fime,sizeof(alumno),1,fpt);
strset(fime.nombre,' ');
strset(fime.carrera,' ');
printf("Deseas continuar insertando datos al archivo? \n");
printf("Pulsa la letra 'S' para continuar o cualquier otra para terminar\n");
scanf(" %[^\n]",OPCION);
}while(!strcmp(OPCION,"S") || !strcmp(OPCION,"s"));
/* cerrar el archivo */
fclose(fpt);
Los datos que insertamos con el programa prog9-5.c, podrn ser vistos en el monitor con el programa
prog9-6.c.
Con este programa destacaremos lo siguiente:
1. fpt=fopen("c:datos.dat","r"), con esta instruccin se abre el archivo para slo lectura
2. fread(&fime,sizeof(alumno),1,fpt), con esta instruccin se lee el archivo, donde &fime es la
direccin de la variable tipo registro, sizeof(alumno) indica el tamao del bloque que se leer del
disco, en este caso el tamao del bloques ser igual a la longitud de alumno, el #1 significa que
se lee un solo bloque y fpt es el apuntador al archivo.
3. do{}while(!feof(fpt)); este ciclo indica que se lea el archivo hasta que se terminen los registros.
El significado de feof() es End Of File, o sea, final de archivo. Entre parntesis se escribe la
variable que apunta al archivo.
/* prog9-6.c */
#include<stdio.h>
#include<string.h>
#include<conio.h>
/* Imprime los datos almacenados en un archivos de datos */
typedef struct {
long int matricula;
char nombre[30];
char carrera[4];
} alumno;
FILE *fpt;
main()
{
int linea;
/* declaracion de la variable tipo registro */
alumno fime;
/* abir el archivo */
fpt=fopen("c:datos.dat","r");
printf("Matricula Nombre Carrera\n");

linea=6;
/* leer el archivo */
fread(&fime,sizeof(alumno),1,fpt);
do{
printf("%ld",fime.matricula);
printf("%s",fime.nombre);
printf("%s",fime.carrera);
linea=linea+1;
/* leer el archivo */
}while(!feof(fpt));
getche();
/* cerrar el archivo */
fclose(fpt);
} /* fin de la funcin main()*/
Captulo #10
Aplicacin de los Archivos de Datos.
La intencin de este ltimo captulo es presentar a detalle algunas aplicaciones de los archivos de
datos. Este captulo est compuesto por tres partes:
1. En la primera parte haremos programas sencillos que involucren archivos de datos.
2. En la segunda parte haremos programa de corte de control.
3. En la tercer parte haremos, primero, un sencillo programa de altas y consultas, y finalmente se
dar el cdigo de un programa de Altas, Bajas y Cambios.
10.1 PROGRAMAS QUE INVOLUCRAN ARCHIVOS DE DATOS.
Problema 10.1:
Realice un programa que genere un archivo de salida a partir de un archivo de entrada el cual contiene:
Archivo de Entrada:
Matricula, Nombre del Estudiante, Calificacin del Primer Parcial y Calificacin del Segundo Parcial
Archivo de Salida:
Matricula, Nombre del Estudiante, Calificacin del Primer Parcial, Calificacin del Segundo Parcial
y Promedio.
Ejemplo:
Archivo de Entrada
Matricula Nombre Primer Parcial Segundo Parcial
595689 Ana Snchez 90 50
897831 Saul Rodrguez 100 70
859645 Carmen Salas 70 80
985656 Gloria Zamora 50 60
917845 Sonia Meja 80 90
Archivo de Salida
Matricula Nombre Primer Parcial Segundo Parcial Promedio
595689 Ana Snchez 90 50 70
897831 Sal Rodrguez 100 70 85
859645 Carmen Salas 70 80 75
985656 Gloria Zamora 50 60 55
917845 Sonia Meja 80 90 85
/* prog10-1.c */
#include<stdio.h>
#include<conio.h>
/* calcula el promedio de alumnos, programa que usa archivos */ /* estructura del archivo
de entada*/
typedef struct{
long int matricula_e;
char nombre_e[30];
int primer_p_e;
int segundo_p_e;
} calificacion; /* nombre del registro de salida*/
/* esctructura del archivo de salida */

typedef struct{
long int matricula_s;
char nombre_s[30];
int primer_p_s;
int segundo_p_s;
int promedio_s;
} promedio; /* nombre del registro de salida */
/* punteros al archivo de entrada y de salida */

FILE *fentrada,*fsalida;
calificacion entrada; /* variable tipo registro del archivo de entrada */

promedio salida; /* variable tipo registro del archivo de salida */
main()
{
void menu();
void iniciar();
void altas(calificacion entrada);
void reporte(calificacion entrada, promedio salida);
void imprime(promedio salida);
/* llamada a la funcion menu() */

menu();
/* ---------------------------------------- */
void menu()
{
int opcion;
do{
printf("M E N U P R I N C I P A L\n");
printf("1.-I N I C I A R \n");
printf("2.-A L T A S \n");
printf("3.-R E P O R T E \n");
;printf("4.-S A L I D A \n"); printf("cual opcion deseas? : ");
scanf("%d",&opcion);
switch(opcion)
{
case 1:
/* borra el archivo de entrada anterior, si se desea */
iniciar();
break;
case 2:
/* altas de registros */
altas(entrada);
break;
case 3:
/* da el resultado del proceso */
reporte(entrada, salida);
break;
} /* fin switch */
}while(opcion>0 && opcion<4);
} /* fin fin de la funcion menu() */
/* ---------------------------------------- */
void iniciar()
{
int op;
printf("I N I C I A R\n");
printf("esta rutina borar el archivo de entrada anterior\n");
printf("deseas borrarlo? 1.-si; 2.-no : ");
scanf("%d",&op);
if(op==1)
{
/* abrir archivo de entrada */
fentrada=fopen("c:califica.dat","r");
if(fentrada==NULL)
{
printf("No puedo borrar el archivo porque NO existe \n");
getche();
}
else
{
fclose(fentrada);
/* borra archivo */
unlink("c:califica.dat");
} /* fin del if(fentrada==NULL) */
} /* fin del if(op==1) */
} /* fin de la funcion iniciar() */
/* ---------------------------------------- */
void altas(calificacion entrada)
{
int op;
fentrada=fopen("c:califica.dat","a+");
if(fentrada==NULL)
{
printf("El archivo de entrada NO existe ; favor de revisar su proceso \n");
} /* fin if */
if(fentrada!=NULL)
{
do{
printf("A L T A S \n");
scanf("%ld",&entrada.matricula_e);
scanf(" %[^\n]",entrada.nombre_e);
printf("dame la califiacion del primer parcial : ");
scanf("%d",&entrada.primer_p_e);
printf("dame la calificacion del segundo parcial : ");
scanf("%d",&entrada.segundo_p_e);
/* escribe en el archivo de entrada */

fwrite(&entrada,sizeof(calificacion),1,fentrada);
printf("deseas continuar 1.-si; 2.-no : ");

scanf("%d",&op);
}while(op==1);
} /* fin del if(fentrada!=NULL) */
fclose(fentrada);
} /* fin de la funcion altas() */
/* ---------------------------------------- */
void reporte(calificacion entrada, promedio salida)
{
int promedio_w;
fentrada=fopen("c:califica.dat","r"); /* abrir archivo de entrada */
fsalida=fopen("c:promedio.sal","w"); /* abrir archivo de entrada */
if(fentrada==NULL)
{
printf("El archivo de entrada NO existe; favor de revisar su proceso \n");
} /* fin if */
if(fentrada!=NULL)
{
/* leer archivo de entrada */
fread(&entrada,sizeof(calificacion),1,fentrada);
do{
promedio_w=(entrada.primer_p_e+entrada.segundo_p_e)/2;
/* pasar los valores de las variables de entrada y trabajo
a las variables de salida */
salida.matricula_s=entrada.matricula_e;
strcpy(salida.nombre_s,entrada.nombre_e);
salida.primer_p_s=entrada.primer_p_e;
salida.segundo_p_s=entrada.segundo_p_e;
salida.promedio_s=promedio_w;
/* escribir en el archivo de salida */

fwrite(&salida,sizeof(promedio),1,fsalida);

fread(&entrada,sizeof(calificacion),1,fentrada);
}while(!feof(fentrada));
fclose(fentrada);
fclose(fsalida);
imprime(salida);
printf("\nPulse cualquier tecla para continuar \n");
getche();
} /* fin de la funcion reporte() */
/* ---------------------------------------- */
void imprime(promedio salida)
{
int linea;
fsalida=fopen("c:promedio.sal","r"); /* abrir archivo de entrada */
if(fsalida==NULL)
{
printf("no puedo abrir archivo; favor de revisar su proceso \n");
} /* fin if */
/* poner encabezados */
printf("Matricula Nombre 1er Parcial 2do Parcial Promedio\n");
linea=3;
/* leer archivo de salida */
fread(&salida,sizeof(promedio),1,fsalida);
do{
printf("%ld ",salida.matricula_s);
printf("%s ",salida.nombre_s);
printf("%d ",salida.primer_p_s);
printf("%d ",salida.segundo_p_s);
printf("%d ",salida.promedio_s);
linea++;
fread(&salida,sizeof(promedio),1,fsalida);
}while(!feof(fsalida));
fclose(fsalida);
} /* fin de la funcion imprime */
Problema 10.2:
Realice un programa que genere un archivo de salida a partir de un archivo de entrada el cual
contiene:
Archivo de Entrada:
Nombre del Empleado, Horas Trabajadas y Tarifa por hora
Archivo de Salida:
Nombre del Empleado, Pago Bruto, IMSS y Pago Neto
Notas.
a) Pago Bruto =(Horas Trabajadas)*(tarifa por hora)
b) IMSS = 4.8% del Pago bruto
c) Pago Neto = (Pago Bruto)-(IMSS)
Ejemplo:
Archivo de Entrada
Nombre del Empleado Horas Trabajadas Tarifa por Hora
JUAN MOLINA 30 $4.50
DORA VELEZ 40 $3.90
SARA CASTRO 45 $4.70
SAUL HIDALGO 39 $3.50
CLARA MORA 46 $4.20
Archivo de Salida
Nombre del Empleado Pago Bruto IMSS Pago Neto
JUAN MOLINA $135 $6.48 $128.52
DORA VELEZ $156 $7.48 $148.52
SARA CASTRO $211.5 $10.15 $201.35
SAUL HIDALGO $136.5 $6.55 $129.95
CLARA MORA $193.20 $9.27 $183.93
********************************************************************
Problema 10.3:
Realice un programa que genere un archivo de salida a partir de un archivo de entrada el cual contiene:
Archivo de Entrada:
Nmero de Factura, Nombre del cliente e Importe de venta
Archivo de Salida:
Nmero de Factura, Nombre del Cliente, Importe de Venta, Porcentaje de descuento y el Importe de
descuento neto
Notas:
a) Si el importe de Venta excede de $100 pesos se dar un 3% de Descuento, si el importe de
Venta es menor o igual $100 pesos se dar un 2% de Descuento
b) Importe de descuento = (Importe de venta)%(Porcentaje de descuento)
c) Importe de descuento neto=(importe de Venta)-(importe de descuento)
Ejemplo:
Archivo de Entrada
Num.Factura Nombre Venta
1596 RAFAEL SOSA $350
1852 PERLA VELA $90
1956 ROSA MENDEZ $260
1784 RAUL ZAVALA $55
2106 LAURA VAZQUEZ $195
Archivo de Salida
Num.Factura Nombre Venta %Descuento Impte.Dto.Neto
1596 RAFAEL SOSA $350 3 $339.50
1852 PERLA VELA $90 2 $ 88.20
1956 ROSA MENDEZ $260 3 $252.20
1784 RAUL ZAVALA $55 2 $ 53.90
2106 LAURA VAZQUEZ $195 3 $189.15
***********************************************************************
Problema 10.4:
contiene:
Archivo de Entrada:
Nombre del Estudiante, Nmero de crditos
Archivo de Salida:
Nombre del estudiante, Nmero de crditos y Colegiatura
Nota.- Si un estudiante toma 12 crditos o menos la colegiatura es de $15 pesos por cada crdito, si
toma ms de 12 crditos la colegiatura es de $150 pesos
Ejemplo:
Archivo de Entrada
Nombre del Estudiante Crditos
GLORIA MEJIA 15
CARLOS PEDRAJA 10
SONIA LOPEZ 12
SANTIAGO ZAPATA 11
CARMEN SALAS 13
Archivo de Salida
Nombre del Estudiante Crditos Colegiatura
GLORIA MEJIA 15 $150
CARLOS PEDRAJA 10 $150
SONIA LOPEZ 12 $180
SANTIAGO ZAPATA 11 $165
CARMEN SALAS 13 $150
*******************************************************************************
Problema 10.5:
contiene:
Archivo de Entrada. Nombre del Empleado, Horas Trabajadas y Tarifa por hora
Archivo de Salida.- Nombre del Empleado y el sueldo
Notas.-
a) Sueldo = (Horas normales)*(tarifa por hora)+(horas extra)*(3.5)
b) Las horas extra son aquellas que pasan de 40
Ejemplo:
Archivo de Entrada
Nombre del Empleado Horas Trabajadas Tarifa por Hora
JUAN MOLINA 30 $4.50
DORA VELEZ 40 $3.90
SARA CASTRO 45 $4.70
SAUL HIDALGO 39 $3.50
CLARA MORA 46 $4.20
Archivo de Salida
Nombre del Empleado Sueldo
JUAN MOLINA $135
DORA VELEZ $156
SARA CASTRO $205.50
SAUL HIDALGO $136.50
CLARA MORA $189
************************************************************************
Problema 10.6:
Realice un programa que genere un archivo de salida a partir de un archivo de entrada, el cual
contiene:
Archivo de Entrada.- Nombre del empleado, Cdigo (1.-Salario, 2.-Sueldo, 3.-Comisin), Importe 1 e importe
2
Archivo de Salida.- Nombre del empleado y el importe de lo ganado
Notas
a) Si es salario, multiplique el importe 1 por el importe 2 para obtener el importe de lo ganado
b) Si es sueldo, el importe de lo ganada es igual al importe 1
c) Si es comisin, multiplique el importe 1 por el importe 2 y agregue un 8% adicional para
obtener el importe de lo ganado
Ejemplo:
Archivo de Entrada
Nombre del Empleado Cdigo Importe 1 Importe 2
RAUL GARZA 2 $530 $150
AIDA SANCHEZ 1 $50 $15
HILDA IBARRA 3 $45 $10
YAZMIN IGLESIAS 2 $630 $20
EDGAR PEREZ 3 $30 $25
Archivo de Salida
Nombre del Empleado Impte Ganado
RAUL GARZA $530
AIDA SANCHEZ $750
HILDA IBARRA $486
YAZMIN IGLESIAS $630
EDGAR PEREZ $810
10.2 PROGRAMAS DE CORTE DE CONTROL

Muchas son las situaciones de la vida cotidiana que manejamos a travs de corte de control, por
ejemplo, los recibos de telfono, de luz, de agua, el estado de cuenta bancario, una factura etc. todos ellos,
computacionalmente hablando, son cortes de control. Por eso, vamos en estos momentos a plantear problemas
y a resolverlos por este mtodo.
Problema 10.8: CORTE01.C

Realice un programa que genere un archivo de salida a partir de un archivo de entrada la cual
contiene:
Archivo de Entrada.- Nmero de Cuenta, Nombre del cliente e Importe
Archivo de Salida.- Nmero de Cuenta, Nombre del cliente e Importe total
Nota.- El archivo de entrada est completamente validado y clasificado en forma ascendente por grupos de
nmero de cuenta.
Ejemplo:
Archivo de Entrada
Nmero de cuenta Nombre del cliente Importe
595689 KARLA GARZA $590
615849 IRMA ORTIZ $965
615849 IRMA ORTIZ $540
658912 JAVIER GALICIA $170
Archivo de Salida
Nmero de Cuenta Nombre del Cliente Importe Total
595689 KARLA GARZA $1,490
615849 IRMA ORTIZ $1,505
658912 JAVIER GALICIA $1,970
Advertencia: La solucin a este problema est en el programa corte01.c. Cuando inserte los datos debe
insertarlos en forma ordenada tal como se muestra en el ejemplo, de lo contrario el programa no funcionar
adecuadamente
/* corte01.c */
#include<stdio.h>
#include<conio.h>
/*programa de corte de control #1 */
/* formato del archivo de entada*/

typedef struct{
long int cuenta_e;
long int impte_e;
} cuenta;
/* nombre del registro de salida*/
/* formato del archivo de salida */

typedef struct{
long int cuenta_s;
long int total_s;
} total;
/* nombre del registro de salida */
/* punteros al archivo de entrada y de salida */

FILE *fentrada,*fsalida;
cuenta entrada;
/* variable tipo registro del archivo de entrada */
total salida;
/* variable tipo registro del archivo de salida */
main()
{
void menu();
void iniciar();
void altas(cuenta entrada);
void reporte(cuenta entrada, total salida);
void imprime(total salida);
/* llamada a la funcion menu() */

menu();
/* ---------------------------------------- */
void menu()
{
int opcion;
do{
printf("1.-I N I C I A R \n");
printf("2.-A L T A S \n");
printf("3.-R E P O R T E \n");
printf("4.-S A L I D A \n");
printf("cual opcion deseas? : ");
switch(opcion)
{
case 1:
/* borra el archivo de entrada anterior, si se desea */
iniciar();
break;
case 2:
/* altas de registros */
altas(entrada);
break;
case 3:
/* da el resultado del proceso */
reporte(entrada, salida);
break;
} /* fin switch */
} /* fin fin de la funcion menu() */
/* ---------------------------------------- */
void iniciar()
{
int op;
printf("esta rutina borar el archivo de entrada anterior\n");
printf("deseas borrarlo? 1.-si; 2.-no : ");
scanf("%d",&op);
if(op==1)
{
fentrada=fopen("c:importe.dat","r"); /* abrir archivo de entrada */
if(fentrada==NULL)
{
printf("No puedo borrar el archivo porque NO existe \n");
printf("Pulse cualquier tecla para continuar \n");
getche();
}
else
{
fclose(fentrada);
/* borra archivo */
unlink("c:importe.dat");
} /* fin del if(fentrada==NULL) */
} /* fin if */
/* ---------------------------------------- */
void altas(cuenta entrada)
{
int op;
fentrada=fopen("c:importe.dat","a+");
if(fentrada==NULL)
{
printf("El archivo de entrada NO existe ; favor de revisar su proceso \n");
} /* fin if */
if(fentrada!=NULL)
{
do{
printf("A L T A S \n");
printf("dame el numero de cuenta : ");
scanf("%ld",&entrada.cuenta_e);
printf("dame el importe : ");
scanf("%ld",&entrada.impte_e);
fwrite(&entrada,sizeof(cuenta),1,fentrada);
printf("deseas continuar 1.-si; 2.-no : ");
scanf("%d",&op);
}while(op==1);
fclose(fentrada);
/* ---------------------------------------- */
void reporte(cuenta entrada, total salida)
{
long int cuenta_w,total_w=0;
fentrada=fopen("c:importe.dat","r"); /* abrir archivo de entrada */
fsalida=fopen("c:importe.sal","w"); /* abrir archivo de entrada */
if(fentrada==NULL)
{
printf("El archivo de entrada NO existe; favor de revisar su proceso \n");
} /* fin if */
if(fentrada!=NULL)
{
fread(&entrada,sizeof(cuenta),1,fentrada);
cuenta_w=entrada.cuenta_e;
do{
if(cuenta_w==entrada.cuenta_e)
{
total_w=total_w+entrada.impte_e;
fread(&entrada,sizeof(cuenta),1,fentrada);
}
else
{
/* se realiza el corte de control */
/* pasar los valores de la variables de trabajo a las
variable de salida */
salida.cuenta_s=cuenta_w;
salida.total_s=total_w;

fwrite(&salida,sizeof(total),1,fsalida);
/* re-inicializar las variables de trabajo */

cuenta_w=entrada.cuenta_e;
total_w=0;
} /* fin if */
}while(!feof(fentrada));
/* se realiza el ultimo corte de control */
/* pasar los valores de la variables de trabajo a las
variable de salida */
salida.cuenta_s=cuenta_w;
salida.total_s=total_w;

fwrite(&salida,sizeof(total),1,fsalida);
fclose(fentrada);
fclose(fsalida);
imprime(salida);
} /* fin del if */
printf("\nPulse cualquier tecla para continuar \n");
getche();
} /* fin de la funcion reporte() */
/* ---------------------------------------- */
void imprime(total salida)
{
int linea;
fsalida=fopen("c:importe.sal","r");
if(fsalida==NULL)
{
printf("no puedo abrir archivo; favor de revisar su proceso \n");
} /* fin if(fsalida==NULL) */
/* poner encabezados */
printf("numero de cuenta importe total\n");
linea=3;
fread(&salida,sizeof(total),1,fsalida);
do{
printf("%ld ",salida.cuenta_s);
printf("%ld ",salida.total_s);
linea++;
fread(&salida,sizeof(total),1,fsalida);
}while(!feof(fsalida));
fclose(fsalida);
} /* fin de la funcion imprime() */
*****************************************************************************
Problema 10.9 : CORTE02.C

contiene:
Archivo de Entrada.- Nmero de vendedor, nombre del vendedor e importe de venta
Archivo de Salida.- Nmero de vendedor, nombre del vendedor y sueldo
Si el importe de venta es menor a $1,000, la comisin es del 5%; Si es mayor o igual a $1,000 y menor
que $3,000, la comisin es del 7% y Si es mayor o igual a $3,000, la comisin es del 10%.
Nota.- El archivo de entrada est completamente validado y clasificado en forma ascendente por grupos
de nmero de vendedor
Ejemplo:
Archivo de Entrada
Nmero de vendedor Nombre del Vendedor Importe de Venta
119 ARTURO SOTO $3,200
119 ARTURO SOTO $1,100
119 ARTURO SOTO $ 900
673 AIDA MATA $5,100
710 SAUL MOLINA $1,500
710 SAUL MOLINA $2,100
Archivo de Salida
Nmero de Vendedor Nombre del Vendedor Sueldo
119 ARTURO SOTO $442
673 AIDA MATA $815
710 SAUL MOLINA $252
****************************************************************************************
Problema 10.10: CORTE03.C
contiene:
Archivo de Entrada: Nmero de Factura, Descripcin del producto, cantidad y precio unitario
Archivo de Salida: Nmero de Factura y Pago
Nota.- El archivo de entrada est completamente validado y clasificado en forma ascendente por grupos
de nmero de factura
Ejemplo:
Archivo de entrada
Num.Factura Descripcin Cantidad Precio unitario
523 PUNTILLAS 2 $4.60
523 LIBRETA SCRIBE 3 $5.90
523 APLIQUE FOX PRO 1 $140
558 MAPA MTY 1 $50
558 PLUMAS BIC 4 $2.50
591 PC WORLD 1 $25
591 PETER NORTON 1 $150
591 LIBRETA SCRIBE 2 $5.90
591 ACCESS FACIL 1 $120
Archivo de Salida
Num. Factura Pago
523 $166.90
558 $ 60.00
591 $306.80
10.3 PROGRAMAS DE ALTAS, BAJAS Y CAMBIOS.
Problema 10.11: Realice un programa que haga una agenda telefnica para guardar los datos en un archivo.
La solucin la puede encontrar en el programa prog10-3.c, cuando haga altas se borrar todos los telfonos
anteriores. Si no desea que esto suceda, abra el archivo, dentro de la funcin altas de la manera:
fpt=fopen("C:phones.bin","a+");
/* prog10-3.c */
#include<stdio.h>
#include<string.h>
#include<conio.h>
/* programa de agenda telefonica con archivo de datos */
typedef struct {
long int telefono;
char nombre[30];
} amigo; /* nombre del regisrto */
FILE *fpt; /* puntero a un archivo */
amigo fime;
/* nombre del registro (amigo) y variable tipo registro (fime) */
/* declaracion de la funciones */
void menu();
void altas(amigo fime);
void ver_telefonos(amigo fime);
main()
{
menu(); /* llamar a la funcion */
/* --------------------------------------- */
void menu()
{
int opcion;
do{
printf("DIRECTORIO TELEFONICO\n");
printf("1.-A L T A S\n");
printf("2.-VER TELEFONOS\n");
printf("3.-SALIDA\n");
do{
printf("cual opcion deseas ? : ");
}while(opcion<1 || opcion>3);
switch(opcion)
{
case 1:
altas(fime);
break;
case 2:
ver_telefonos(fime);
break;
case 3:
printf("hasta luego, muchas gracias\n");
getche();
break;
} /* fin switch */
} while(opcion>0 && opcion<3);
} /* fin de la funcion menu */
/* --------------------------------------- */
void altas(amigo fime)
{
int opcion;
fpt=fopen("C:phones.bin","w");
do{
printf("dame el telefono : ");

scanf("%ld",&fime.telefono);
/* escribir en el archivo */
fwrite(&fime,sizeof(amigo),1,fpt);
strset(fime.nombre,' ');
do{
printf("continuar en altas; 1.-si, 2.-no\n");
if(opcion<1 || opcion>2)
{
printf("opcion invalida; favor de esperar");
printf(" ");
} /* fin if */
}while(opcion<1 || opcion>2);
}while(opcion==1);
fclose(fpt);
} /* fin altas */
/* --------------------------------------- */
void ver_telefonos(amigo fime)
{
int seguir;
fpt=fopen("C:phones.bin","r");
if(fpt==NULL)
{
printf("No puedo mostrar los telefonos porque el archivo NO existe \n");
getche();
} /* fin del if(fpt==NULL) */
if(fpt!=NULL)
{
/* leer archivo */
fread(&fime,sizeof(amigo),1,fpt);
do{
printf("telefono : %ld ",fime.telefono);
printf("nombre : %s\n",fime.nombre);
fread(&fime,sizeof(amigo),1,fpt);
}while(!feof(fpt));
getche();
fclose(fpt);
} /* fin del if(fpt!=NULL */
} /* fin de la funcion ver_telfonos() */
10.3.1 Procesamiento de un Archivo
La mayora de las aplicaciones requieren que se altere el archivo cuando se procesa. Por ejemplo, en
aplicaciones que impliquen el procesado de registros de clientes, se puede desear aadir nuevos registros
al archivo (ya sea al final o entre los registros existentes), o para reordenar los registros. Estos
requerimientos sugieren varias estrategias computacionales distintas.
Por ejemplo, considerar el problema de actualizar los registros dentro de un archivo de datos. Hay varios
enfoques de este problema. Quiz el ms obvio es leer cada registro de un archivo, actualizar el registro y
despus escribir el registro actualizado al mismo archivo. Sin embargo, hay algunos problemas con esta
estrategia. En particular, es difcil leer y escribir datos con formato al mismo archivo sin alterar la
ordenacin de los elementos dentro del archivo. Adems, el conjunto original de registros puede volverse
inaccesible si algo funciona mal durante la ejecucin del programa.
Otro enfoque es trabajar con dos archivos diferentes: un archivo antiguo (fuente) y otro nuevo. Se lee cada
registro dentro del archivo antiguo, se actualiza y se escribe el nuevo archivo. Cuando se han actualizado
todos los registros, se borra o se almacena el archivo antiguo y se renombra el archivo nuevo.
Esta ltima estrategia es la que se utiliza en el siguiente programa ABC.C.
________________________________________________________________________________________
/* ABC.C */
/* programa de Altas, Bajas y Cambios con archivos de datos */
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<ctype.h>
#define CIERTO 1
#define FALSO 0
/* formato del archivo */

typedef struct {
char matricula[8];
char nombre[30];
char carrera[4];
}alumno; /* nombre del registro */
FILE *fpt; /* puntero al archivo */
alumno fime; /* variable tipo registro */
main()
{
void menu();
void iniciar();
alumno altas(alumno fime);
alumno bajas(alumno fime);
alumno cambios(alumno fime);
int buscar(char mat[7]);
int buscar_pantalla(char mat[8]);
void borrar_registro(char mat[8]);
void cambiar_registro(alumno fime,char mat[8]);
int validar_matricula(char mat[8]);
char cambiar_letras(alumno fime,char variable[30]);
void imprime(alumno fime);
/* llamada a la funcion */
menu();
imprime(fime);
/* --------------------------------------------- */
void menu()
{
int opcion;
do{
printf("1.-I N I C I A R\n");
printf("2.-A L T A S\n");
printf("3.-B A J A S\n");
printf("4.-C A M B I O S\n");
printf("5.-S A L I R\n");
printf("cual opcion deseas ? :");
switch(opcion)
{
case 1:
/* borra el archivo anterior, si se desea*/
iniciar();
break;
case 2:
/* altas de alumnos */
altas(fime);
break;
case 3:
/* bajas de alumnos */
bajas(fime);
break;
case 4:
/* cambios de alumnos */
cambios(fime);
break;
} /* fin switch */
} /* fin de la funcion menu() */
/* --------------------------------------------- */
void iniciar()
{
int op;
printf("esta rutina borra el archivo de datos anterior\n");
printf("desea borrarlo? 1.-si,2.-no: " );
scanf("%d",&op);
if(op==1)
{
fpt=fopen("c:abc.bin","w"); /* abrir archvo, se pierde el anterior */
fclose(fpt); /* cerrar archivo */
}/* fin if(op==1) */
/* --------------------------------------------- */
alumno altas(alumno fime)
{
int i,op,no_valido,encontrado; /* encontrado=1 verdadero ; encontardo=0 falso*/
int longitud;
char mat[8],nom[30],car[4]; /* variable mat para buscar en el archivo */
fpt=fopen("c:abc.bin","a+"); /* abrir archivo */
do{
do{
printf("A L T A S\n");
scanf("%s",mat);
no_valido=validar_matricula(mat);
}while(no_valido==CIERTO);
encontrado=buscar(mat); /* llamada a la funcion buscar */
/* busqueda secuencial de un registro */
if(encontrado)
{
printf("M A T R I C U L A E X I S T E N T E\n");
printf("pulse cualquier tecla para continuar \n");
getche();
/* borrar las lineas anteriores */
printf(" \n");
printf(" \n");
}
else
{
strcpy(fime.matricula,mat);
/* cambiar letras a mayusculas */

longitud=strlen(fime.nombre);
for(i=0;i<longitud;i++)
{
fime.nombre[i]=toupper(fime.nombre[i]);
} /* fin for */
printf("dame la carrera : ");

longitud=strlen(fime.carrera);
{
fime.carrera[i]=toupper(fime.carrera[i]);
} /* fin for */
fseek(fpt, 1L, 2); /* poner el puntero al final del archivo*/
fwrite(&fime,sizeof(alumno),1,fpt); /* escribir en el archivo*/
} /* fin if encontrado */
printf("deseas continuar 1.-si, 2.-no : ");
scanf("%d",&op);
strset(fime.matricula,' '); /* borrar basura de matricula */
strset(fime.nombre,' '); /* borrar basura de nombre */
strset(fime.carrera,' '); /* borrar basura de carrera */
}while(op==1);
return(fime);
/* --------------------------------------------- */
int buscar(char matri[8])
{
int buscado;
buscado=0;
rewind(fpt); /* poner puntero al principio del archivo */
do{
fread(&fime,sizeof(alumno),1,fpt); /* leer archivo */
if(!strcmp(fime.matricula,matri))
{
buscado=1; /* si lo encontro se asigna 1 a buscado */
break;
} /* fin if */
}while(!feof(fpt)); /* se repite hasta fin de archivo */
return(buscado);
} /* fin de la funcion buscar() */
/* --------------------------------------------- */
alumno bajas(alumno fime)
{
int op,no_valido,encontrado; /* encontrado=1 verdadero ; encontrado=0 falso*/
char mat[8]; /* variable mat para buscar en el archivo */
fpt=fopen("c:abc.bin","r"); /* abrir archivo solo lectura*/

if(fpt==NULL)
{
printf("no puedo abrir el archivo \n");
} /* fin if */
do{
do{
printf("B A J A S\n");
scanf("%s",mat);
encontrado=buscar_pantalla(mat); /* llamada a la funcion buscar */
if(!encontrado)
{
/* la matricula buscada no existe */
printf("M A T R I C U L A I N E X I S T E N T E\n");
getche();
printf(" \n");
printf(" \n");
}
else
{
/* la matricula buscada si existe */
printf("deseas dar de baja este registro 1.-si, 2.-no : ");
scanf("%d",&op);
/* borrar la linea anterior */
printf(" ");
if(op==1)
{
borrar_registro(mat);
} /* fin op==1 */
scanf("%d",&op);
}while(op==1);
return(fime);
} /* fin bajas */
/* --------------------------------------------- */
void borrar_registro(char matri[8])
{
/* copiado secuencial de registros un archivo a otro */
/* baja fisica de un registro */
FILE *fregistro;
fregistro=fopen("c:abc.new","w"); /* abrir archivo nuevo */
fread(&fime,sizeof(alumno),1,fpt); /* leer registro */
do{
if(strcmp(fime.matricula,matri))
{
fwrite(&fime,sizeof(alumno),1,fregistro);
} /* fin if */
fclose(fregistro);
fclose(fpt);
unlink("c:abc.bin");
rename("c:abc.new","c:abc.bin");
} /* finde la funcion borrar_registros() */
/* --------------------------------------------- */
alumno cambios(alumno fime)
{
int op,no_valido,encontrado; /* encontrado=1 verdadero ; encontrado=0 falso*/
char mat[8]; /* variable mat para buscar en el archivo */
if(fpt==NULL)
{
} /* fin if */
do{
do{
printf("C A M B I O S\n");
scanf("%s",mat);
encontrado=buscar_pantalla(mat); /* llamada a la funcion buscar */
if(!encontrado)
{
/* la matricula buscada no existe */
printf("M A T R I C U L A I N E X I S T E N T E\n");
getche();
printf(" \n");
printf(" \n");
}
else
{
/* la matricula buscada si existe */
printf("deseas cambiar este registro 1.-si, 2.-no : ");
scanf("%d",&op);
/* borrar la linea anterior */
printf(" ");
if(op==1)
{
cambiar_registro(fime,mat);
} /* fin if op==1 */
scanf("%d",&op);
}while(op==1);
return(fime);
} /* fin de la funcion cambios() */
/* ------------------------------------------------- */
void cambiar_registro(alumno fime,char matri[8])
{
/* copiado secuencial de registros de un archivo a otro */
/* baja fisica de un registro */
int op,longitud,i;
char opc;
FILE *fregistro;
/* se inicia el proceso de pasar todos los registros a otro archivo */

fregistro=fopen("c:abc.new","w"); /* abrir archivo nuevo */
do{
if(strcmp(fime.matricula,matri))
{
}
else
{
printf("dame el nuevo nombre : ");
printf(" ");

longitud=strlen(fime.nombre);
{
fime.nombre[i]=toupper(fime.nombre[i]);
} /*fin del for */
printf(" ");
printf("dame la nueva carrera : ");
printf(" ");
longitud=strlen(fime.carrera);
{
fime.carrera[i]=toupper(fime.carrera[i]);
} /* fin del for */
/* escribir cambio */
} /* fin if */
fclose(fregistro);
fclose(fpt);
unlink("c:abc.bin");
rename("c:abc.new","c:abc.bin");
} /* fin cambiar_registro */
/* --------------------------------------------- */
int buscar_pantalla(char matri[8])
{
int buscado;
buscado=0;
do{
if(!strcmp(fime.matricula,matri))
{
buscado=1; /* si lo encontro se asigna 1 a buscado */
printf("nombre : %s",fime.nombre);
printf("carrera : %s",fime.carrera);
break;
} /* fin if */
return(buscado);
} /* fin buscar_pantalla */
/* --------------------------------------------- */
int validar_matricula(char matri[8])
{
int longitud,i,caracter,valido;
caracter=FALSO;
longitud=strlen(matri);
{
if(!isdigit(matri[i]))
{
caracter=CIERTO;
} /* fin if */
} /* fin for */
if(longitud!=7 || caracter==CIERTO)
{
printf("matricula incorrecta\n");
getche();
printf(" \n");
printf(" \n");
printf("la matricula debe ser numerica de 7 digitos\n");
caracter=CIERTO;
getche();
} /* fin if */
return(caracter);
} /* fin de la funcion validar_matricula */
/* --------------------------------------------- */
void imprime(alumno fime)
{
int linea;
fpt=fopen("c:abc.bin","r");
if(fpt==NULL)
{
} /* fin if */
printf("Matricula Nombre Carrera\n");
linea=6;
do{
printf(" %s",fime.matricula);
printf(" %s",fime.nombre);
printf(" %s\n",fime.carrera);
linea=linea+1;
}while(!feof(fpt));
getche();
fclose(fpt);
} /* fin de la funcion imprime() */

Raptor y C

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Raptor y C

Enviado por

Direitos autorais:

Formatos disponíveis

NDICE

C es un lenguaje de programacin estructurado, de alto nivel, flexible y orientado a funciones.

Durante mi estancia como estudiante en la F.I.M.E.-U.A.N.L. aprend a programar en FORTRAN, BASIC

Maestro en Ciencias de Administracin con especialidad en Sistemas

1.2. DEFINICIN DE PROGRAMACIN DE COMPUTADORAS.

1.3. HISTORIA DEL LENGUAJE C

1.4. MTODO A SEGUIR PARA LA SOLUCIN DE PROBLEMAS

1.5. MTODOS PARA LA ELABORACIN DE ALGORITMOS.

1.6. EJECUCIN DE UN PROGRAMA.

Se introducen datos a la memoria RAM (desde el teclado), ah mismo de procesan y posteriormente se

1.7 Instalacin del Dev-C++.

Una vez ejecutado el programa tendremos algo as:

2. Explorador de proyectos y clases e informacin de depuracin.

4. Resultados de la compilacin y controles de depuracin.

Aqu tenemos las opciones de configuracin del IDE y del compilador.

1.8. PASOS PARA EJECUTAR (CORRER) UN PROGRAMA.

2.1. LAS VARIABLES

2.1.1. Tipos de Datos

Los tipos de datos en C son:

Tipo Descripcin Ancho en bits Bytes Rango

2.1.2. Modificadores del Tipo de Datos

Enseguida, se muestra una lista de ejemplo de la forma en cmo se declaran variables.

long int matricula;

2.2. LAS CONSTANTES

Tipo de dato Constante de Ejemplo

2.2.1. Constantes Hexadecimales y Octales

La primer constante hexadecimal es equivalente a 255 en decimal y la segunda constante en octal

2.2.2. Constantes de Cadena

2.2.3. Constantes de Caracteres de Diagonal Invertida

2.3.1. Operadores Aritmticos

Estos operadores se pueden subdividir en unarios (++, - - ) y binarios (+,-,*,/, %)

Ahora bien, estos operadores pueden preceder o seguir al operando, es decir

X=X+1 se puede dar como X++ o ++X

En el primer caso se denomina posincremento y en el segundo caso se denomina preincremento, de esta

2.3.1.1 Reglas para la Evaluacin de Expresiones Aritmticas

La prioridad relativa de los operadores relacionales y lgicos es la siguiente:

2.3.3. Operador de Asignacin

Ejemplo de frmulas matemticas

Fuerza = masa * aceleracion

Ejemplo de ecuaciones matemticas

2.4. EXPRESIONES ARITMTICAS

2.5. ESCRIBIENDO FRMULAS MATEMTICAS EN C

d = b2 4ac d =b*b-4*a*c o d=pow(b,2)-4*a*c

El anterior programa se desglosa de la siguiente manera

3.2. ESPECIFICADORES DE FORMATO

3.3. ENTRADA Y SALIDA DE DATOS.

SINTAXIS: scanf (cadena de control, lista de argumentos);

Por otro lado, para poder visualizar valores de variables en el monitor de la

Aunque esta visualizacin se muestra, generalmente, en el monitor de la computadora tambin puede

SINTAXIS: printf (cadena de control, lista de argumentos);

3.4. EJEMPLOS DE PROGRAMAS CON ENTRADA-SALIDA DE DATOS Y

A continuacin, tenemos el programa prog3-4.c que calcula el rea de un cuadrado.

La frmula para determinar el rea es:

rea = LADOS(LADOS LADO1)(LADOS LADO2)(LADOS LADO3)

donde, LADOS =(LADO1+LADO2+LADO3)/2

Donde V es la velocidad final, g es la gravedad equivalente a 32 pies/seg2 y h es la altura

Finalmente, en el programa prog3-9.c se resuelve el siguiente problema. Un avin que se encuentra

3.5. ENTRADA Y SALIDA DE CARACTERES Y CADENAS DE CARACTERES.

En el ejemplo #1 se realiz una operacin algebraica, en el ejemplo #2 se realiz una concatenacin. De

En el ltimo programa de este captulo se ver el uso de getchar() y getche(), el especificador de

3.7 PROBLEMAS PROPUESTOS.

La programacin estructurada maneja instrucciones selectivas, repetitivas y secuenciales. A estas

4.1 SENTENCIA if()

d = b2 4ac d =bb-4a*c o d=pow(b,2)-4ac

void gotoxy(int x,int y); /Declaracin de funcin gotoxy(x,y)/

printf("\n \n u=%d &u=%d pu=%d pu=%d \n",u,&u,pu,pu);

pv=7; / reasignacion indirecta */