Fundamentos de Programacion

FUNDAMENTOSDE PROGRAMACIN
ESIMEZacatencoIngenieraElctrica
Engenerallosestudiantesnecesitanherramientasbsicasqueloayudenala bsquedayelanlisisdelainformacin,aslograrintegrarsusconocimientos prcticosdeingeniera;paralocuallasherramientasdeprogramacinsonunabase fundamental.
PrimerSemestre Profesores:AlejandraGutirrezReyes EnriqueMartnezRoldn
UNIDAD I INTRODUCCIN A LA PROGRAMACIN
CONTENIDO
Capitulo 1. 1.1. Introduccin a la Programacin Pag. 1 1
Sistemas Operativos 1.1.1. Definicin, caractersticas y funcin de un Sistema Operativo 1.1.2. Anlisis Comparativo de Sistemas Operativos Evolucin de los Lenguajes de Programacin 1.2.1. Definicin, caractersticas y funcin de los Lenguajes de Programacin Interpretes y Compiladores 1.3.1. Definicin de Interpretes y Compiladores Fundamentos de Programacin Estructurada
3
3 3 5 5
1.2. 1.3.
Capitulo 2. 2.1. 2.2.
Estructura General de un Programa Tipos de Datos y Operadores 2.2.1. Tamaos, declaracin y modificadores 2.2.2. Operadores Lgicos, Aritmticos y de Asignacin Funciones de Biblioteca 2.3.1. Funciones de Entrada y Salida 2.3.2. Funciones Matemticas Funciones Generadas por el Usuario 2.4.1. Argumentos y Parmetros Formales 2.4.2. Funciones con y sin argumentos 2.4.3. Funciones que regresan Valores Estructuras de Flujo Programtico
7 10 15 25 26 29 33 34 40 43 47
2.3.
2.4.
Capitulo 3. 3.1.
Estructuras de Decisin 3.1.1. Simple 3.1.2. Ramificada Estructuras de Iteracin Estructuras de Control 3.3.1. Ruptura de un Lazo Estructuras de Datos
53 54 66 85 97 107
3.2. 3.3.
Capitulo 4. 4.1.
Arreglos Unidimensionales 4.1.1. Concepto y Forma General 4.1.2. Arreglos Numricos y de Caracteres Arreglos Bidimensionales 4.2.1. Concepto y Forma General 4.2.2. Arreglos Numricos y de Caractres Apuntadores 4.3.1. Concepto 4.3.2. Tipos de Apuntadores 4.3.3. Operaciones con Apuntadores 4.3.4. Relacin de Apuntadores con Arreglos
109 109 115 116 116 120 123 124 130 132 133
4.2.
4.3.
2 Autores: Alejandra Gutierrez Reyes - Enrique Martnez Roldn - Academia de Computacin Ingenieria Elctrica ESIME Zacatenco IPN
1.1.
Sistemas Operativos
1.1.1. Definicin, caractersticas y funcin de un sistema operativo. Un sistema operativo es un software de sistema, es decir, un conjunto de programas de computadora para permitir una administracin eficaz de sus recursos. Comienza a trabajar cuando es cargado en memoria por un programa especfico, que se ejecuta al iniciar el equipo, o al iniciar una mquina virtual, y gestiona el hardware de la mquina desde los niveles ms bsicos, brindando una interfaz con el usuario. Cuando un programa desea acceder a un recurso material, no necesita enviar informacin especfica a los dispositivos perifricos; simplemente enva la informacin al sistema operativo, el cual la transmite a los perifricos correspondientes a travs de su driver (controlador). Si no existe ningn driver, cada programa debe reconocer y tener presente la comunicacin con cada tipo de perifrico. Sistemas Operativos por su Estructura: Requisitos de usuario: Sistema fcil de usar y de aprender, seguro, rpido y adecuado al uso al que se le quiere destinar. Requisitos del software: Donde se engloban aspectos como el mantenimiento, forma de operacin, restricciones de uso, eficiencia, tolerancia frente a los errores y flexibilidad. Mquina Virtual. Se trata de un tipo de sistemas operativos que presentan una interface a cada proceso, mostrando una mquina que parece idntica a la mquina real subyacente. Estos sistemas operativos separan dos conceptos que suelen estar unidos en el resto de sistemas: la multiprogramacin y la mquina extendida. El objetivo de los sistemas operativos de mquina virtual es el de integrar distintos sistemas operativos dando la sensacin de ser varias mquinas diferentes. El ncleo de estos sistemas operativos se denomina monitor virtual y tiene como misin llevar a cabo la multiprogramacin, presentando a los niveles superiores tantas mquinas virtuales como se soliciten. Sistemas Operativos por Servicios: Esta clasificacin es la ms comnmente usada y conocida desde el punto de vista del usuario final. Monousuario Los sistemas operativos monousuarios son aqullos que soportan a un usuario a la vez, sin importar el nmero de procesadores que tenga la computadora o el nmero de procesos o tareas que el usuario pueda ejecutar en un mismo instante de tiempo. Las computadoras personales tpicamente se han clasificado en este rengln. Multiusuario Los sistemas operativos multiusuario son capaces de dar servicio a ms de un usuario a la vez, ya sea por medio de varias terminales conectadas a la computadora o por medio de sesiones remotas en una red de comunicaciones. No importa el nmero de procesadores en la mquina ni el nmero de procesos que cada usuario puede ejecutar simultneamente. Monotarea Los sistemas monotarea son aquellos que slo permiten una tarea a la vez por usuario. Puede darse el caso de un sistema multiusuario y monotarea, en el cual se admiten varios usuarios al mismo tiempo pero cada uno de ellos puede estar haciendo solo una tarea a la vez.
Multitarea Un sistema operativo multitarea es aqul que le permite al usuario estar realizando varias labores al mismo tiempo. Por ejemplo, puede estar editando el cdigo fuente de un programa durante su depuracin mientras compila otro programa, a la vez que est recibiendo correo electrnico en un proceso en background. Es comn encontrar en ellos interfaces grficas orientadas al uso de mens y el ratn, lo cual permite un rpido intercambio entre las tareas para el usuario, mejorando su productividad. Uniproceso Un sistema operativo uniproceso es aqul que es capaz de manejar solamente un procesador de la computadora, de manera que si la computadora tuviese ms de uno le sera intil. El ejemplo ms tpico de este tipo de sistemas es el DOS y MacOS. Multiproceso Un sistema operativo multiproceso se refiere al nmero de procesadores del sistema, que es ms de uno y ste es capaz de usarlos todos para distribuir su carga de trabajo. Generalmente estos sistemas trabajan de dos formas: simtrica o asimtricamente. Cuando se trabaja de manera asimtrica, el sistema operativo selecciona a uno de los procesadores el cual jugar el papel de procesador maestro y servir como pivote para distribuir la carga a los dems procesadores, que reciben el nombre de esclavos. Cuando se trabaja de manera simtrica, los procesos o partes de ellos (threads) son enviados indistintamente a cuales quiera de los procesadores disponibles, teniendo, tericamente, una mejor distribucin y equilibrio en la carga de trabajo bajo este esquema. Se dice que un thread es la parte activa en memoria y corriendo de un proceso, lo cual puede consistir de un rea de memoria, un conjunto de registros con valores especficos, la pila y otros valores de contexto. Sistemas Operativos por la Forma de Ofrecer sus Servicios: Esta clasificacin tambin se refiere a una visin externa, que en este caso se refiere a la del usuario, el cmo acceda los servicios. Bajo esta clasificacin se pueden detectar dos tipos principales: sistemas operativos de red y sistemas operativos distribuidos. Sistemas Operativos de Red Los sistemas operativos de red se definen como aquellos que tiene la capacidad de interactuar con sistemas operativos en otras computadoras por medio de un medio de transmisin con el objeto de intercambiar informacin, transferir archivos, ejecutar comandos remotos y un sin fin de otras actividades. El punto crucial de estos sistemas es que el usuario debe saber la sintaxis de un conjunto de comandos o llamadas al sistema para ejecutar estas operaciones, adems de la ubicacin de los recursos que desee accesar. Sistemas Operativos Distribuidos Los sistemas operativos distribuidos abarcan los servicios de los de red, logrando integrar recursos (impresoras, unidades de respaldo, memoria, procesos, unidades centrales de proceso) en una sola mquina virtual que el usuario accesa en forma transparente. Es decir, ahora el usuario ya no necesita saber la ubicacin de los recursos, sino que los conoce por nombre y simplemente los usa como si todos ellos fuesen locales a su lugar de trabajo habitual. El sistema operativo cumple varias funciones: Administracin del procesador: el sistema operativo administra la distribucin del procesador entre los distintos programas por medio de un algoritmo de programacin.
El tipo de programador depende completamente del sistema operativo, segn el objetivo deseado. Gestin de la memoria de acceso aleatorio: el sistema operativo se encarga de gestionar el espacio de memoria asignado para cada aplicacin y para cada usuario, si resulta pertinente. Cuando la memoria fsica es insuficiente, el sistema operativo puede crear una zona de memoria en el disco duro, denominada "memoria virtual". La memoria virtual permite ejecutar aplicaciones que requieren una memoria superior a la memoria RAM disponible en el sistema. Sin embargo, esta memoria es mucho ms lenta. Gestin de entradas/salidas: el sistema operativo permite unificar y controlar el acceso de los programas a los recursos materiales a travs de los drivers (tambin conocidos como administradores perifricos o de entrada/salida). Gestin de ejecucin de aplicaciones: el sistema operativo se encarga de que las aplicaciones se ejecuten sin problemas asignndoles los recursos que stas necesitan para funcionar. Esto significa que si una aplicacin no responde correctamente puede "sucumbir". Administracin de autorizaciones: el sistema operativo se encarga de la seguridad en relacin con la ejecucin de programas garantizando que los recursos sean utilizados slo por programas y usuarios que posean las autorizaciones correspondientes. Gestin de archivos: el sistema operativo gestiona la lectura y escritura en el sistema de archivos, y las autorizaciones de acceso a archivos de aplicaciones y usuarios. Gestin de la informacin: el sistema operativo proporciona cierta cantidad de indicadores que pueden utilizarse para diagnosticar el funcionamiento correcto del equipo.
1.1.2. Anlisis Comparativo de Sistemas Operativos Anlisis comparativo de Sistemas Operativos Programacin Usuario Usuario Tarea nico mltiple nica 16 bits X X 16/32 bits X 32 bits 32 bits 32/64 bits 32/64 bits 32 bits 32 bits X X X X X X
Tabla 1. Anlisis de Sistemas Operativos
Sistema DOS Windows3.1 Windows95/98/Me WindowsNT/2000 WindowsXP Unix / Linux MAC/OS X VMS
Multitarea no preventivo cooperativo preventivo preventivo preventivo preventivo preventivo
1.2.
Evolucin de los lenguajes de programacin
1.2.1. Definicin, caractersticas y funciones de los lenguajes de programacin Los lenguajes de programacin son herramientas que nos permiten crear programas y software. Una computadora funciona bajo control de un programa el cual debe estar almacenado en la unidad de memoria; tales como el disco duro. Los lenguajes de programacin de una computadora en particular se conoce como cdigo de mquinas o lenguaje de mquinas. Estos lenguajes codificados en una computadora especfica no podrn ser ejecutados en otra computadora diferente. Para que estos programas funcionen para diferentes computadoras hay que realizar una
versin para cada una de ellas, lo que implica el aumento del costo de desarrollo. Por otra parte, los lenguajes de programacin en cdigo de mquina son verdaderamente difciles de entender para una persona, ya que estn compuestos de cdigos numricos sin sentido nemotcnico. Los lenguajes de programacin facilitan la tarea de programacin, ya que disponen de formas adecuadas que permiten ser ledas y escritas por personas, a su vez resultan independientes del modelo de computador a utilizar. Los lenguajes de programacin representan en forma simblica y en manera de un texto los cdigos que podrn ser ledos por una persona. Los lenguajes de programacin son independientes de las computadoras a utilizar. Existen estrategias que permiten ejecutar en una computadora un programa realizado en un lenguaje de programacin simblico. Los procesadores del lenguaje son los programas que permiten el tratamiento de la informacin en forma de texto, representada en los lenguajes de programacin simblicos. La ventaja del proceso interprete es que no necesita de dos fases para ejecutar el programa, sin embargo su inconveniente es que la velocidad de ejecucin es ms lenta ya que debe analizar e interpretar las instrucciones contenidas en el programa fuente. Los lenguajes de programacin se pueden clasificar atendiendo a varios criterios: Segn el nivel de abstraccin Segn la forma de ejecucin Segn el paradigma de programacin que poseen cada uno de ellos
Nivel de abstraccin Lenguajes Mquina Estn escritos en lenguajes directamente inteligibles por la maquina (computadora), ya que sus instrucciones son cadenas binarias (0 y 1). Da la posibilidad de cargar (transferir un programa a la memoria) sin necesidad de traduccin posterior lo que supone una velocidad de ejecucin superior, solo que con poca fiabilidad y dificultad de verificar y poner a punto los programas. Lenguajes de bajo nivel Los lenguajes de bajo nivel son lenguajes de programacin que se acercan al funcionamiento de una computadora. El lenguaje de ms bajo nivel por excelencia es el cdigo mquina. A ste le sigue el lenguaje ensamblador, ya que al programar en ensamblador se trabajan con los registros de memoria de la computadora de forma directa. Lenguajes de medio nivel Hay lenguajes de programacin que son considerados por algunos expertos como lenguajes de medio nivel (como es el caso del lenguaje C) al tener ciertas caractersticas que los acercan a los lenguajes de bajo nivel pero teniendo, al mismo tiempo, ciertas cualidades que lo hacen un lenguaje ms cercano al humano y, por tanto, de alto nivel. Lenguajes de alto nivel Los lenguajes de alto nivel son normalmente fciles de aprender porque estn formados por elementos de lenguajes naturales, como el ingls. En BASIC, uno de los lenguajes de alto nivel
ms conocidos, los comandos como "IF CONTADOR = 10 THEN STOP" pueden utilizarse para pedir a la computadora que pare si el CONTADOR es igual a 10. Esta forma de trabajar puede dar la sensacin de que las computadoras parecen comprender un lenguaje natural; en realidad lo hacen de una forma rgida y sistemtica, sin que haya cabida, por ejemplo, para ambigedades o dobles sentidos. Segn la forma de ejecucin Lenguajes compilados Naturalmente, un programa que se escribe en un lenguaje de alto nivel tambin tiene que traducirse a un cdigo que pueda utilizar la mquina. Los programas traductores que pueden realizar esta operacin se llaman compiladores. stos, como los programas ensambladores avanzados, pueden generar muchas lneas de cdigo de mquina por cada proposicin del programa fuente. Se requiere una compilacin antes de ejecutar las instrucciones de un problema. Segn el paradigma de programacin Un paradigma de programacin representa un enfoque particular o filosofa para la construccin del software. No es mejor uno que otro, sino que cada uno tiene ventajas y desventajas. Dependiendo de la situacin un paradigma resulta ms apropiado que otro.
1.3.
Interpretes, Compiladores
1.3.1. Definicin de Intrpretes y Compiladores Hay lenguajes de programacin que utilizan compilador. La ejecucin de un programa con compilador requiere de dos etapas: 1) Traducir el programa simblico a cdigo mquina 2) Ejecucin y procesamiento de los datos. Otros lenguajes de programacin utilizan un programa intrprete o traductor, el cual analiza directamente la descripcin simblica del programa fuente y realiza las instrucciones dadas. Los compiladores son aquellos cuya funcin es traducir un programa escrito en un determinado lenguaje a un idioma que la computadora entienda (lenguaje mquina con cdigo binario). Al usar un lenguaje compilado (como lo son, por ejemplo, los lenguajes del popular Visual Studio de Microsoft), el programa desarrollado nunca se podr ejecutar mientras haya errores, sino hasta que tras haber compilado el programa, ya no aparecen errores en el cdigo. El intrprete en los lenguajes de programacin simula una mquina virtual, donde el lenguaje de mquina es similar al lenguaje fuente. Se puede tambin utilizar una alternativa diferente de los compiladores para traducir lenguajes de alto nivel. En vez de traducir el programa fuente y grabar en forma permanente el cdigo objeto que se produce durante la compilacin para utilizarlo en una ejecucin futura, el programador slo carga el programa fuente en la computadora junto con los datos que se van a procesar. A continuacin, un programa interprete, almacenado en el sistema operativo del disco, o incluido de manera permanente dentro de la mquina, convierte cada proposicin del programa fuente en lenguaje de mquina conforme vaya siendo necesario durante el procesamiento de los datos. El cdigo objeto no se graba para utilizarlo posteriormente. La siguiente vez que se utilice una instruccin, se la deber interpretar otra vez y traducir a lenguaje mquina. Por ejemplo, durante el procesamiento repetitivo de los pasos de un ciclo o
bucle, cada instruccin del bucle tendr que volver a ser interpretada en cada ejecucin repetida del ciclo, lo cual hace que el programa sea ms lento en tiempo de ejecucin (porque se va revisando el cdigo en tiempo de ejecucin) pero ms rpido en tiempo de diseo (porque no se tiene que estar compilando a cada momento el cdigo completo). El intrprete elimina la necesidad de realizar una de compilacin despus de cada modificacin del programa cuando se quiere agregar funciones o corregir errores; pero es obvio que un programa objeto compilado con antelacin deber ejecutarse con mucha mayor rapidez que uno que se debe interpretar a cada paso durante una ejecucin del cdigo. Ambiente integral del Lenguaje C: C es un lenguaje de programacin de propsito general que ofrece control de flujo y estructuras sencillas y un buen conjunto de operadores. No es un lenguaje de muy alto nivel y ms bien un lenguaje pequeo, sencillo y no est especializado en ningn tipo de aplicacin. Este lenguaje ha sido estrechamente ligado al sistema operativo UNIX, puesto que fueron desarrollados conjuntamente. Sin embargo, este lenguaje no est ligado a ningn sistema operativo ni a ninguna mquina concreta. Se le suele llamar lenguaje de programacin de sistemas debido a su utilidad para escribir compiladores y sistemas operativos, aunque de igual forma se puede desarrollar cualquier tipo de aplicacin.
UNIDAD II FUNDAMENTOS DE PROGRAMACIN ESTRUCTURADA
2.1. Estructura General de un Programa

Es muy til, sobre todo cuando se empieza a trabajar con un nuevo lenguaje, disponer de una plantilla con la estructura habitual y general de un programa en dicho lenguaje. Es de lo que tratar este tema. Se dice que C es un lenguaje estrictamente modular: todo el cdigo debe estar ubicado en el interior de funciones. La funcin llamada main() es slo eso, una funcin. Pero una funcin especial. Existe en todos los programas, porque contiene el algoritmo o mdulo principal del programa. La ejecucin de un programa siempre empieza por la primera lnea de la funcin main(). La funcin main(), como todas las funciones de C, puede devolver un valor. El valor devuelto por main() debe ser de tipo entero. Esto se utiliza para pasar algn valor al programa que haya llamado al nuestro, que suele ser el sistema operativo. Si main() no devuelve un nmero entero al sistema operativo mediante una sentencia return, entonces nuestro programa devolver un nmero desconocido. Moraleja: es una buena idea incluir un return al final de la funcin main(). Generalmente, la devolucin de un 0 indica al sistema operativo que el programa a finalizado sin problemas, mientras que cualquier otro valor seala que se ha producido algn error. Por lo tanto, la forma habitual de la funcin main() ser: int main(void) { ...instrucciones del algoritmo principal... return 0; } Observa que main() no tiene argumentos, por lo que aparece el identificador void entre parntesis en la declaracin. Es posible que se vea una definicin de main() con argumentos, algo as: int main(int argc, char* argv[]) { ...instrucciones del algoritmo principal... return 0; } Esos dos argumentos sirven para capturar parmetros de entrada desde la lnea de comandos. En general, un programa en C consta de las siguientes partes: Directivas al procesador. Definicin de tipos de datos. Declaracin de variables. Definicin de funciones.
Aspectos importantes a definir: 1.- Comentarios: Los comentarios en C comienzan con la secuencia '/*' y termina con la secuencia '*/'. Todo lo que se encuentre entre estas dos secuencias es omitido por el compilador y solo nos sirve para poner notas o anotaciones que nos sean tiles para ayuda a nuestro cdigo (jams sern compiladas ni ejecutadas por C). Algunos compiladores (no todos) soportan el anidamiento de comentarios (comentarios dentro de comentarios), pero por no ser una facilidad comn, no se
aconseja su utilizacin. El uso de comentarios en un programa es fundamental para su entendimiento. Una proporcin 50%-50% (cdigo-comentario) no es exagerada. Existen dos maneras de colocar un comentario, el de un prrafo completo deben estar comprendido entre /*.....*/, y aquellos comentarios que son de una sola lnea van con doble //. void main() /* Esta parte del programa es la cabecera principal */ { /* Llave que da inicio a la programacin del cuerpo del programa */ // Comentarios de 1 sola lnea // Cuerpo del programa principal } programa // Llave que da fin a la programacin del cuerpo del
2.- Directivas al procesador: Las directivas al procesador se refiere, a que la etapa de compilacin se realiza en dos fases, una en la que un procesador atiende todas las directivas que contiene el cdigo fuente y la otra etapa es la traduccin a cdigo objeto. Todas las directivas al procesador comienzan con el caracter '#', tambin llamadas bibliotecas, es un archivo que contiene las funciones estndar que se pueden usar en los programas. Entre esas funciones se encuentran todas las operaciones de entrada y salida de datos. Cada funcin definida en la biblioteca estndar tiene asociada una cabecera (#include). // Zona de ficheros de cabecera de las libreras #include <....... . h> // h de Head #include <....... . h> Cabeceras de Programa Cabecera <ctype.h> <errno.h> <float.h> <math.h> <setjmp.h> <stddef.h> <stdio.h> <stdlib.h> <string.h> <time.h> Propsito Manejo de caracteres Informes de error Define valores en coma flotante dependientes de la implementacin Definiciones usadas en la biblioteca matemtica Soporte para saltos no locales Define algunas constantes de uso comn Soporte para E/S de archivos Declaraciones variables Soporte para las funciones de cadena Soporte para las funciones de tiempo del sistema
Tabla 2. Cabeceras
3.- Definicin de funciones: Todas las funciones se definen colocando primero el tipo de retorno (void significa que la funcin no retorna nada como resultado de su ejecucin. Por defecto si no se coloca tipo de retorno, se asume que la funcin retorna un valor entero); al tipo de retorno le sigue el nombre (la funcin main posee un significado especial, ya que es la funcin que toma el control cuando se ejecuta el programa); le siguen los argumentos separados por comas y encerrados entre
parntesis (aunque la funcin no reciba argumentos, se colocan los parntesis vacios); y por ltimo el cuerpo de la funcin encerrado entre llaves. void main (void) // Programa principal tpico de Turbo C { // Llave de inicio del programa // Cdigo del programa ....... ....... ....... } // fin del programa
4.- Definicin de Tipos de Datos: La definicin o declaracin de datos se hace de dos tipos; una llamada declaracin global, que se hace antes del void main ( ) y la cual es reconocida por todo el programa y la declaracin local que es conocida en el programa principal, y se incluye dentro del void main ( ). // Zona de variables globales int valor; float media_total; /* Variables locales del algoritmo principal */ int a, b; float x, y;
Todo programa en C, desde el ms pequeo hasta el ms complejo, tiene una funcin principal denominada main(),que es la funcin que toma el control cuando se corre el programa. Adems, por encima de main() deben aparecer los prototipos de funciones (y esto implica a los archivos de cabecera, si se utilizan funciones de librera) y las variables y constantes globales, si las hay. Por debajo de main() encontraremos el cdigo del resto de funciones. Por lo tanto, la estructura habitual de nuestros programas en C debera ser esta: /* Comentario inicial: nombre del programa, del programador, fecha, etc. */ /* Archivos de cabecera (prototipos de funciones de librera) */ #include <archivo_cabecera.h> #include <archivo_cabecera.h> /* Prototipos de funciones escritas por nosotros */ float funcin1 (argumentos); float funcin2 (argumentos); /* Variables y constantes globales */ int variable_global; const char constante_global; #define PI 3.14
/* Algoritmo principal */ int main(void) { /* Variables locales del algoritmo principal */ int a, b; float x, y; ... ... /* Instrucciones del algoritmo principal */ ... funcin1(argumentos); ... funcin2(argumentos); ... return 0; } /* Cdigo completo de las funciones escritas por nosotros */ float funcin1 (argumentos) { /* Variables locales e instrucciones de este subalgoritmo */ } float funcin2 (argumentos) { /* Variables locales e instrucciones de este subalgoritmo */ } El tema de funciones se ver posteriormente a detalle en el tema 2.3. Un punto importante es enfatizar que todas las lneas de las sentencias terminan con el carcter de ( ; ).
2.2. Tipos de Datos y Operadores

Operadores Un operador es un carcter o grupo de caracteres que acta sobre una, dos o ms variables para realizar una determinada operacin con un determinado resultado. Ejemplos comnes de operadores son la suma (+), la diferencia (-), el producto (*), etc. Los operadores pueden ser unarios, binarios y ternarios, segn acten sobre uno, dos o tres operandos, respectivamente. En C existen muchos operadores de diversos tipos, que se vern a continuacin. Ahora solo mencionar los tipos de operadores que hay, ya que posteriormente se explicar con un poco mas de detalle cada uno de ellos. Operadores Aritmticos Los operadores aritmticos son los ms sencillos de entender y de utilizar. Todos ellos son operadores binarios. En C se utilizan los cinco operadores siguientes: Suma (+) Resta () Multiplicacin (*) Divisin (/)
El quinto operador es el que proporciona el resto de la divisin (residuo) Mdulo (%)
Todos estos operadores se pueden aplicar a constantes, variables y expresiones. El resultado es el que se obtiene de aplicar la operacin correspondiente entre los dos operandos. El nico operador que requiere una explicacin adicional es el operador Mdulo ( %). En realidad su nombre completo es resto o residuo de la divisin entera. Este operador se aplica solamente a constantes, variables o expresiones de tipo int. Con el objeto de dejar mas en claro lo anterior, su significado es evidente: 23 % 4 es 3, ya que el resto de dividir 23 por 4 es 3. Otro ejemplo seria; si a % b es cero entonces a es mltiplo de b. Como se ver ms adelante, en los otros subtemas una expresin es un conjunto de variables y constantes y tambin de otras expresiones ms sencillas relacionadas mediante distintos operadores. Un ejemplo de expresin en la que intervienen operadores aritmticos es el siguiente polinomio de grado 2 en la variable y: 9.0 - 5.0 * y + y * y / 3.0 Las expresiones pueden contener parntesis (...) que agrupan a algunos de sus trminos. Puede haber parntesis contenidos dentro de otros parntesis. El significado de los parntesis coincide con el que se usa en las expresiones matemticas, con algunas caractersticas importantes que se vern ms adelante. En ocasiones, la introduccin de caracteres espacio mejora la legibilidad de las expresiones. Operadores De Asignacin Aritmtica Estos resultan de la unin de los operadores aritmticos con el operador de asignacin el signo (=), o sea: Igual (=) Suma igual (+=) Resta igual ( =) Multiplicacin igual (*=) Divisin igual (/=)
Estos operadores se aplican de la siguiente manera: ( x += 5 ), en este ejemplo se toma el operando de la izquierda lo suma con el operando de la derecha y lo asigna al operando de la izquierda, en este caso la variable x. Operadores de Incremento y Decremento El operador de incremento es el (++) y el de decremento es el (--), son operadores unarios los cuales tienen prioridad mas alta que otros operadores y sirven para incrementar o decrementar una unidad el valor de la variable a la que afectan. Ahora describiremos algunas caractersticas de los operadores; pre-incremento y postincremento: Estos operadores pueden ir inmediatamente delante o detrs de la variable. Si preceden a la variable, sta es incrementada antes de que el valor de dicha variable sea utilizado en la expresin en la que aparece. Si es la variable la que precede al operador, la variable es incrementada despus de ser utilizada en la expresin. A continuacin se presenta un ejemplo de estos operadores: i = 2; j = 2;
m = i++; /* despus de ejecutarse esta sentencia m=2 e i=3*/ n = ++j; /* despus de ejecutarse esta sentencia n=3 y j=3*/ Estos operadores son muy utilizados. Es importante entender muy bien por qu los resultados m y n del ejemplo anterior son diferentes. Operadores Relacinales Estos establecen la magnitud relativa de dos elementos y son los siguientes: Expresin a<b a>b a == b a != b a <= b a >=b Expresiones Lgicas: Significado Es a menor que b Es a mayor que b Es a igual a b Es a diferente o no igual a b Es a menor o igual a b Es a mayor o igual a b
Tabla 3. Expresiones Lgicas
Recordemos que estas operaciones nos dan resultados lgicos de 1 0 es decir valores de verdadero o falso; lenguaje C considera todo valor no cero como un valor verdadero. Operadores Lgicos C proporciona operadores lgicos para combinar los resultados de varias condiciones. Una expresin compuesta es aquella que utiliza operadores como estos y que se pueden evaluar para obtener un nico resultado de verdadero o falso. Dos de los operadores lgicos son binarios porque usan dos operandos, devuelven un resultado basado en los operandos recibidos y en el operador. AND ( && ): Este operador conocido como producto lgico retorna un valor de verdadero si los operandos son verdaderos. OR ( || ): El operador de suma lgica retorna un valor de verdadero si los operandos o uno de los operandos es verdadero. NOT ( ! ): Operador de negacin, tiene por efecto invertir el resultado de la expresin que le sigue es decir si la expresin es verdadera despus de aplicar este operador la expresin ser falsa y viceversa. Los operadores lgicos tienen una prioridad bastante baja, menos que los operadores de igualdad pero mayor que el operador de asignacin. Jerarqua o Precedencia de Operadores Operadores Unario / Binario Comentario Operadores Unarios Unario !, &, +, -, sizeof() Multiplicador Aritmtico Binario *, /, % Adicin Aritmticos Binario +, Operadores Relacinales Binario <, <=, >, >= Operadores de Igualdad Binario ==, != Multiplicador Lgico Binario && Aditivo Lgico Binario || Operador de Asignacin Binario =
Tabla 4. Jerarqua de Operadores 1 Autores: Alejandra Gutierrez Reyes - Enrique Martnez Roldn - Academia de Computacin Ingenieria Elctrica ESIME Zacatenco IPN
Los lenguajes de programacin disponen de una serie de tipos de datos bsicos, y proporcionan herramientas para crear estructuras a medida que faciliten el acceso a la informacin. As en nuestro caso ficticio de resolver un sistema de ecuaciones podemos almacenar los coeficientes de cada ecuacin con lo que utilizaramos como tipo de dato los nmeros, si plantesemos el problema desde un punto de vista matricial nos interesara tener un tipo de datos matriz y lo ideal sera tener un tipo de datos ecuacin. En este apartado describiremos los tipos bsicos que proporciona el lenguaje C y dejaremos para temas posteriores la declaracin de tipos complejos. El C dispone de estos tipos bsicos: Para el sistema operativo MSDOS , en el smbolo del sistema de Windows XP (En TC++ 3.0 y Borland C++ 5.0): TIPOS FORMATO Tipos de Datos y Rango: RANGO TAMAO DESCRIPCIN -128 a 127 0 a 255 -32.768 a 32.767 0 a 65.535 -32.768 a 32.767 0 a 65.535 -32.768 a 32.767 -2.147.483.648a 0 a 4.294.967.295 -2.147.483.648a 2 147 483 647 0 a 4.294.967.295 1 1 2 2 2 2 2 4 4 4 4 Para una letra o un dgito. Letra o nmero positivo. Entero corto con signo Entero corto sin signo Entero con signo Entero sin signo Entero con signo Entero largo con signo Entero largo sin signo Entero largo con signo Entero largo sin signo Para nmeros con decimales Para nmeros con decimales Para nmeros con decimales
Char %c unsigned char %u Short unsigned %u Int %d, %i unsigned int %u short int %d Long %ld unsigned long %ld long int %ld unsigned long %ld i t Float %f, %g, %e, %E Double %f, %g, %e, %E long double %f, %g, %e, %E
3.4E-38 a 3.4E+38 decimales(6) 4 1.7E-308 a 1.7E+308 decimales(10) 8 3.4E-4932 a 1.1E+4932 decimales(10) 10

Tabla 5. Tipos de datos y su rango
Todos estos tipos salvo void son tipos numricos. Incluso el tipo char. Adems de estos tipos podemos utilizar los modificadores signed y unsigned, los cuales son aplicables a los tipos de datos enteros Aunque el tipo char represente caracteres internamente para la computadora no es ms que un nmero comprendido entre 0 y 255 que identifica un carcter dentro del cdigo especificado para tal propsito en el sistema en el que nos encontremos trabajando. El cdigo ms utilizado para este tipo de representacin es el ASCII. Segn la mquina, el compilador empleado y las opciones de compilacin , "char" puede interpretarse con signo o sin signo. Esto es, de -128 a 127 o desde 0 a 255. Si se requiere una representacin que no dependa de las opciones del compilador, etc., se puede poner "signed char" o "unsigned char", segn el caso. Variables Como decamos antes la computadora debe de disponer de los datos necesarios para resolver el problema para el que lo queramos programar. Difcilmente se podra resolver un sistema de
ecuaciones si no se dispone de stas. Para ello podemos definir variables. Las variables almacenan valores de un tipo especificado y en ellas almacenamos los datos de nuestro problema, se denominan variables por que su valor puede cambiar a lo largo del programa. Una variable slo puede pertenecer a un tipo de dato. Para poder utilizar una variable, primero tiene que ser declarada. Para referenciar una variable especificada es necesario que la podamos identificar para ello se utiliza un nombre o identificador. Las variables no se conservan despus de que un programa termina su ejecucin. Cuando finaliza un programa, los datos son borrados. Si quieres que datos permanezcan puedes usar archivos para almacenarlos. Declaracin de Variables Las variables se utilizan para almacenar temporalmente datos dentro del programa. En C Hay que declarar todas las variables antes de usarlas. Cada variable tiene un tipo. Es posible inicializar y declarar ms de una variable del mismo tipo en la misma sentencia: La declaracin es: tipo nombre ; Ejemplo: int pepe; /* tipo de variable: int y nombre de la variable: a */ float b; double c,d; /* tipo de las variables: double y nombre de las variables: c y d */ char x; Nota: La declaracin de variables debe hacerse al principio de la funcin. (Aunque algunos compiladores lo admitan, no debe hacerse en cualquier lugar). Asignacin de Valores Para la asignacin de valores se utiliza el signo ( = ) igual, por ejemplo: A = 5; B = 4; X = 43.453; En C es posible asignar a varias variables un solo valor ejemplo: a x p k = = = = b y d i = = = = c = 7; n = 34; m = 56.8; 23;
Algunos lenguajes automticamente inicializan variables numricas a cero y variables tipo carcter a blanco o a carcter nulo, en C no es as ya que se puede declarar la variable e inicializarla al mismo tiempo, por ejemplo: int x = 5, y = 1; Hay que tener cuidado con lo siguiente: Podramos pensar que x e y son igual a 20, pero no es as. La variable x est sin valor inicial y la variable 'y' tiene el valor 20. Ejemplo: Suma dos valores
Algoritmo: inicio declarar variables enteras num1=4, num2, num3 = 6 escribir ( El valor de num1 es: , num1) escribir ( El valor de num3 es:, num3) num2 num1+num3 escribir ( num1 + num3 = , num2) pausa fin Programa: #include <stdio.h> int main (void) { int num1=4, num2, num3=6; printf(" El valor de num1 es %d", num1); printf("\n El valor de num3 es %d", num3); num2=num1+num3; printf("\n num1 + num3 = %d\n", num2); system(pause); return 0; }
Alcance o mbito de las Variables (tipos de declaracin de variables) Segn el lugar donde se declaren las variables tendrn un mbito. Segn el mbito de las variables pueden ser utilizadas desde cualquier parte del programa o nicamente en la funcin donde han sido declaradas. Las variables pueden ser: - locales: Cuando se declaran dentro de una funcin. Las variables locales slo pueden ser referenciadas (utilizadas) por sentencias que estn dentro de la funcin que han sido declaradas. No son conocidas fuera de su funcin. Pierden su valor cuando se sale y se entra en la funcin. La declaracin es como siempre. -globales: Son conocidas a lo largo de todo el programa, y se pueden usar desde cualquier parte del cdigo del programa. Mantienen sus valores durante toda la ejecucin. Deban ser declaradas fuera de todas las funciones incluida main (void). La sintaxis de creacin no cambia nada con respecto a las variables locales. Inicialmente toman el valor 0 o nulo, segn el tipo. -de registro: Otra posibilidad es, que en vez de ser mantenidas en posiciones de memoria de la computadora, se las guarde en registros internos del microprocesador. De esta manera el acceso a ellas es ms directo y rpido. Para indicar al compilador que es una variable de registro hay que aadir a la declaracin la palabra register delante del tipo. Solo se puede utilizar para variables locales. -estticas: Las variables locales nacen y mueren con cada llamada y finalizacin de una funcin, sera til que mantuvieran su valor entre una llamada y otra sin por ello perder su mbito. Para conseguir eso se aade a una variable local la palabra static delante del tipo. 2.2.1. Tamao, declaracin y modificadores El Tipo de dato int
En una variable de este tipo se almacenan nmeros enteros (sin decimales). Una variable tipo int se almacena en 2 bytes (16 bits), aunque algunos compiladores utilizan 4 bytes (32 bits). El ANSI C no tiene esto completamente normalizado y existen diferencias entre unos compiladores y otros. Con 16 bits se pueden almacenar 216 = 65536 nmeros enteros diferentes: de 0 al 65535 para variables sin signo, y de -32768 al 32767 para variables con signo (que pueden ser positivas y negativas), que es la opcin por defecto. Este es el rango de las variables tipo int. Para poder usar una variable primero hay que declararla (definirla). Hay que decirle al compilador que queremos crear una variable y hay que indicarle de qu tipo. Por ejemplo: unsigned int numero; int nota = 10; Esto hace que declaremos una variable llamada nmero que va a contener un nmero entero sin signo y una variable nota con signo. En este caso la variable numero podr estar entre 0 y 65535, mientras que nota deber estar comprendida entre -32768 al 32767. Cuando a una variable int se le asigna en tiempo de ejecucin un valor que queda fuera del rango permitido (situacin de overflow o valor excesivo), se produce un error en el resultado de consecuencias tanto ms imprevisibles cuanto que de ordinario el programa no avisa al usuario de dicha circunstancia. Cuando el ahorro de memoria es muy importante puede asegurarse que el computador utiliza 2 bytes para cada entero declarndolo en una de las formas siguientes: int numero; Como se ha dicho antes, ANSI C no obliga a que una variable int ocupe 2 bytes, pero declarndola como int s que necesitar slo 2 bytes (al menos en los PCs). Mostrar variables por pantalla Vamos a ir u poco ms all con la funcin printf. Supongamos que queremos mostrar el contenido de la variable x por pantalla: printf( "%i", x ); Suponiendo que x valga 10 (x=10) en la pantalla tendramos: 10 Aqu se describe brevemente el significado de "%i" el cual no se muestra por pantalla, se sustituye por el valor de la variable que va detrs de las comillas. ( %i, de integer = entero en ingls). Para ver el contenido de dos variables, por ejemplo x e y, podemos hacer: printf( "%i ", x ); printf( "%i", y ); resultado (suponiendo x=10, y=20): 10 20 Pero hay otra forma mejor: printf( "%i %i", x, y );
y as podemos poner el nmero de variables que queramos. Obtenemos el mismo resultado con menos trabajo. No olvidemos que por cada variable hay que poner un %i dentro de las comillas. Tambin podemos mezclar texto con enteros: printf( "El valor de x es %i, excelente! \n", x ); que quedar como: El valor de x es 10, excelente! Como vemos %i al imprimir se sustituye por el valor de la variable. Veamos un ejemplo para resumir todo: Algoritmo: inicio declara variables enteras x 20 escribir ( El valor inicial de x es , x ) x 60 escribir ( Ahora el valor es , x ); pausa fin Programa: #include <stdio.h> int main() { int x = 20; prinft( "El valor inicial de x es %i \n", x ); x = 60; printf( "Ahora el valor es %i \n", x ); system(pause); return 1; } Cuya salida ser: El valor inicial de x es 20 Ahora el valor es 60 Si imprimimos una variable a la que no hemos dado ningn valor no obtendremos ningn error al compilar pero la variable tendr un valor cualquiera. El Tipo de dato char Las variables de tipo char sirven para almacenar caracteres y se almacenan en un byte de memoria (8 bits). En un bit se pueden almacenar dos valores (0 y 1); con dos bits se pueden almacenar 22 = 4 valores (00, 01, 10, 11 en binario; 0, 1 2, 3 en decimal). Con 8 bits se podrn almacenar 28 = 256 valores diferentes (normalmente entre 0 y 255; con ciertos compiladores entre -128 y 127).
Los 128 primeros (0 a 127) son el ASCII estndar. El resto es el ASCII extendido y depende del idioma y de la computadora. Para declarar una variable de tipo char hacemos: char letra; char a, b, caracter; Se puede declarar ms de una variable de un tipo determinado en una sola sentencia. Se puede tambin inicializar la variable en la declaracin. Por ejemplo, para definir la variable carcter letra a y asignarle el valor A, se puede escribir: char letra = A; o letra = 65; A partir de ese momento queda definida la variable letra con el valor correspondiente a la letra A. Recurdese que el valor A utilizado para inicializar la variable letra es una constante carcter. En realidad, letra se guarda en un solo byte como un nmero entero, el correspondiente a la letra A en el cdigo ASCII, (existe un cdigo ASCII extendido que utiliza los 256 valores y que contiene caracteres especiales y caracteres especficos de los alfabetos de diversos pases, como por ejemplo las vocales acentuadas y la letra para el espaol latinoamericano). En una variable char slo podemos almacenar solo una letra, no podemos almacenar ni frases ni palabras. En el ejemplo anterior, en ambos casos se almacena la letra 'A' en la variable. Esto es as porque el cdigo ASCII de la letra 'A' es el 65. Para imprimir un char usamos el smbolo %c (c de character=caracter en ingls): letra = 'A'; printf( "La letra es: %c.", letra ); Resultado: La letra es A. Tambin podemos imprimir el valor ASCII de la variable usando %i en vez de %c: letra = 'A'; printf( "El cdigo ASCII de la letra %c es: %i.", letra, letra ); Resultado: El cdigo ASCII de la letra A es 65. Como vemos la nica diferencia para obtener uno u otro es el modificador (%c %i) que usemos. Las variables tipo char se pueden usar (y de hecho se usan mucho) para almacenar enteros. Si necesitamos un nmero pequeo (entre -127 y 127) podemos usar una variable char (8bits) en vez de una int (16bits), con el consiguiente ahorro de memoria. Todo lo dems dicho para los datos de tipo int se aplica tambin a los de tipo char. Una curiosidad:
letra = printf( letra = printf(
'A'; "La letra es: %c y su valor ASCII es: %i\n", letra, letra ); letra + 1; "Ahora es: %c y su valor ASCII es: %i\n", letra, letra );
En este ejemplo letra comienza con el valor 'A', que es el cdigo ASCII 65. Al sumarle 1 pasa a tener el valor 66, que equivale a la letra 'B' (cdigo ASCII 66). La salida de este ejemplo sera: La letra es A y su valor ASCII es 65 Ahora es B y su valor ASCII es 66 El Tipo de dato long Existe la posibilidad de utilizar enteros con un rango mayor si se especifica como tipo long en su declaracin: long int numero _ grande; o, ya que la palabra clave int puede omitirse en este caso, long numero _ grande; El rango de un entero long puede variar segn el computador o el compilador que se utilice, pero de ordinario se utilizan 4 bytes (32 bits) para almacenarlos, por lo que se pueden representar 232 = 4.294.967.296 nmeros enteros diferentes. Si se utilizan nmeros con signo, podrn representarse nmeros entre -2.147.483.648 y 2.147.483.647. Tambin se pueden declarar enteros long que sean siempre positivos con la palabra unsigned: unsigned long numero_positivo_muy_grande; En algunos computadores una variable int ocupa 2 bytes (coincidiendo con short) y en otros 4 bytes (coincidiendo con long). Lo que garantiza el ANSI C es que el rango de int no es nunca menor que el de short ni mayor que el de long. El Tipo de dato float En muchas aplicaciones hacen falta variables reales, capaces de representar magnitudes que contengan una parte entera y una parte fraccionaria o decimal. Estas variables se llaman tambin de punto flotante. De ordinario, en base 10 y con notacin cientfica, estas variables se representan por medio de la mantisa, que es un nmero mayor o igual que 0.1 y menor que 1.0, y un exponente que representa la potencia de 10 por la que hay que multiplicar la mantisa para obtener el nmero considerado. Por ejemplo, se representa como 0.3141592654 . 101. Tanto la mantisa como el exponente pueden ser positivos y negativos. Las computadoras trabajan en base 2. Por eso un nmero de tipo float se almacena en 4 bytes (32 bits), utilizando 24 bits para la mantisa (1 para el signo y 23 para el valor) y 8 bits para el exponente (1 para el signo y 7 para el valor). Es interesante ver qu clase de nmeros de punto flotante pueden representarse de esta forma. En este caso hay que distinguir el rango de la precisin. La precisin hace referencia al nmero de cifras con las que se representa la mantisa. Declaracin de una variable de tipo float: float numero; Para imprimir valores tipo float Usamos %f.
float num=4060.80; printf( "El valor de num es : %f", num ); El resultado ser: El valor de num es: 4060.80 Si queremos escribirlo en notacin exponencial usamos %e: float num = 4060.80; printf( "El valor de num es: %e", num ); Que da como resultado: El valor de num es: 4.06080e003 El Tipo de dato double Las variables tipo float tienen un rango y sobre todo una precisin muy limitada, insuficiente para la mayor parte de los clculos tcnicos y cientficos. Este problema se soluciona con el tipo double, que utiliza 8 bytes (64 bits) para almacenar una variable. Se utilizan 53 bits para la mantisa (1 para el signo y 52 para el valor) y 11 para el exponente (1 para el signo y 10 para el valor). Las variables tipo double se declaran de forma anloga a las anteriores: double numero_real_grande; Por ltimo, existe la posibilidad de declarar una variable como long double, aunque el ANSI C no garantiza un rango y una precisin mayores que las de double. Eso depende del compilador y del tipo de computador. Estas variables se declaran en la forma: long double real_muy_grande; cuyo rango y precisin no est normalizado. Los compiladores de Microsoft para PCs utilizan 10 bytes (64 bits para la mantisa y 16 para el exponente). Overflow: Qu pasa cuando nos saltamos el rango El overflow es lo que se produce cuando intentamos almacenar en una variable un nmero mayor del mximo permitido. El comportamiento es distinto para variables de nmeros enteros y para variables de nmeros en coma flotante. Tabla de tipos de datos Tipo Char Short Int Unsigned Long Float Double Definicin Carcter Entero corto con signo Entero con signo Entero sin signo Entero largo con signo Flotante simple Flotante doble Bits (normalmente 8 bits) (normalmente 16 bits) (depende de la implementacin) (depende de la implementacin) (normalmente 32 bits) (normalmente 32 bits) (normalmente 64 bits)
Tabla 6. Tipos de datos
Con nmeros enteros si corremos este programa Algotimo: inicio declarar variables Enteras num1 num1 2147483648 escribir ( El valor de num1 es: , num1 ) pausa fin Programa: #include <stdio.h> int main(void) { int num1; num1 = 2147483648; printf( "El valor de num1 es: %i \n", num1 ); getch(); } El resultado que obtenemos es: El valor de num1 es: -2147483648 Comprueba si quieres que con el nmero anterior (2.147.483.647) no pasa nada. Con nmeros en coma flotante El comportamiento con nmeros en coma flotante es distinto. Dependiendo de la computadora si nos pasamos del rango al ejecutar un programa se puede producir un error y detenerse la ejecucin. Con estos nmeros tambin existe otro error que es el underflow. Este error se produce cuando almacenamos un nmero demasiado pequeo. Conversin de tipos: Cuando escribimos una expresin aritmtica a+b, en la cual hay variables o valores de distintos tipos, el compilador realiza determinadas conversiones antes de que evale la expresin. Estas conversiones pueden ser para 'aumentar' o 'disminuir' la precisin del tipo al que se convierten los elementos de la expresin. Un ejemplo claro, es la comparacin de una variable de tipo int con una variable de tipo double. En este caso, la de tipo int es convertida a double para poder realizar la comparacin. Los tipos pequeos son convertidos de la forma siguiente: un tipo char se convierte a int, con el modificador signed si los caracteres son con signo, o unsigned si los caracteres son sin signo. Un unsigned char es convertido a int con los bits ms altos puestos a cero. Un signed char es convertido a int con los bits ms altos puestos a uno o cero, dependiendo del valor de la variable. Para los tipos de mayor tamao: si un operando es de tipo double, el otro es convertido a double. Si un operando es de tipo float, el otro es convertido a float. Si un operando es de tipo unsigned long, el otro es convertido a unsigned long. Si un operando es de tipo long, el otro es convertido a long. Si un operando es de tipo unsigned, el otro es convertido a unsigned. Si no, los operandos son de tipo int. Otra clase de conversin implcita tiene lugar cuando el resultado de una expresin es asignado a una variable, pues dicho resultado se convierte al tipo de la variable (en este caso,
sta puede ser de menor rango que la expresin, por lo que esta conversin puede perder informacin y ser peligrosa). Por ejemplo, si i y j son variables enteras y x es double: x = i*j j + 1; En C existe casting, en programador. convertir por ejemplo, tambin la posibilidad de ingles). El casting es Para ello basta preceder el tipo al que se desea realizar conversiones explcitas de tipo (llamadas pues una conversin de tipo, forzada por el la constante, variable o expresin que se desea convertir, encerrado entre parntesis. En el siguiente
k = (int) 1.7 + (int) masa; la variable masa es convertida a tipo int, y la constante 1.7 (que es de tipo double) tambin. El casting se aplica con frecuencia a los valores de retorno de las funciones. Ejemplo: Algoritmo: inicio declarar variables reales a enteras b a 2.8 b 10 escribir ( a (real) = , a) escribir ( a convertido en entero: , (int) a) escribir ( b (entero): , b) escribir ( b convertido en real: , (float) b) pausa fin Programa: #include <stdio.h> int main (void) { float a; int b; a = 2.8; b = 10; printf("\n a (real) = %f", a); /* a = 2.8000 */ printf("\n a convertido en entero: %d", (int) a); /* a convertido en entero : 2 */ printf("\n b (entero): %d", b); /* b : 10 */ printf("\n b convertido en real: %f", (float) b); /* b convertido en real : 10.0000 */ system(pause); return 1; } Constantes Se entiende por constantes aquel tipo de informacin numrica o alfanumrica que no puede cambiar ms que con una nueva compilacin del programa. Como ya se ha dicho anteriormente, en el cdigo de un programa en C pueden aparecer diversos tipos de constantes que se van a explicar a continuacin.
Constantes Enteras Un constante entero decimal est formado por una secuencia de dgitos del 0 al 9, constituyendo un nmero entero. Las constantes enteros decimales estn sujetas a las mismas restricciones de rango que las variables tipo int y long, pudiendo tambin ser unsigned. El tipo de una constante se puede determinar automticamente segn su magnitud, o de modo explcito posponiendo ciertos caracteres, como en los ejemplos que siguen:
Longitud 23484 45815 253u 253U 739l 739L 583ul 583UL
Constantes de tipo entero Constante constante tipo int constante tipo long (es mayor que 32767) constante tipo unsigned int constante tipo long constante tipo unsigned long
Tabla 7. Constantes Enteras
En C se pueden definir tambin constantes enteras octales, esto es, expresadas en base 8 con dgitos del 0 al 7. Se considera que una constante est expresada en base 8 si el primer dgito por la izquierda es un cero (0). Anlogamente, una secuencia de dgitos (del 0 al 9) y de letras (A, B, C, D, E, F) precedida por 0x o por 0X, se interpreta como una constante entera hexadecimal, esto es, una constante numrica expresada en base 16. Por ejemplo: Ejemplos conversiones Conversin 011 11 0xA 0xFF Cdigo constante octal (igual a 9 en base 10) constante entera decimal (no es igual a 011) constante hexadecimal (igual a 10 en base 10) constante hexadecimal (igual a 162-1=255 en base 10)
Tabla 8. Ejemplos de Conversiones
Es probable que no haya necesidad de utilizar constantes octales y hexadecimales, pero conviene conocer su existencia y saber interpretarlas por si hiciera falta. La ventaja de los nmeros expresados en base 8 y base 16 proviene de su estrecha relacin con la base 2 ( 8 y 16 son potencias de 2), que es la forma en la que la computadora almacena la informacin. Constantes de punto flotante Como es natural, existen tambin constantes de punto flotante, que pueden ser de tipo float, double y long double. Una constante de punto flotante se almacena de la misma forma que la variable correspondiente del mismo tipo. Por defecto si no se indica otra cosa las constantes de punto flotante son de tipo double. Para indicar que una constante es de tipo float se le aade una f o una F; para indicar que es de tipo long double, se le aade una l o una L. En cualquier caso, el punto decimal siempre debe estar presente si se trata de representar un nmero real. Estas constantes se pueden expresar de varias formas. La ms sencilla es un conjunto de dgitos del 0 al 9, incluyendo un punto decimal. Para constantes muy grandes o muy pequeas puede utilizarse la notacin cientfica; en este caso la constante tiene una parte entera, un punto decimal, una parte fraccionaria, una e o E, y un exponente entero (afectando a
la base 10), con un signo opcional. Se puede omitir la parte entera o la fraccionaria, pero no ambas a la vez. Las constantes de punto flotante son siempre positivas. Puede anteponerse un signo (-), pero no forma parte de la constante, sino que con sta constituye una expresin, como se ver ms adelante. A continuacin se presentan algunos ejemplos vlidos:
Ejemplo 1.23 23.963f .00874 23e2 .874e-2 .874e-2f
Ejemplos de Constantes Constante constante tipo double (opcin por defecto) constante tipo float constante tipo double constante tipo double (igual a 2300.0) constante tipo double en notacin cientfica (=.00874) constante tipo float en notacin cientfica
Tabla 9. Ejemplos de Constantes
Seguidos de otros que no son correctos: Ejemplos incorrectos de constantes
1,23 23963f .e4 -3.14
error: la coma no esta permitida error: no hay punto decimal ni carcter e E error: no hay ni parte entera ni fraccionaria error: slo el exponente puede llevar signo
Tabla 10. Ejemplos incorrectos de constantes
Constantes carcter Una constante carcter es un carcter cualquiera encerrado entre apstrofos (tal como 'x' o 't'). El valor de una constante carcter es el valor numrico asignado a ese carcter segn el cdigo ASCII. Conviene indicar que en C no existen constantes tipo char; lo que se llama aqu constantes carcter son en realidad constantes enteras. Hay que sealar que el valor ASCII de los nmeros del 0 al 9 no coincide con el propio valor numrico. Por ejemplo, el valor ASCII de la constante carcter '8' es 56. Ciertos caracteres no representables grficamente, el apstrofo (') y la barra invertida (\) y otros caracteres, se representan mediante tabla de secuencias de escape con ayuda de la barra invertida (\). Los caracteres ASCII pueden ser tambin representados mediante el nmero octal correspondiente, encerrado entre apstrofos y precedido por la barra invertida. Por ejemplo, '\07' y '\7' representan el nmero 7 del cdigo ASCII (sin embargo, '\007' es la representacin octal del carcter '7'). El ANSI C tambin admite secuencias de escape hexadecimales, por ejemplo '\x1a'.
Cadenas de caracteres Una cadena de caracteres es una secuencia de caracteres delimitada por comillas ("), como por ejemplo: "Esto es una cadena de caracteres". Dentro de la cadena, pueden aparecer caracteres en blanco y se pueden emplear las mismas secuencias de escape vlidas para las constantes carcter. Por ejemplo, las comillas (") deben estar precedidas por (\), para no ser interpretadas como fin de la cadena; tambin la propia barra invertida (\). Es muy importante sealar que el compilador sita siempre un byte nulo (\0) adicional al final de cada cadena de caracteres para sealar el final de la misma. As, la cadena "mesa" no ocupa 4 bytes, sino 5 bytes. A continuacin se muestran algunos ejemplos de cadenas de caracteres: "Informtica I" "'A'" " cadena con espacios en blanco " "Esto es una \"cadena de caracteres".\n" 2.2.2. Operadores Lgicos Aritmticos y de Asignacin Constantes de tipo Enumeracin: En C existen una clase especial de constantes, llamadas constantes enumeracin. Estas constantes se utilizan para definir los posibles valores de ciertos identificadores o variables que slo deben poder tomar unos pocos valores. Por ejemplo, se puede pensar en una variable llamada dia_de_la_semana que slo pueda tomar los 7 valores siguientes: lunes, martes, mircoles, jueves, viernes, sbado y domingo. Es muy fcil imaginar otros tipos de variables anlogas, una de las cuales podra ser una variable booleana con slo dos posibles valores: SI y NO, o TRUE y FALSE, u ON y OFF. El uso de este tipo de variables hace ms claros y legibles los programas, a la par que disminuye la probabilidad de introducir errores. En realidad, las constantes enumeracin son los posibles valores de ciertas variables definidas como de ese tipo concreto. Las enumeraciones se crean con enum: enum nombre_de_la_enumeracin { }; Ejemplo 1: nombres de las constantes enum da {lunes, martes, mircoles, jueves, viernes, sbado, domingo}; Esta declaracin crea un nuevo tipo de variable el tipo de variable da que slo puede tomar uno de los 7 valores encerrados entre las llaves. Estos valores son en realidad constantes tipo int: lunes es un 0, martes es un 1, mircoles es un 2, etc. Ahora, es posible definir variables, llamadas dia1 y dia2, que sean de tipo da, en la forma (observe que en C deben aparecer las palabras enum da) enum da dia1, dia2; y a estas variables se les pueden asignar valores en la forma dia1 = martes; Los valores enteros que se asocian con cada constante tipo enumeracin pueden ser controlados por el programador. Por ejemplo, la declaracin,
enum da domingo};
{lunes=1,
martes,
mircoles,
jueves,
viernes,
sbado,
asocia un valor 1 a lunes, 2 a martes, 3 a mircoles, etc., mientras que la declaracin, enum da domingo}; {lunes=1, martes, mircoles, jueves=7, viernes, sbado,
asocia un valor 1 a lunes, 2 a martes, 3 a mircoles, un 7 a jueves, un 8 a viernes, un 9 a sbado y un 10 a domingo.
Tabla de operadores lgicos, aritmticos y de asignacin: Operador +, ++, -*, /, % >>, << & | ^ ~ ! ==, != &&, || <, <= >, >= Definicin suma, resta incremento, decremento multiplicacin, divisin, mdulo rotacin de bits a la derecha, izquierda. AND booleano OR booleano EXOR booleano complemento a 1 complemento a 2, NOT lgico igualdad, desigualdad AND, OR lgico menor, menor o igual mayor, mayor o igual
Tabla 11. Operadores
2.3. Funciones de Biblioteca

Uno de los principales objetivos de la programacin modular es la reutilizacin de cdigo, esto es escribir una funcin de manera que cualquier otra persona puede utilizarla en sus cdigos. En el estndar de C, se establecen una serie de funciones, denominadas de biblioteca; que cualquier compilador debe incorporar, de forma que cualquier programa que utilice dichas funciones pueda ser compilado sin errores en cualquier mquina. Existen funciones predefinidas, que se encuentran disponibles en la biblioteca estndar de C y nos sirven para; manipulacin de cadenas, manipulacin de caracteres, entrada/salida, verificacin de errores, y muchas otras operaciones tiles para cualquier programador de C. Esto hace que el trabajo del programador sea ms sencillo debido a que estas funciones proporcionan muchas de las capacidades que se requieren. Las funciones de la biblioteca estndar son parte del ambiente de programacin en C. Para usar las bibliotecas de funciones y las llamadas al sistema en un programa de C simplemente se debe llamar la funcin apropiada de C. Ejemplos de las funciones de la biblioteca estndar que han sido vistas son las funciones de E/S de alto nivel -fprintf(), malloc(), entrada y salida simples printf(), scanf(), operadores aritmticos, generadores de nmeros aleatorios como random(), srandom(), lrand48(), drand48(), etc. y funciones para conversin de cadenas a los tipos bsicos de C (atoi(), atof(), etc.) son miembros de la biblioteca estndar stdlib.h.
Todas las funciones matemticas como sin(), cos(), sqrt() son funciones de la biblioteca estndar de matemticas (math.h). Para muchas llamadas del sistema y funciones de las bibliotecas se tiene que incluir el archivo cabecera apropiado, por ejemplo: stdio.h, math.h. Para usar una funcin se debe asegurar de haber puesto los correspondientes #include en el archivo de C. De esta forma la funcin puede ser llamada correctamente, es importante asegurarse que los argumentos tengan los tipos esperados, de otra forma la funcin probablemente producir resultados extraos. La mayora de las bibliotecas contienen cientos de funciones utilizables que nos pueden ahorrar una cantidad importante de tiempo de programacin. Una biblioteca es una coleccin de funciones, proporcionadas por el compilador para utilizarse dentro de un programa, para usar una funcin de estas bibliotecas (libreras), se debe incluir el archivo de encabezado correspondiente que contiene el prototipo de la funcin y una vez listo; la funcin solo se usa (entonces la funcin realiza la operacin para lo que fue creada), y listo. El prototipo de encabezado contiene los prototipos correctos y simplemente tendrs que incluir el archivo de encabezado mediante la declaracin #include y luego se podr llamar a la funcin que se desee. Ejemplo: #include <stdio.h> Donde #include es el prototipo de encabezado y <stdio.h> es la biblioteca de C, en donde dentro de ella se encontrarn muchas funciones de biblioteca que se pueden usar dentro de un programa, las cuales ya realizan una funcin determinada, Ejemplos de algunas funciones que se encuentran en las diferentes bibliotecas: Biblioteca math.h Funciones Funciones acos ceil fabs ldexp pow tan Biblioteca string.h Funciones Funciones memchr memset strcoll strlen strpbrk strtok Biblioteca stdlib.h Funciones Funciones abort atoi abs atol atexit bsearch atof calloc
asin cos floor log sin tanh
atan cosh fmod log10 sinh
atan2 exp frexp modf sqrt
Tabla 12. Funcin math.h
memcmp strcat strcpy strncat strrchr strxfrm
memcpy strchr strcspn strncmp strspn
memmove strcmp strerror strncpy strstr
Tabla 13. Funcin string.h
div labs mbstowcs realloc strtoul Biblioteca stdio.h
exit ldiv mbtowc srand system
free malloc qsort strtod wctomb
getenv mblen rand strtol
Tabla 14. Funcin stdlib.h
Funciones Funciones clearerr fflush fopen fputs fseek getc printf remove setbuf tmpfile vprintf Biblioteca time.h Funciones Funciones asctime gmtime time clock localtime ctime mktime difftime strftime fclose fgetc formato fread fsetpos getchar putc rename setvbuf tmpnam vsprintf feof fgetpos fprintf freopen ftell gets putchar rewind sprintf ungetc ferror fgets fputc fscanf fwrite perror puts scanf sscanf vfprintf
Tabla 15. Funcin stdio.h
Tabla 16. Funcin time.h
Un ejemplo de un programa donde se usan dos funciones de biblioteca llamadas getchar() y putchar(), las cuales se encuentran respectivamente en la biblioteca stdio.h, sera el siguiente. Algoritmo: inicio declarar variables Entera c c getchar( ) mientras (c != EOF) hacer putchar(c) c getchar() fin_mientras pausa fin Programa: #include <stdio.h> void main() { int c; c = getchar(); while (c != EOF) {
putchar(c); c = getchar(); } getch(); } El mismo ejemplo solo un poco ms simple de realizar. Algoritmo: inicio declarar variables enteras c mientras ((c = getchar()) != EOF) hacer putchar(c) fin_mientras pausa fin Programa: #include <stdio.h> void main() { int c; while ((c = getchar()) != EOF) { putchar(c); }
}
Ejemplo que cuenta el nmero de caracteres de una cadena. Algoritmo: inicio declarer variables float nc nc 0 mientras ((getchar()) != EOF) hacer incrementar en uno nc escribir ( nc ) fin_mientras pausa fin Programa: #include <stdio.h> void main() { long nc; nc = 0; while ((getchar()) != EOF) ++nc;
printf("%ld\n", nc);
}
2.3.1 funciones de entrada y salida Cuando nos referimos a entrada/salida estndar (E/S estndar) queremos decir que los datos o bien se estn leyendo del teclado, bien se estn escribiendo en el monitor de video. Como se utilizan muy frecuentemente se consideran como los dispositivos de E/S por default y no necesitan ser nombrados en las instrucciones de E/S. En C no existe ninguna palabra clave para realizar la entrada y salida de datos (E/S). Se realizan a travs de funciones de biblioteca especficamente stdio.h. Las funciones principales que realizan la entrada y salida sin formato son: getchar(): Lee un carcter del teclado, espera hasta que se pulsa una tecla y entonces devuelve su valor. putchar(): Imprime un carcter en la pantalla en la posicin actual del cursor. gets(): Lee una cadena de caracteres introducida por el teclado y la sita en una direccin apuntada por su argumento de tipo puntero a carcter. puts(): Escribe su argumento de tipo cadena en la pantalla seguida de un carcter de salto de lnea. El siguiente fragmento de cdigo lee un carcter del teclado y lo muestra por pantalla. A continuacin lee una cadena (de 10 caracteres incluido el carcter nulo) y tambin la muestra por pantalla: Algoritmo: inicio declarar variables carcter cadena[10] entera i i getchar( ) putchar( i ) escribir ( Digita una cadena de caracteres ) gets (cadena) escribir ( Imprime la cadena de caracteres ) puts (cadena) pausa fin Programa: #include <stdio.h> main() { char cadena[10]; int i; i=getchar(); putchar(i); printf( Digita una cadena de caracteres \n );
gets(cadena); printf( Imprime la cadena de caracteres \n); puts(cadena); getch(); } Las funciones principales que realizan la entrada y salida con formato, es decir, se pueden leer y escribir en distintas formas controladas, son: printf(): Escribe datos en la consola con el formato especificado. scanf(): Funcin de entrada por consola con el formato especificado. Su sintaxis es la siguiente: printf (" caracteres de transmisin y escape", lista de argumentos); scanf (" caracteres de transmisin y escape", lista de argumentos); Ejemplos: cdigo en C printf( Hola como estas ); int j; j=100; printf( Tu resultado es: flota y; y=45.45; printf( El valor Impresin en pantalla Hola como estas
%d
, j );
Tu resultado es:
100
%f
, corresponde a la variable y , y);
El valor 45.45, corresponde a la variable y Los caracteres de transmisin son precedidos de un % para distinguirlos de los normales: Caracteres de transmisin y el argumento que transmite: Caracteres de transmisin Tipo de dato Int: un carcter simple Char *: una cadena de caracteres Int: un nmero decimal octal sin signo hexadecimal sin signo decimal sin signo Float o double, en notacin fija Float o double, en notacin cientfica Float o double en notacin cientfica si el exponente es menor de diez a la menos cuatro, o fija en caso contrario. escribe el nmero que corresponde al puntero Escribe un signo de %
Tabla 17. Modificador y su argumento
Modificador %c %s %d %i %o %x %X %u %f %e %E %g %G %p %% .
Una l precediendo al tipo (por ejemplo, %l5d) significa que transmitiremos un long int, si, por el contrario, es una h significa que transmitiremos un short int. Existe otro tipo de carcter especial, los caracteres de escape, que tienen un significado especial. Los caracteres de escape son los siguientes: Caracteres de escape Significado Nueva lnea Tabulador Espacio atrs Retorno de carro Comienzo de pgina Pitido sonoro Comilla simple Comilla doble Barra invertida Cdigo ASCII en notacin hexadecimal (cada d representa un dgito) Cdigo ASCII en notacin octal (cada d representa un dgito)
Tabla 18. Caracteres de escape
Carcter de escape \n \t \b \r \f \a \ \" \\ \xdd \ddd
La lista de argumentos estar separada por comas. Debe existir una correspondencia directiva entre los caracteres de transmisin (aquellos que comienzan con un %) y la lista de argumentos a transmitir. Cabe destacar una diferencia en la lista de argumentos entre las funciones printf() y scanf(). En est ultima funcin (scanf()), la lista de argumentos va precedida por el operador de direccin(&), puesto que scanf() requiere que los argumentos sean las direcciones de las variables, en lugar de ellas mismas. Ejemplo de printf() con scanf(); Algoritmo: Inicio Declarar variables Enteras ent1 Enteras ent2 Enteras suma Escribir ( Introducir el primer nmero ) Leer ent1 escribir ( Introducir el segundo nmero ) leer ent2 suma ent1 + ent2 escribir ( La suma es , suma ) pausa fin Programa: ama suma /* Programa suma */ #include <stdio.h>
int main() { int ent1; /* declaracin de variable, es el primer nmero */ int ent2; /* segundo nmero a introducir por el usuario */ int suma; /* variable en donde se guardar la suma */ printf(Introducir el primer nmero \n); /* Indicacin */ scanf(%d,&ent1); /* Lectura de primer entero*/ printf(Introducir el segundo nmero \n); /* Indicacin */ scanf(%d,&ent2); /* Lectura del segundo entero*/ suma=ent1+ent2; /* Realiza la suma */ printf(La suma es %d \n); /* Imprime la suma */ return 0; /* Indica que el programa termin con xito*/ getch(); } scanf(%d,&ent1); %d es una cadena de control de formato, en ste caso indica que el usuario introducir un entero (int ent1;) printf(La suma es %d \n, suma); %d es una cadena de control de formato, en ste caso indica que se imprimir el valor numrico de la variable suma Al declarar las variables enteras ent1, ent2, suma en C, en realidad corresponde a lugares en la memoria de la computadora. int ent1; Toda variable en C tiene un nombre, un tipo, y un valor. Cuando la instruccin scanf(%d,&ent1); se ejecuta el valor escrito por el usuario se colocar en una direccin o localidad de la memoria donde se le haya asignado a la variable ent1.
2.3.2. Funciones matemticas Para poder usar las funciones matemticas, se debe usar la biblioteca de funciones matemticas que permite al programador reutilizar ciertos clculos matemticos comunes, esta es biblioteca <math.h>. La biblioteca de matemticas es relativamente fcil de usar, al igual que las vistas previamente. Se debe incluir la directiva de preprocesamiento #include <math.h>, y entonces se podrn utilizar todas las funciones que se encuentren en dicha librera, como las que se enlistaron en las funciones de biblioteca anteriormente. Se muestra a continuacin una lista de funciones matemticas. Son fciles de usar y algunas de ellas han sido ya usadas previamente. Funciones Matemticas Calcula el arco coseno de x. Calcula el arco seno de x. Devuelve el arco tangente en radianes.
double acos(double x) double asin(double x) double atan(double x)
double atan2(double y, double x)
Calcula el arco tangente de las dos variables x e y. Es similar a calcular el arco tangente de y / x, excepto en que los signos de ambos argumentos son usados para determinar el cuadrante del resultado. Redondea x hacia arriba al entero ms cercano. Devuelve el coseno de x, donde x est dado en radianes. Devuelve el coseno hiperblico de x. Devuelve el valor de e (la base de los logaritmos naturales) elevado a la potencia x. Devuelve el valor absoluto del nmero en punto flotante x. Redondea x hacia abajo al entero ms cercano. Calcula el resto de la divisin de x entre y. El valor devuelto es x - n * y, donde n es el cociente de x / y. Se emplea para dividir el nmero x en una fraccin normalizada y un exponente que se guarda en exp.
double ceil(double x) double cos(double x) double cosh(double x) double exp(double x)
double fabs(double x) double floor(double x) double fmod(double x, double y) double *exp) frexp(double x, int
long int labs(long int j) double ldexp(double x, int exp) double log(double x); double log10(double x) double modf(double x, double *iptr) double pow(double x, double y) double sin(double x) double sinh(double x) double sqrt(double x) double tan(double x) double tanh(double x)
Divide el argumento x en una parte entera y una parte fraccional. La parte entera se guarda en iptr. Devuelve el valor de x elevado a y.
Tabla 19. Funciones Matemticas
Estas funciones matemticas, realizan una funcin especfica para lo que fueron creadas y el programador no tiene que preocuparse por crear el cdigo para realizar dicha funcin, nicamente las tiene que utilizar dentro del programa que lo desee.
2.4. Funciones Generadas por el usuario

La experiencia ha demostrado que la mejor manera de desarrollar y mantener un programa grande es construirlo a partir de piezas o componentes mas pequeos, esta tcnica se llama divide y vencers. Las funciones son bloques de programa que definen tareas especficas, las cuales pueden utilizarse en diversos puntos del programa, estas funciones es en donde se produce toda la actividad que realiza un programa. C fu diseado como un lenguaje de programacin estructurado, tambin llamado programacin modular. Por esta razn, para escribir un programa se divide ste en varios
mdulos, en lugar de uno solo largo. El programa se divide en muchos mdulos (rutinas pequeas llamadas funciones). Ejemplo de ello se muestra en el esquema siguiente, como los procesos (funciones) estn aparte del programa principal y son llamados por l, en el lugar adecuado. PRINCIPAL PROCESO A PROCESO B
INICIO
INICIO
INICIO
PROCESO A
PROCESO A
PROCESO B
PROCESO B
FIN
FIN
FIN Figura 1. Funciones
Una funcin es un conjunto de lneas de cdigo que realizan una tarea especfica y puede retornar un valor. Las funciones pueden tomar parmetros que modifiquen su funcionamiento. Las funciones son utilizadas para descomponer grandes problemas en tareas simples y para implementar operaciones que son comnmente utilizadas durante un programa y de esta manera reducir la cantidad de cdigo. Cuando una funcin es invocada se le pasa el control a la misma, una vez que esta finaliz con su tarea el control es devuelto al punto desde el cual la funcin fue llamada. As pues, un programa en C se compone de varias funciones, cada una de las cuales realiza una tarea principal. Una funcin es, sencillamente, un conjunto de sentencias que se pueden llamar desde cualquier parte de un programa. Las funciones permiten al programador un grado de abstraccin en la resolucin de un problema. Las funciones en C no se pueden anidar. Esto significa que una funcin no se puede declarar dentro de otra funcin. La razn para esto es permitir un acceso muy eficiente a los datos. En C todas las funciones son externas o globales, es decir pueden ser llamadas desde cualquier punto del programa. Si un programa contiene varias funciones, sus definiciones deben aparecer en cualquier orden, pero deben ser independientes unas de otras. Existen dos tipos de funciones: funciones predefinidas (de biblioteca) y las funciones creadas por el programador. Una funcin se invoca (es decir, se hace que realice la tarea para la que fue creada) mediante una llamada a la funcin. La llamada a la funcin especifica el nombre de la funcin y proporciona informacin (como argumentos) que la funcin invocada necesita para hacer su trabajo. Todas las variables definidas dentro de una funcin, son variables locales que solo se conocen dentro de la funcin en la que se definen, esta comienza a existir cuando se entra a la funcin y se destruye al salir de ella. As, las variables locales no pueden conservar sus valores entre distintas llamadas a la funcin. Los dos puntos importantes para la creacin de una funcin son los siguientes: la reutilizacin de cdigo (ya que la funcin se puede utilizar cuantas veces
sea necesario dentro de un programa y as no escribirla mas de una vez), y la otra es que un programa se pueda dividir en bloques de sentencias mas simples y pequeas, para su mejor solucin. Cada funcin se debe limitar para que realice una tarea sencilla y bien definida, y el nombre de la funcin debe expresar de manera efectiva dicha tarea, ya que este tipo de funciones son creadas dependiendo de la necesidad del usuario sobre un determinado problema. Esto promueve la reutilizacin de cdigo que es esencial en la programacin. El tipo devuelto por una funcin, debe ser compatible con el tipo que se espera que devuelva en la funcin de llamada, o el compilador dar un warning. Forma general de una funcin: tipo_dev nombre_de_la_funcin { Cuerpo de la funcin } (lista de parmetros)
El tipo_dev especifica el tipo de dato que devuelve la funcin. Una funcin puede devolver cualquier tipo de dato excepto un array. El nombre de la funcin es cualquier identificador vlido, la lista de parmetros es una lista de nombres de variables separados por comas con sus tipos asociados. Los parmetros reciben los valores de los argumentos cuando se llama a la funcin. Una funcin puede no tener parmetros, en cuyo caso la lista de parmetros est vaca y por lo tanto se puede usar la palabra clave void entre los parntesis. Por ejemplo, aqu se muestra una declaracin de funciones con parmetros correcta ya que a cada variable le corresponde un tipo e incorrecta porque a algn parmetro le hace falta su tipo y esto es un error: void F(float r, int v, flota j); void F(float t,g, float h); /* correcto */ /* incorrecto */
Los parmetros de una funcin tambin se conocen dentro de ella nicamente, estos comienzan a existir cuando se entra a la funcin y se destruyen al salir de ella. Ejemplos de funciones sin parmetros Algoritmo: declarar funcin cuadrado( ) inicio declara variable real res y N limpiar pantalla escribir ( Programa que obtiene mediante una funcin el cuadrado de un numero ) llamar a funcin cuadrado( ) escribir ( Fin de nuestro programa ) pausa fin funcin cuadrado( ) inicio escribir ( Funcin Cuadrado ) escribir ( Da el numero a evaluar ) leer N res N * N escribir ( El cuadrado de , N , es: , res) escribir ( Fin de la Funcin ) fin_cuadrado
Programa: #include <stdio.h> #include <stdlib.h> #include <conio.h> void cuadrado( ); void main( ) { float res,N; clrscr( ); printf(Programa que obtiene mediante una funcin el cuadrado de un numero \n ); cuadrado( ); printf( Fin de nuestro programa ); getch( ); } void cuadrado( ) { printf( \n Funcin Cuadrado \n ); printf( Da el numero a evaluar \n ); scanf(%f,&N); res = N * N; printf( El cuadrado de %f es: %f , N,res); printf( \n Fin de la Funcin ); } El siguiente programa nos muestra a dos funciones sin parmetros, las cuales se mandan llamar dentro del programa principal main( ). Algoritmo: declarar funcin1( ) declarar funcion2( ) inicio limpiar pantalla escribir ( Programa que desarrolla dos funciones ) llamar a funcin1( ) llamar a funcion2( ) return 0 escribir ( Fin de nuestro programa ) pausa fin funcin funcion1( ) inicio escribir ( Funcin Uno ) escribir ( La funcin uno no toma argumentos ) escribir ( Fin de la funcin uno ) fin_funcion1 funcin funcion2( ) inicio escribir ( Funcin Dos ) escribir ( La funcin dos tampoco toma argumentos ) escribir ( Fin de la funcin dos )
fin_funcion2 Programa: #include <stdio.h> #include <stdlib.h> #include <conio.h> void funcion1( ); void funcion2( void); int { main( ) clrscr( ); printf(Programa que desarrolla dos funciones \n ); Funcion1( ); /* llama a la funcin 1 sin argumentos */ Funcion2( ); /* llama a la funcin 2 sin argumentos */ return 0; /* indica terminacin exitosa */ printf( Fin de nuestro programa ); getch( ); /* fin del main */ ) \n Funcin Uno \n ); La funcin uno no toma argumentos \n Fin de la Funcin uno ); /* declaracin de una funcin */ /* declaracin de una funcin */
void funcion1( { printf( printf( printf( }
\n );
/* La funcin dos en su lista de parmetros tiene la palabra void para especificar que la funcin no recibe parmetros */ void funcion2(void ) { printf( \n Funcin Dos \n ); printf( La funcin dos tampoco toma argumentos printf( \n Fin de la Funcin dos ); }
\n );
En caso de tener una lista de parmetros la funcin, su forma general sera: tipo_dev funcin ( tipo var1, tipo var2, tipo var3, , tipo varN ) Por ejemplo, a continuacin se muestran unos ejemplos de declaraciones correctas e incorrectas de los parmetros de una funcin: void f( int i, int l, int m); /* declaraciones correctas */ void f( float g, int h, float y); void f( int k, float u, float k, int r); void f( int g,h,j ); void flota(float f,j,r ); /* declaraciones incorrectas, cada variable debe */ /* tener su propio tipo */
void f( float g,t, int g,h );
Los parmetros formales tienen que ser del mismo tipo que los argumentos usados al llamar una funcin (el compilador no dar error pero los resultados sern inesperados). Al igual que con variables locales, se pueden hacer asignaciones a los parmetros de una funcin o usarlos en cualquier expresin vlida. Se pueden usar como cualquier otra variable. Una funcin es visible para ella misma y otras funciones desde el momento en que se define. Es visible para el propio cuerpo de la funcin, es decir, la recursividad esta permitida. El cdigo de una funcin es privado a esa funcin y slo se puede acceder a l mediante una llamada a esa funcin. Las variables definidas dentro de una funcin son locales (a no ser que las definamos globales) por lo que no conservan su valor de una llamada a otra. mbito de una funcin: El mbito en un lenguaje son las reglas que controlan si un fragmento de cdigo conoce o tiene acceso a otro fragmento de cdigo o de datos. El mbito de una funcin determina no slo en qu partes de un programa se puede llamar a esa funcin, sino tambin a qu definiciones tiene acceso la funcin. Las mismas reglas de mbito que se aplican a los identificadores de variable se aplican a los identificadores de funcin. Una funcin declarada en el mbito global estar disponible en todo el cdigo. Llamada a una funcin: Las funciones son llamadas para su ejecucin desde cualquier parte del cdigo, teniendo en cuenta que antes deben haber sido declaradas (y por supuesto definidas). nombre_funcin (void); nombre_funcin ( m, t); // sin parmetros //con parmetros
La llamada de una funcin se produce mediante el uso de su nombre en una sentencia, pasando una lista de argumentos que deben coincidir en nmero y tipo con los especificados en la declaracin (en otro caso se producira una conversin de tipos o resultados inesperados). Las llamadas a las funciones solo cambian si estas contiene parmetros o no, si no tienen simplemente se pone la palabra void dentro de los parntesis y si tienen parmetros se pone la lista de las variables en cuyo espacio caer el valor dado en el programa principal. A continuacin se muestra un programa ejemplo, con parmetros. Ejemplo de funcin con parmetros Algoritmo: declarar funcin haz_algo( entero alas, real pies, entero ojos ) inicio declara variable entera ala 10 real pie 100.55 entero ojo 20 limpiar pantalla escribir ( Programa de dos funciones con parmetros ) llamar a funcin haz_algo( 3, 12.5, 4 ) llamar a la funcin haz_algo ( ala, pie, ojo ) escribir ( Fin de nuestro programa ) pausa fin
funcin haz_algo(entero alas, real pies, entero ojos ) inicio escribir ( Hay ala alas ) escribir ( Hay pie pies ) escribir ( Hay ojo ojos ) fin_haz_algo Programa: #include <conio.h> #include <stdio.h> #include <iostream.h> void haz_algo (int alas, float pies, int ojos); void main( ) { int ala = 10; float pie = 100.55; int ojo = 20; clrscr(); printf( Programa de dos funciones con parmetros \n ) haz_algo (3, 12.5, 4); haz_algo (ala, pie, ojo); printf( Fin de nuestro programa ); getch(); } void haz_algo (int alas, { printf ( " \n Hay printf ( " \n Hay printf ( " \n Hay } La salida de este programa ser: Hay 3 alas. Hay 12.5 pies. Hay 4 ojos. Hay 10 alas. Hay 100 55 pies. Hay 20 ojos. 2.4.1. Argumentos y Parmetros Formales Llamamos parmetros a la lista de argumentos que dentro de una funcin se encuentran encerrados entre parntesis ejemplo de ellos es: float Promedio(int A, int B) { float r; r=(A+B)/2.0; return r; } float pies, int ojos) %d %f %d alas. \n ", alas); pies. \n ", pies); ojos. \n ", ojos);
En donde (int A, int B) es la lista de parmetros que tiene esta funcin, los cuales son utilizados dentro de ella para realizar un determinado clculo, en lenguaje C se contemplan dos formas de pasar argumentos a las subrutinas, esto es pasarle valores a los parmetros que tiene la funcin, tantos parmetros tenga sern los argumentos que se enviarn a la funcin. Caractersticas de los parmetros: Representados por variables de un tipo dados Incluyen informacin que es vlida nicamente dentro de la funcin Esta informacin puede modificarse a nivel local, (dentro de la funcin). Segn el tipo de paso de parmetros la informacin volver a tomar el valor con que entr, o el de la ltima modificacin. Existen dos tipos de paso con parmetros: 1.- Por valor: valor que entra es el mismo que con el que sale 2.- Por direccin: si el parmetro es modificado, este tomar el de la ltima modificacin. Los mtodos son dos: llamadas por valor y por referencia. En general, se pueden pasar argumentos a las funciones de dos formas, por valor y por referencia. La llamada por valor copia el valor de un argumento en el parmetro formal de la funcin. De esta forma, los cambios en los parmetros de la funcin no afectan a las variables que se usan en la llamada (es la llamada ms usual, es decir, en general no se pueden alterar las variables usadas para llamar a la funcin). La llamada por referencia copia la direccin del argumento en el parmetro. Dentro de la funcin se usa la direccin para acceder al argumento usado, significando que los cambios hechos a los parmetros afectan a la variable usada en la llamada. Ejemplos de funcin con parmetros: Sintaxis: Tipo_Retorno nombre_funcin (argumentos) { Sentencias; } Algoritmo: funcin entera suma(entero a, entero b ) inicio retorna ( a + b ) fin_suma inicio declara variable entera x 6
entero y 7 limpiar pantalla resultado suma ( 6 , 7 ) escribir ( Resultado: , resultado ) escribir ( Fin de nuestro programa ) return 0 pausa fin Programa: #include <stdio.h> int suma(int a,int b) { return (a + b); } int main { int x = 6,y = 7; int resultado; clrscr(); resultado = suma(6,7); printf(" Resultado: %d\n",resultado); printf( Fin de nuestro programa ); return 0; getch(); } Ejemplo de paso por valor: Algoritmo: funcin entera valor_a(entero var_1 ) inicio escribir ( Valor de la Var_1 : , decremento var_1 ) retorna 0 fin_valor_a inicio declara variable entera var_1 5 limpiar pantalla escribir ( Valor de var_1 : , var_1 ) llamar a funcin valor_a ( var_1 ) escribir ( Fin de nuestro programa ) return 0 pausa fin Programa: #include <stdio.h> int valor_a (int var_1) { printf( Valor de a Var_1 : %d \n ,-var_1); return 0; } int main (void)
{ int var_1 = 5; clrscr(); printf( Valor de a Var_1 : %d \n ,var_1); valor_a(var_1); printf( Fin de nuestro programa ); return 0; } El valor que debe devolver una funcin se indica con la palabra return. La evaluacin de la expresin debe dar una valor del mismo tipo de dato que el que se ha definido como resultado. La declaracin de una variable puede incluir una inicializacin en la misma declaracin. Se debe tener muy en cuenta que en C todos los argumentos son pasados 'por valor'. No existe el concepto de paso de parmetros 'por variable' o 'por referencia'. Veamos un ejemplo: Algoritmo de la funcin: funcin entera incremento (entero v ) inicio retorna ( v + 1 ) fin_incremento inicio declara variable entera a , b limpiar pantalla b3 a incremento ( b ) / * a = 4 mientras que b = 3 por lo tanto b no ha cambiado su valor despus de la llamada a la funcin * / pausa fin Programa de la funcin: int incremento ( int v ) { return v + 1; } main (void ) { int a, b; clrscr(); b = 3; a = incremento(b); /* a = 4 mientras que b = 3 por lo tanto b no ha cambiado su valor despus de la llamada a la funcin */ getch(); } En el ejemplo anterior el valor del parmetro de la funcin incremento, aunque se modifique dentro de la funcin, no cambia el valor de la variable b de la funcin main. Todo el texto comprendido entre los caracteres /* y */ son comentarios al programa y son ignorados por el compilador.
Si quisiramos modificar el valor de los argumentos sera necesario pasar como argumento su direccin de memoria esto se hara utilizando punteros. A esto se le llama paso de parmetros por referencia. 2.4.2. Funciones con y sin argumentos Las funciones que no tienen dentro de los parntesis del nombre de la funcin ningn parmetro (variable), se dice que son funciones sin argumentos, por lo tanto este tipo de funciones no devuelve ningn valor al programa principal, esto es; el programa principal no recibe ningn resultado para mostrarlo en su ejecucin. Entonces los programas que tienen funciones que no tienen argumentos, solo realizan sus lneas y al momento de mandar llamar a la funcin realizan todo lo que este dentro de la funcin, despus devuelven el mando al programa principal y este contina con sus propias lneas, un ejemplo de un programa con una funcin que no tienen argumentos, sera algo como lo siguiente: Algoritmo: Declarar funcin hola( ) inicio limpiar pantalla escribir ( Que tal ) llamar a la funcin hola( ) pausa fin funcin hola ( ) inicio escribir ( Hola a todos, este es un ejemplo de mensaje de una funcin ) escribir ( Hasta pronto amigos ) fin_hola Programa: #include<stdio.h> #include<conio.h> void hola(); /* Declaracin de la funcin hola() */ void main( ) { clrscr(); printf( Que tal \n ); hola(); getch(); } void hola() /* No existen parmetros dentro de los parntesis del nombre de la funcin */ { printf( Hola a todos, este es un ejemplo de mensaje de una funcin \n ); printf( Hasta pronto amigos ); } Al correr el siguiente programa se vera como sigue:
Que tal Hola a todos, este es un ejemplo de mensaje de una funcin Hasta pronto amigos Otro ejemplo de funciones sin argumentos, es el siguiente programa; que calcula la diferencia en minutos entre dos horas distintas dadas desde el teclado por el usuario. La funcin se llama minutos(), si observan dentro de los parntesis no va ningn tipo de parmetros, esto la hace una funcin sin argumentos que no devuelve al compilador ningn valor, para despus mostrarlo, acepta el tiempo que el usuario introduce en horas y minutos y lo convierte a minutos, devolviendo este valor en un tipo entero. La funcin presenta la particularidad de no tener argumentos. Ejemplo Algoritmo: Declarar funcin minutos( ) inicio limpiar pantalla declarar variables enteras minutos1, minutos2 escribir ( Escribe la primer hora (formato 3:22): ) minutos1 minutos( ) escribir ( Escribe la segunda hora (posterior): ) minutos2 minutos( ) escribir ( La diferencia es , minutos2 minutos1 , minutos ) pausa fin funcin entera minutos ( ) inicio declarar variables enteras horas, mins escribir ( Da las horas y los minutos ) leer ( horas , mins ) return ( horas * 60 + mins ) fin_minutos Programa: /* Programa que calcula la diferencia entre dos horas distintas */ #include <stdio.h> int minutos(void); void main(void) { clrscr(); int minutos1, minutos2; printf("Escribe la primera hora (formato 3:22): "); minutos1=minutos(); /* obtiene los minutos */ printf("Escribe la segunda hora (posterior): "); minutos2=minutos(); /* obtiene los minutos*/ printf("La diferencia es %d minutos.\n", minutos2-minutos1); getch(); } int minutos(void) { int horas, mins; printf(Da las horas y los minutos \n ); scanf("%d:%d", &horas, &mins);
return (horas*60+mins); } La funcin return, le sirve al compilador para regresar al comando principal del programa la operacin ah expuesta, en este ejemplo devolver al programa principal la operacin que resulta de (horas*60+mins) Por otro lado las funciones con argumentos son aquellas que dentro del parntesis si tienen valores o variables, las cuales se usan dentro de cada funcin para realizar algo, y despus devolverlo al programa principal par mostrarlo. En C todos los argumentos que se pasan a una funcin se pasan por valor. En otras palabras, se pasa una copia del valor del argumento y no el argumento en s (por ello, este procedimiento se conoce en algunas ocasiones como paso por copia). Al pasar una copia del argumento original a la funcin, cualquier modificacin que se realice sobre esta copia no tendr efecto sobre el argumento original utilizado en la llamada de la funcin. Se puede considerar un argumento pasado por valor como una variable local de la funcin a la que se ha pasado, de tal modo que los cambios que se realicen sobre sta tendrn efecto slo dentro de la funcin. Supongamos que en un determinado programa debemos calcular repetidamente el valor medio de dos variables, una solucin razonable sera crear una funcin que realice dicho clculo, y llamarla cada vez que se necesite. Para ello ser necesario, en cada llamada, pasarle los valores de las variables para que calcule su valor medio. Esto se define en la declaracin de la funcin especificando, no solo su valor de retorno sino tambin el tipo de argumentos que recibe: double valor_medio(double x, double y) ; De esta declaracin vemos que la funcin valor_medio recibe dos argumentos ( x e y ) del tipo double, por lo tanto devuelve un resultado de ese mismo tipo . Cuando definamos a la funcin en s, deberemos incluir parmetros para que alberguen los valores recibidos, as escribiremos: double valor_medio(double x, double y ) { return ( (x + y) / 2.0 ) } No es necesario que los nombres de los parmetros coincidan con los declarados previamente, es decir que hubiera sido equivalente escribir: double valor_medio(double a, double b) etc, sin embargo es una buena costumbre mantenerlos igual. En realidad en la declaracin de la funcin, no es necesario incluir el nombre de los parmetros, bastara con poner solo el tipo, sin embargo es prctica generalizada, explicitarlos a fin de hacer ms legible al programa. Por ejemplo, en la creacin de la funcin se puede poner de estas dos maneras y es totalmente correcto: double valor_medio(double x, double y) double valor_medio(double, double) Sin embargo es preferible utilizar la nomenclatura moderna, ya que esta facilita la rpida comprensin del programa. Veamos un ejemplo, para determinar el comportamiento de los parmetros, supongamos desear un programa que calcule el valor medio de dos variables incrementadas en un valor fijo, es decir:
( ( x + incremento ) + ( y + incremento ) ) / 2.0 Lo podramos resolver de la siguiente forma : Algoritmo: declarar funcin double valor_medio(double p_valor, double s_valor, double inc ) inicio limpiar pantalla declarar variables double x, y, z escribir ( Ingresa el primer valor ) lee x escribir ( Ingresa el segundo valor ) leer y escribir ( ingresa el incrementeo ) leer z llamar a la funcin valor_medio ( x, y. z ) escribir ( Valor con que quedaron las variables ) escribir ( Primer valor: , x ) escribir ( Segundo valor: y ) escribir ( Incremento: , z ) pausa fin funcin double valor_medio (double p_valor, double s_valor, double inc ) inicio declarar variable double resultado p_valor p_valor + inc s_valor s_valor + inc res (p_valor + s_valor ) / 2.0 escribir ( Tu resultado del valor medio es: , res ) fin_valor_medio
Programa: #include <stdio.h> /* Declaracin de la funcin y el tipo de sus parmetros */ double valor_medio(double p_valor, double s_valor, double inc); void main() { clrscr(); double x, y, z; printf(Ingrese el primer valor: ) ; scanf(% lf, &x ) ; printf(\n Ingrese el segundo valor: ); scanf(% lf, &y ) ; printf(\n Ingrese el incremento : ); scanf(% lf, &z) ; valor_medio( x, y, z ); /* llamada a la funcin y pasaje de argumentos */ printf(\n\n Valor con que quedaron las variables: ) ;
printf(\n Primer valor : %lf , x ) ; printf(\n Segundo valor: %lf , y ) ; printf(\n Incremento : %lf , z ) ; getch(); } /* Definicin de la funcin y sus parmetros */ double valor_medio( double p_valor, double s_valor, double inc ) { double resultado; p_valor += inc; s_valor += inc; resultado =( (p_valor + s_valor ) / 2.0 ); printf( Tu resultado del valor medio es: %lf , resultado); } Cabe destacar que el resultado de esta funcin esta dado dentro de la misma, en la funcin se van los valores dados desde el teclado, en ella se evalan y se despliega el valor ah mismo, por lo tanto al mandar llamarla, desglosa todo y luego el programa principal contina desglosando los valores individuales de las variables. 2.4.3. Funciones que regresan valores La funcin en si misma es llamada definicin de la funcin y generalmente contiene un pequeo programa. La primera lnea de la definicin de la funcin se llama encabezado de la funcin y es idntico al prototipo de la funcin con la diferencia que no termina con ; El cuerpo de la funcin se encierra entre llaves { }. Su sintaxis dentro de lenguaje C es la siguiente: Tipo_dato nombre_funcin(argumento formal 1, argumento formal 2, argumento N ); ...
La especificacin del tipo de valor devuelto por la funcin, seguido del nombre de la funcin y (opcionalmente) un conjunto de argumentos, separados por comas y cerrados entre parntesis y punto y coma al final del prototipo. Despus del nombre de la funcin deben seguir un par de parntesis vacos si la definicin de la funcin no incluye ningn argumento con o sin la palabra void. El estndar ANSI C permite que el tipo de datos de cada argumento sea seguido del nombre del argumento dentro de la declaracin de la funcin, es decir, tipo_dato nombre_funcin (tipo1 arg1, tipo2 arg2, ... , tipoN argN); en donde arg1, .., argN hacen referencia al primer argumento, al segundo , etc. Las declaraciones de funciones escritas de est forma se llaman prototipos de funciones. Despus del encabezado y de abrir la llave de inicio se debern declarar las variables locales. La funcin termina con la sentencia return(0) que marca el final de la funcin. Cuando la funcin termina el control del programa retorna a la funcin main a el mismo lugar donde fue llamada la funcin. La definicin de la funcin se define despus de cerrar la llave del main. La sentencia return tambin hace que se devuelva el control al punto de llamada. Slo se puede incluir una expresin (variable u operacin) en la sentencia return. Por lo tanto, una funcin slo puede devolver un valor al punto de llamada mediante la sentencia return. Una definicin de funcin puede incluir varias sentencias return, conteniendo cada una de ellas una expresin distinta. Las funciones que incluyen varias bifurcaciones suelen requerir varias sentencias return. La sentencia return puede no incluirse en la definicin de una funcin, aunque esto se considera generalmente como una programacin pobre. Si una funcin alcanza el final del bloque sin encontrarse una sentencia return, se devuelve el control al punto de llamada sin devolverse ninguna informacin. Se recomienda utilizar en estos casos una sentencia return vaca. Cuando una funcin no va a regresar ningn valor se antecede la
palabra void al nombre de la funcin, pero si esta si va a devolver un valor, entonces se antecede la palabra del tipo de dato que devolver ejemplo (int, float, double). La funcin se realiza en el momento en que desde el programa principal se hace referencia a su nombre, o dicho en otras palabras, en el momento en que se llama la funcin. Hay dos formas de llamar una funcin. Escribiendo su nombre como una instruccin (esto es para funciones sencillas que no regresan valor). Otra forma es escribiendo su nombre y la lista de parmetros (para funciones complejas con parmetros). El llamado de la funcin se puede hacer en cualquier momento, en cualquier posicin dentro de nuestro programa. Se puede llamar a una funcin especificando su nombre, seguido de una lista de argumentos cerrados entre parntesis y separados por comas. Si la llamada a la funcin no requiere ningn argumento, se debe escribir a continuacin del nombre de la funcin un par de parntesis vacos. La llamada a la funcin puede aparecer sola, o puede ser uno de los operandos de una expresin ms compleja. Ejemplos de funciones que regresan valores al comando principal del programa seran: Algoritmo que obtiene el cubo de un nmero dado desde el teclado: declarar variables globales flotantes res, num flotante cubo ( entero x ) inicio escribir ( Ingrese un nmero ) leer ( num ) res cubo ( num ) escribir ( num , al cubo es: , res ) return 0; fin function flotante cubo( entera x ) inicio return x*x*x fin_cubo Programa: #include<stdio.h> float num; float res, cubo(int x);
main() { printf("ingrese un nmero "); scanf("%f",&num); res = cubo(num); printf("%f al cubo es: %f " ,num, res); return 0; } float cubo(int x) {return x*x*x;} Otro ejemplo de una funcin que regresa un valor al programa principal, es la siguiente de la potencia de un nmero dando desde el teclado, la base y la potencia a la cual se quiere elevar.
Algoritmo: declarar variables globales enteras b, e flotante potencia ( entero m, entero n ) inicio escribir ( INGRESE DOS NUMEROS.. ) leer ( b , e ) escribir ( potencia ( b , e ) ) pausa fin function flotante potencia ( entera m, entera n ) inicio declarar variables entera i flotante y y1 desde i = 1 hasta i < = n incremento 1 hacer yy*m return y fin_cubo Programa: #include<stdio.h> #include <math.h> int b, e; float potencia(int m, int n); main(void) { printf(" INGRESE DOS NMEROS.. scanf("%d %d",&b,&e); printf("%f",potencia(b, e)); getch(); } float potencia(int m, int n) { int i; float y; y=1; for(i=1;i<=n;i++) y=y*m; return y; } Si se observa muy bien el programa anterior, notar que la funcin potencia recibe dos parmetros (m y n), pero solo devuelve al programa principal un valor de retorno (y), que es el que se muestra en el segundo printf del programa principal main().
");
El siguiente ejemplo no regresa un valor al programa principal, sino solamente imprime en pantalla los valores de rea y longitud, al llamar a la funcin circulo (). Algoritmo: declarar variables globales entera r funcin circulo ( entero m ) inicio limpiar pantalla escribir ( INGRESE EL VALOR DEL RADIO.. ) leer ( r ) llamar a funcin circulo ( r ) pausa fin function circulo ( entera m ) inicio declarar variables flotante pi pi 3.1416 escribir ( AREA: , pi * m * m ) escirbir ( LONGITUD: , 2 * pi * m ) fin_cubo Programa: #include<stdio.h> int r; void circulo(int m); main(void) { clrscr(); printf(" INGRESE EL VALOR DEL RADIO.. "); scanf("%d",&r); circulo(r); // llamada a un procedimiento getch(); } void circulo(int m) { // procedimiento
float pi; pi=3.1416; printf("AREA: %f \n ", pi*m*m); printf("LONGITUD: %f ", 2*pi*m); } El siguiente programa que tiene la funcin intercambio( ), muestra los valores dentro de la funcin, cuando sta es mandada a llamar por el programa principal. La funcin contiene dos parmetros (x, y); que toman los valores que se ingresan en el programa principal como (a,b), para procesarlos dentro de la funcin e intercambiar sus valores, luego entonces ser mostrados en el printf de la funcin.
Algoritmo: declarar funcin intercambio ( entera x, entera y ) declarar variables globales enteras temp, a , b inicio limpiar pantalla escribir ( Ingrese a: ) leer ( a ) escribir ( Ingrese b: ) leer ( b ) llamar a la funcin intercambio ( a , b ) pausa fin function intercambio ( entera x, entera y ) inicio temp x xy y temp escribir ( Nuevos valores de a: , x , y b: , y ) fin_intercambio Programa: #include<stdio.h> void intercambio(int x,int y); int temp,a,b; main(void) { clrscr(); printf("ingrese a: "); scanf("%d",&a); printf("ingrese b: "); scanf("%d",&b); intercambio(a,b); getch(); } void intercambio(int x, int y) { temp = x; x = y; y = temp; printf(" Nuevos valores de a:=%d y b:=%d",x,y); }
UNIDAD III ESTRUCUTRAS DE FLUJO PROGRAMTICO
3.1. Estructuras de Decisin

Control de Flujo Las sentencias estudiadas hasta ahora son ejecutadas una tras otra. El control de flujo de un lenguaje especifica el orden en el que se ejecuta cada sentencia. Las sentencias para controlar el flujo que podemos encontrar son: Estructuras de decisin o seleccin Estructuras de repeticin En C el carcter (;) representa el fin de una instruccin y se puede agrupar un grupo de sentencias utilizando las llaves ({ }) y formar lo que se conoce como una instruccin compuesta. Las estructuras de decisin, como su nombre lo indica, son estructuras que se usan en caso tal de que un algoritmo tenga alguna pregunta o tenga que decidir sobre una operacin cualquiera. Para realizar las condiciones, se debe repasar los operadores relacionales: igual (=), mayor que (>), menor que (<), mayor igual que (> =), menor igual que (<=) y diferente (<>) o (!=). Las condiciones se pueden realizar de la siguiente manera: variable contra variable: si (salario = salario_neto) entonces variable contra constante: si (salario > 5000.000) entonces constante contra variable: si (500.000 < salario_neto) entonces variable contra clculo: si (salario >= salario+aumento) entonces clculo contra variable: si (salarioaumento <= salario_neto) entonces constante contra clculo: si (450.000 != salario - dismin) entonces Las estructuras de decisin permiten seleccionar la prxima sentencia a ejecutarse sobre la base de una decisin (expresin lgica o variable lgica), los tipos de estructuras de decisin que podemos encontrar son: Simple Ramificada Las sentencias de decisin o tambin llamadas de control de flujo son estructuras de control que realizan una pregunta la cual retorna verdadero o falso (evala una condicin) y selecciona la siguiente instruccin a ejecutar dependiendo la respuesta o resultado. Estas sentencias de decisin en lenguaje C, son conocidas como ciclo if (simple y anidado) y ciclo switch (simple y anidado), las cuales se abordarn un poco ms adelante.
3.1.1. Simple En algn momento dentro de nuestros algoritmos, es preciso cambiar el flujo de ejecucin de las instrucciones, es decir, el orden en que las instrucciones son ejecutadas. Muchas de las veces tenemos que tomar una decisin en cuanto a que se debe ejecutar basndonos en una respuesta de verdadero o falso (condicional). La ejecucin de las instrucciones, incluyendo una estructura de control como el condicional funcionan de esta manera: Las estructuras de control simple es cuando slo se requiere de una sola estructura o una sola pregunta. Su sintaxis es la palabra Si, seguida de una pregunta o condicin (la cual va encerrada en medio de parntesis), y por ltimo si la condicin es verdadera se ejecuta la siguiente sentencia que se encuentra despus de la condicin, o se ejecuta el bloque de sentencias que se encuentran despus de la condicin, siempre y cuando estn encerradas entre llaves. Sabemos que un bloque de sentencias forzosamente estn encerradas entre llaves, y estas se ejecutan juntas dentro de un ciclo condicional, as como todo algoritmo tiene su fin, todas las estructuras de decisin terminan o tiene su fin, con la llave final del bloque de sentencias. Estructura de Seleccin if simple En medio de la estructura, solo se colocan las instrucciones, clculos u operaciones que se deban desarrollar cuando la pregunta sea verdadera. Las dems operaciones van fuera de la estructura de decisin. Las instrucciones o clculos se deben colocar un poco corridos hacia la derecha para identificar perfectamente donde empieza la estructura y donde termina, esto solo para darle vista y entendimiento a nuestro programa. Las instrucciones comienzan a ejecutarse de forma secuencial (en orden) y cuando se llega a una estructura condicional, la cual esta asociada a una condicin, se decide que camino tomar dependiendo siempre del resultado de la condicin siendo esta falsa o verdadera. Cuando se termina de ejecutar este bloque de instrucciones se reanuda la ejecucin en la instruccin siguiente a la de la condicional. Por lo tanto una estructura de decisin simple es una condicin, esta estructura evala la condicin, luego: Si la condicin es cierta entonces ejecuta el conjunto de sentencias definidas entre las llaves de dicha sentencia. Si la condicin es falsa entonces no ejecuta el conjunto de sentencias definidas dentro de las llaves y entonces se salta todo el bloque y contina en la siguiente instruccin inmediata de donde termina el ciclo condicional. Veremos la sintaxis del ciclo if dentro del lenguaje C. si (condicin) entonces sentencia si (condicin) entonces { sentencias } En el caso de la sintaxis anterior la diferencia entre ambas es el nmero de sentencias que se encuentra en el bloque de instrucciones, en la primera solo hay una sentencia por lo tanto, no hay necesidad de utilizar llaves que representan un bloque de instrucciones, y en la segunda hay mas de una instruccin por lo cual se requiere del uso de llaves, ya que sin ellas le estaremos diciendo al compilador que bajo esa condicin solo realice una instruccin, y si hay un bloque de instrucciones se le indica al compilador que bajo esa condicin realice todo lo que se encuentra entre llaves.
Por lo tanto, llamamos sentencias a un bloque de instrucciones en el cual se pueden introducir operaciones, clculos, escritura y lectura de variables, etc. Tambin pueden incluir condiciones, que entonces se les llamaran ciclos anidados, los cuales ms adelante se vern a detalle. Una de las estructuras ms simples del ciclo if es la siguiente: si (condicin) sentencia if (condicin) sentencia Ejemplos del ciclo de seleccin if simple if (x>0.0) printf(x es positivo \n);
if (a<b) {b+=a;} Nota: Observe que cuando hay una sola instruccin a ejecutarse dentro del if, las llaves son opcionales. Diagrama de flujo de la condicin if simple
Si condicin cierto acciones
falso
Figura 2. Diagrama de flujo ciclo if simple
Algoritmo: si (x > 0.0) entonces escribir ( x es positivo ) fin_si si (a<b) entonces bb+a fin_si Cuando hay dos o ms sentencias asociadas al if van encerradas entre llaves { }, como en el ejemplo siguiente: Segmento de Programa:
if (nota > 15) { eliminado++; printf(Estudiante eliminado \n); } Algoritmo: si (nota > 15) entonces eliminado eliminado + 1 escribir ( Estudiante eliminado ) fin_si Otro ejemplo simple del ciclo if if (x >= 0.0) { y += x; cont++; } Algoritmo: si ( x > 0.0 ) entonces yy+x cont cont + 1 fin_si Ejemplo en el que se piden tres nmeros desde el teclado y el programa nos diga si la suma de dos de ellos; es igual al tercero de ellos, si se dieran estos nmeros 5 3 2 el programa dara iguales, ya que la suma de dos de ellos (3 2) nos dan el tercero, si se dieran estos nmeros 6 2 1 el programa dara distintos. Algoritmo: inicio declarar variables enteras A, B, C escribir ( Introduzca tres nmeros enteros ) leer A, B, C si ( A + B = C ) entonces escribir ( Iguales ) fin_si si ( A + C = B ) entonces printf( Iguales ) fin_si si ( B + C = A ) entonces escribir ( Iguales ) fin_si si ((A + B != C) && (A + C != B) && (B + C != A)) entonces escribir ( Distintos ) fin_si pausa fin Programa: #include <stdio.h> #include <conio.h>
int main () { int A, B, C; printf(Introduzca tres nmeros enteros\n); scanf(%i %i %i, &A, &B, &C); if (A + B == C) printf(Iguales); if (A + C == B) printf(Iguales); if (B + C == A) printf(Iguales); if ((A + B != C) && (A + C != B) && (B + C != A)) printf(Distintos); return 0; getch(); } Otros ejemplos de estructura de seleccin if simple serian: Algoritmo: Inicio declarar variables enteras edad limpiar pantalla escribir ( Qu edad tienes? ) leer edad si ( edad > 20 ) entonces escribir ( Eres mayor de edad ) fin_si pausa fin Programa: #include <iostream.h> #include <stdio.h> void main() { int edad; clrscr(); printf("Qu edad tienes? \n"); scanf(%d,&edad); if ( edad > 20 ) printf("Eres mayor de edad"); getch(); } En el caso que sigue se muestra una modificacin del ciclo if, teniendo ahora ms de una lnea. Algoritmo: inicio declarar variables enteras edad limpiar pantalla
escribir ( Qu edad tienes? ) leer edad si ( edad > 20 ) entonces escribir ( Eres mayor de edad ) escribir ( Te estas volviendo viejo ) fin_si pausa fin Programa: #include <iostream.h> #include <stdio.h> void main() { int edad; clrscr(); printf("Qu edad tienes? \n"); sacnf(%d,&edad); if ( edad > 20 ) { printf("Eres mayor de edad"); printf("Te estas volviendo viejo "); } getch(); } La diferencia entre estos dos programas se situa dentro del ciclo if , cuando este tiene una sentencia y cuando tiene dos o ms, que es cuando se abren y cierran llaves. Estructura de Seleccin if else Ahora veremos el ciclo if else, que es agregar una sentencia de (en caso contrario), o parte falsa de la sentencia. La estructura if / else lo que hace es ejecutar una accin si el resultado de la evaluacin de la expresin es verdadera y otra accin si el resultado de la evaluacin es falsa. La diferencia con utilizar slo la estructura if es que si la expresin evaluada es verdadera slo en ese caso se ejecuta una accin de otro modo se pasa de largo. En cambio en la estructura if / else si la expresin es falsa entonces se ejecuta otra accin. En sntesis lo que hace esta estructura es realizar una accin si la expresin es verdadera y otra si es falsa. Su sintaxis sera: if (condicin) { Serie de sentencias 1 } else { Serie de sentencias 2 }
//parte verdadera
//parte falsa
Que se lee, si la condicin es verdadera realiza (la serie de sentencias 1), pero si la condicin fuera falsa; entonces, realiza (la serie de sentencias 2). La estructura condicional if...else es la que nos elegir entre dos caminos dependiendo de la condicin. Traducida literalmente del ingls, se la podra llamar la estructura "si...si no", es decir, "si se cumple la condicin, haz esto, y si no, haz esto otro". Aqu se muestra un segmento de programa con el ciclo if else, muy sencillo para poder entender esta definicin y su sintaxis. Algoritmo: declarar variables enteras edad escribir ( Dame tu edad por favor ) leer ( edad ) si ( edad < 18 ) entonces escribir ( no puedes acceder, eres menor de edad ) si_no escribir ( Bienvenido acceso permitido ) fin_si Programa: int edad; printf( Dame tu edad por favor \n); scanf(%d, &edad); if (edad < 18) printf("No puedes acceder, eres menor de edad \n"); else printf("Bienvenido acceso permitido \n"); Esta estructura de toma de decisin tiene un diagrama de flujo como el siguiente: Diagrama de flujo ciclo if-else
INICIO
LEER N NO PROCESO A N=1 SI PROCESO B
SALIDA
FIN Figura 3. Ciclo if-else
Aqu tenemos un ejemplo para ilustrar la estructura if / else.

Algoritmo: Inicio limpiar pantalla declarar variables entera edad if ( edad > 20 ) entonces escribir ( Eres mayor de edad ) else escribir ( No eres mayor de edad ) fin_si pausa fin Programa: #include <stdio.h> #include <conio.h> void main() { int edad; clrscr(); if ( edad > 20 ) printf("Eres mayor de edad"); else printf("No eres mayor de edad"); getch(); }
El cual tendra un diagrama de flujo como el siguiente: Diagrama de flujo if - else
falso printf("No eres mayor de edad"); Edad > 20
verdadero printf("Eres mayor de edad");
Figura 4. Diagrama if - else
El anterior diagrama de flujo funciona de la siguiente manera: 1. Si Edad es mayor que 20 (verdadero) entonces se muestra: Eres mayor de edad. 2. Si no (falso) entonces se muestra: No eres mayor de edad.
A continuacin se ver otro ejemplo con if else que nos proporciona de dos nmeros cual es el menor, observe que el tipo de variables utilizadas son de tipo float, por lo tanto al leer las variables pedidas desde el teclado; el modificador que se usa es ( %f ) respectivamente, y por ltimo al imprimir el valor de menor dentro de la comillas se incluye el modificador nuevamente ( %f ), para en ese preciso lugar imprimir el resultado de la variable ( menor ), que se encuentra despus de las comillas. Algoritmo: inicio declarar variables flotantes a, b, menor limpiar pantalla menor 0.0 escribir ( Dame el valor para a: ) leer ( a ) escribir ( Dame el valor para b ) leer ( b ) si ( a >b ) entonces escribir ( a es el numero menor ) menor a si_no escribir ( b es el numero menor ) menor b fin_si escribir ( Tu valor menor es el siguiente: , menor ) pausa fin Programa: #include <stdio.h> #include <conio.h> void main() { float a,b,menor; clrscr(); menor=0.0; printf( Dame el valor para a : \n); scanf(%f, &a); printf( Dame el valor para b : \n); scanf(%f, &b); if ( a > b ) { printf(" a es el nmero menor "); menor=a; } else { printf(" b es el nmero menor "); menor=b; } printf( Tu valor menor es el siguiente: \t %f , menor); getch(); }
El siguiente ejemplo transforma una cantidad dada a pesetas o a euros, dando como un valor constante de 166.7 a PTS_POR_EURO, que se declara al inicio. Algoritmo: declarar constante PTS_POR_EURO 166.7 inicio declarar variables flotantes CantidadOriginal, CantidadConvertida carcter PtsOEuros limpiar pantalla escribir ( Introduce P si quieres convetir pesetas ) escribir ( o E si quieres convertir euros ) PtsOEuros getchar( ) PtsOEuros toupper ( PtsOEuros ) si (PtsOEuros = E ) entonces escribir ( cuantos Euros ? ) si_no escribir ( cuantas pesetas ? ) leer ( CantiodadOriginal ) si (PtsOEuros = P ) entonces escribir ( Son , CantidadConvertida , pesetas ) si_no escribir ( Son , CantidadConvertida , Euros ) pausa fin Programa: #define PTS_POR_EURO 166.7 void main() { float CantidadOriginal, CantidadConvertida; char PtsOEuros; /* Pide al usuario que elija si convertir pesetas o euros*/ Clrscr(); printf("Introduce P si quieres convertir pesetas, "); printf(" o E si quieres convertir euros:"); PtsOEuros=getchar(); /* Espera a que introduzca un caracter */ PtsOEuros=toupper(PtsOEuros); /* Pasa a mayusculas el caracter*/ /* El mensaje que muestra depende de PtsOEuros */ if (PtsOEuros=='E') printf("Cuantos euros ? ") else printf("Cuantas Pesetas ? "); scanf("%f", &CantidadOriginal); /* Lee la suma a convertir */ if (PtsOEuros=='E') /* el clculo depende de PtsOEuros */ CantidadConvertida = CantidadOriginal*PTS_POR_EURO; else CantidadConvertida= CantidadOriginal/PTS_POR_EURO; if (PtsOEuros == 'P') /* El mensaje depende de PtsOEuros */ /* muestra el resultado con 3 decimales */ printf("Son %.3f pesetas\n ", CantidadConvertida);
else printf("Son %.3f Euros\n ", CantidadConvertida); getch(); } Estructura de Seleccin switch simple El switch es una estructura de decisin mltiple, que permite elegir ejecutar diferentes cdigos dependiendo de un valor. En forma ocasional, un algoritmo tendr una serie de decisiones, en las cuales una variable o expresin se probar por separado contra cada uno de los valores (constantes enteros) que pueda asumir, y se tomarn diferentes acciones. Para esta forma de toma de decisiones se proporciona una estructura de seleccin mltiple switch..case. La estructura switch est formada de una serie de etiquetas case, y de un caso opcional default. Estructura general: switch (variable) { case valor1: sentencia1; sentenciaN; break; case valor2: sentencia1; sentenciaN; break; case valorN: sentencia1; sentenciaN; break; default: sentencia1; sentenciaN; break; }; La variable a evaluar en la sentencia switch debe ser de tipo int o char nicamente. La palabra reservada switch es seguida por el nombre de la variable entre parntesis. Esto se conoce como la expresin de control. Despus de esta expresin se abre una llave { para el inicio de los cases. El valor de esta expresin es comparado con cada una de las etiquetas case. Si ocurre una coincidencia, se ejecutaran la sentencias correspondientes a dicho case, y de inmediato mediante el enunciado break se sale de la estructura switch. El enunciado break causa que el control del programa contine con el primer enunciado que sigue despus de la estructura switch. Se utiliza el enunciado break, porque de lo contrario los cases en un enunciado switch se ejecutaran juntos. Si en alguna parte de la estructura case no se utiliza break, entonces, cada vez que ocurre una coincidencia en la estructura se ejecutaran todos los enunciados de los cases restantes. Si no existe coincidencia, el caso default es ejecutado y se imprime por lo general un mensaje de error. Despus de terminar con la sentencia de la expresin default se cierra la llave } del switch. La expresin default es opcional. Cada case puede tener una o mas sentencias. La estructura switch es diferente a todas las dems estructuras, en el sentido de que no se requieren llaves alrededor de varias sentencias dentro de un case. Se pueden utilizar varias etiquetas, que significa que el mismo conjunto de acciones ocurrir para cualquiera de estos casos. Ejemplo:
case D : case d : printf( La letra es D ); break; Al utilizar una estructura switch, recuerde que puede ser usada slo para probar una expresin integral o caracter constante. Una constante de caracter se representa como un caracter especifico, entre comillas sencillas como d. Los caracteres deben ser encerrados dentro de comillas sencillas para que sean reconocidos como constantes de caracter. Las constantes enteras son solo nmeros enteros.
Algoritmo: switch (valor) { case 1 : ejecuta esto si valor es 1 break; case 2 : ejecuta esto si valor es 2 break; case 3 : ejecuta esto si valor es 3 break; default : ejecuta esto si valor no es ninguno de los anteriores break; }; Cada case puede ejecutar mltiples lneas de cdigo. Todos deben terminan con un break, que indica que debe seguirse la ejecucin del programa luego de ejecutar las lneas superiores. La ejecucin contina luego de la estructura switch. El caso default se ejecuta si no hubo coincidencia entre el contenido de valor y los case superiores. Un ejemplo del uso de la estructura switch en C: Algoritmo: inicio declarar variables entero hijos limpiar pantalla escribir ( Ingrese la cantidad de hijos que usted tiene: ) leer ( hijos ) segn_sea ( hijos ) hacer 0 : escribir ( No le corresponde asignacn familiar por hijos ) break; 1 : escribir ( Le corresponde 500 pesos de asignacn familiar por su nico hijo ) break; 2 : escribir ( Le corresponden 750 pesos de asignacn familiar por sus dos hijos ) break; default : escribir ( Le corresponden 1000 pesos de asignacn familiar por tener mas de dos hijos ) break; fin_segn_sea pausa fin Programa:
int hijos; clrscr( ); printf(Ingrese la cantidad de hijos que usted tiene: \n); scanf(%d, &hijos); switch (hijos) { case 0: printf(No le corresponde asignacin familiar hijo\n); break; case 1: printf(Le corresponden 500 pesos de asignacin familiar por su nico hijo\n); break; case 2: printf(Le corresponden 750 pesos de asignacin familiar por sus dos hijos\n); break; default: printf(Le corresponden 1000 pesos de asignacin familiar por tener ms de dos hijos\n); break; };
por
Se define la variable del tipo entero hijos, se le pide al usuario que ingrese el nmero de hijos que posee y luego entra en accin la estructura switch, actuando de diferentes formas dependiendo del valor de la variable hijos en tiempo de ejecucin. Otro ejemplo del switch sera el siguiente: Algoritmo: inicio declarar variables entero x carcter m limpiar pantalla escribir ( Seleccione una opcin del men ) escribir ( 1. Sumar ( ++ ) 2. Restar ( - - ) ) leer ( m ) segn_sea ( m ) hacer 1 : incrementar X en uno escribir ( , x , ) break; 2 : decrementar X en uno escribir ( , x , ) break; fin_segn_sea pausa fin Programa:
main() { int x; char m; clrscr( ); printf("Seleccione una opcin del men: "); printf("\n1.Sumar (++) \n 2.Restar(--) \n"); scanf ("%c" ,&m); printf("Teclee el numero"); scanf("%d" ,&x); switch (m) { case '1': /*Uso de comillas solas porque es como caraceter*/ x++; printf("%d", x); break; /*necesario sino se sigue hasta que encuentre un break*/ case '2': x--; printf("%d",x); break; } return 0; } 3.1.2. Ramificada Para hacer estructuras condicionales ms complejas podemos anidar sentencias if, es decir, colocar estructuras if dentro de otras estructuras if. Con un solo if podemos evaluar y realizar una accin u otra segn dos posibilidades, pero si tenemos ms posibilidades que evaluar debemos anidar Ifs para crear el flujo de cdigo necesario para decidir correctamente. Por ejemplo, si deseo comprobar si un nmero es mayor menor o igual que otro, tengo que evaluar tres posibilidades distintas. Primero puedo comprobar si los dos nmeros son iguales, si lo son, ya he resuelto el problema, pero si no son iguales todava tendr que ver cul de los dos es mayor, en situaciones como sta es cuando tenemos que utilizar y apoyarnos de estructuras anidadas, la sintaxis de estas condicionales sera: Sintaxis: if (condicin1) sentencia1 else if (condicin2) sentencia2 else if (condicin3) sentencia3 Segmento de algoritmo: si (condicin1) entonces
sentencias1 si_no si (condicin2) entonces sentencias2 si_no si (condicin3) entonces sentencias3 fin_si fin_si fin_si
A veces es importante utilizar las llaves para aclarar el sentido semntico de los if anidados, ya que estos empiezan a ser cada vez mas grandes y por ende tienen ms lneas de cdigo las cuales si no definimos bien en que parte del programa se quieren realizar, se revolveran y el cdigo sera inentendible. Ejemplo que determina de 3 nmeros cual es el mayor, con el ciclo if else, de esta manera hay que fijarse muy bien en el primer if que ejecuta todo su bloque de sentencias ( que es otro if else ) una anidacin de ciclos, y en el else del mismo if se vuelve a anidar otro if else en otro bloque de sentencias, por lo cual se comparan perfectamente los tres nmeros para dar el nmero mayor. Algoritmo: inicio declarar variables enteras A 0, B 0, C 0 limpiar pantalla escribir ( Ingrese 3 nmeros ) leer ( A, B, C ) si ( A > C ) entonces si ( A > C ) entonces escribir ( A es el nmero mayor ) si_no escribir ( C es el nmero mayor ) fin_si si_no si ( B > C ) entonces escribir ( B es el nmero mayor ) si_no escribir ( C es el nmero mayor ) fin_si fin_si pausa fin Programa: #include <iostream.h> #include <stdio.h> #include <conio.h> void main() { int A=0, B=0, C=0; clrscr( ); printf(Ingrese 3 nmeros);
scanf(%d %d %d,&A, &B, &C); if ( A > B ) { if (A > C ) printf(A else printf(C } else { if ( B > C ) printf(B else printf(C } getch(); }
//Lectura de valores por teclado
es el nmero mayor \n); es el nmero mayor \n);
es el nmero mayor \n); es el nmero mayor \n);
Otro ejemplo en el cual se incluyen ifs anidados: Algoritmo: inicio declarar variables enteras numero1 23, numero2 63 limpiar pantalla si ( numero1 == numero2 ) entonces escribir ( Los dos nmeros son iguales ) escribir ( numero1, numero2 ) si_no si ( numero1 > numero2 ) entonces escribir ( El primer nmero es mayor que el segundo ) escribir ( numero1, numero2 ) si_no escribir ( El primer nmero es menor que el segundo ) escribir ( numero1, numero2 ) fin_si fin_si pausa fin Programa: int numero1=23, numero2=63; clrscr( ); if (numero1 == numero2) { printf(Los dos nmeros son iguales \n "); printf( %d = %d , numero1, numero2); } else { if (numero1 > numero2) { printf( El primer nmero es mayor que el segundo \n "); printf( %d > %d , numero1, numero2); }
else { printf("El primer nmero es menor que el segundo \n"); printf( %d < %d , numero1, numero2); } getch( ); } En el anterior segmento de programa, primero se evala si los dos nmeros son iguales. En caso positivo se muestra un mensaje informndolo. En caso contrario ya sabemos que son distintos, pero aun debemos averiguar cul de los dos en mayor. Para eso se hace otra comparacin para saber si el primero es mayor que el segundo. Si esta comparacin da resultados positivos mostramos un mensaje diciendo que el primero es mayor que el segundo, en caso contrario indicaremos que el primero es menor que el segundo. Los sangrados tambin son opcionales en todo caso y nos sirven slo para ver el cdigo de una manera ms ordenada. Mantener el cdigo muy bien estructurado y escrito de una manera comprensible es muy importante, ya que nos har la vida ms agradable a la hora de programar y sobre todo ms adelante cuando tengamos que revisar programas ms extensos. Se pueden colocar instrucciones de control dentro de otras instrucciones de control, por ejemplo un bloque If...Else dentro de otra sentencia de control IfElse o incluso dentro de otra sentencia de control llamada switch que vimos anteriormente y entonces as, crear anidaciones. Cuando una instruccin de control se coloca dentro de otra, se dice que est anidada. Note que en el caso de este if anidado no se necesitan abrir y cerrar llaves en el if interno, ya que al abrir un if y enseguida volver a abrir otro; este se liga y solo que ubiera ms de una instruccin a realizar en ese if interno se abriran llaves de lo contrario queda como esta en este ejemplo. Para ver mejor lo dicho anteriormente se repetir el ejercicio anterior con ms de una instruccin dentro del if interno para notar claramente donde sera la modificacin. Algoritmo: si ( condicion ) entonces si ( condicion ) entonces Instrucciones a ejecutar cuando la condicin es verdadera En el caso de haber mas de una instruccin a realizar si_no Instrucciones a ejecutar cuando la condicin es falsa En el caso de haber tres lneas o ms a realizar Esta sera la tercera lnea Y podramos seguirnos cuantas lneas fueran necesarias Las llaves se abren al ser dos o ms lneas Fin_si si_no Instruccin a ejecutar cuando la condicin es falsa fin_si Programa: if (condicin) if (condicin) {
Instrucciones a ejecutar cuando la condicin es verdadera; En el caso de haber mas de una instruccin a realizar; } else { Instrucciones a ejecutar cuando la condicin es falsa; En el caso de haber tres lneas o ms a realizar; Esta sera la tercera lnea; Y podramos seguirnos cuantas lneas fueran necesarias; Las llaves se abren al ser dos o ms lneas; } else Instruccin a ejecutar cuando la condicin es falsa; Programa que determina de cuatro nmeros cual es el mayor: Ejemplo Algoritmo: inicio declarar variables enteras a, b, c, d, mayor limpiar pantalla escribir ( Programa que indica cual de los 4 nmeros es mayor ) escribir ( Introduce 4 nmeros enteros ) leer ( a, b, c, d ) si ( a > b ) entonces si ( a > c ) entonces si ( a > d ) entonces mayor a si_no mayor d fin_si si_no si ( c > d ) entonces mayor c si_no mayor d fin_si fin_si si_no si ( b > c ) entonces si ( b > d ) entonces mayor b si_no mayor a fin_si si_no si ( c > d ) entonces mayor c si_no mayor d fin_si fin_si fin_si escribir ( El mayor es , mayor ) pausa fin
Ejemplo Programa: #include <stdio.h> #include <conio.h> void main() { int a, b, c, d, mayor; clrscr (); printf ("Programa que indica cual de 4 numeros es el mayor\n"); printf ("Introduce 4 numeros enteros:\n"); scanf ("%i%i%i%i", &a, &b, &c, &d); if (a > b) if (a > c) if (a > d) mayor = a; else mayor = d; else if (c > d) mayor = c; else mayor = d; else if (b > c) if (b > d) mayor = b; else mayor = a; else if (c > d) mayor = c; else mayor = d; printf ("El mayor es %i", mayor); getch(); } Este es un claro ejemplo en el cual se manipulan varios ifs anidados para dar solucin a un problema de nmero mayor. Si se desea ejecutar ms de una instruccin, es posible ejecutar varias instrucciones en forma condicional al incluirlas en bloques mediante { }, al igual que en el ejemplo anterior. Las instrucciones que se van a ejecutar como resultado de comprobar la condicin pueden ser de cualquier tipo, incluida otra instruccin if anidada dentro de la instruccin if original. En las instrucciones if anidadas, la clusula else pertenece a la ltima instruccin if que no tiene una clusula else correspondiente. Por ejemplo:
if (x > 10) if (y > 20) printf(" El valor es mayor "); else printf( " El valor es menor "); En este ejemplo, se mostrar El valor es menor si la condicin (y > 20) se evala como false. No obstante, si desea asociar El valor es menor a la condicin (x >10), deber utilizar llaves, como se muestra a continuacin: if (x > 10) { if (y > 20) printf(" El valor es mayor "); } else printf( " El valor es menor "); En este caso, se mostrar El valor es menor si la condicin (x > 10) se evala como false. La razn por la que los ifs anidados son tan problemticos es que puede ser difcil saber que else se asocia con que if. Por ejemplo: if (x) if (y) printf ("1"); else printf("2"); A qu if se refiere el else? Afortunadamente, C proporciona una regla muy sencilla para resolver este tipo de situaciones. En C una sentencia else siempre se refiere al if precedente mas prximo que no tenga ya asociada una sentencia else. En este caso, el else esta asociado con la sentencia if(y). Para asociar el else con el if(x), se debe usar llaves para saltarse la asociacin normal, tal como se muestra aqu: if (x) { if (y) printf ("1"); } else printf("2");
Ahora, el else esta asociado con el if(x), porque ya no pertenece al bloque del if (y). Debido a las reglas de alcance de C, ahora el else no tiene conocimiento de la sentencia if (y), ya que no estn en el mismo bloque de cdigo. La escala if-else-if Una construccin comn en programacin es la if-else-if. Su forma general es:
if (expresin) sentencia; else if (expresin) sentencia; else if (expresin) sentencia; . . . else sentencia; Utilizando una escala if-else-if, el programa del nmero mgico queda como: Algoritmo: inicio declarar variables enteras magico 123, intento limpiar pantalla escribir ( Adivine el nmero mgico: ) leer ( intento ) si ( intento == magico ) entonces escribir ( **** Correcto **** ) escribir ( magico, es el nmero mgico ) si_no si ( intento > magico ) entonces escribir ( Incorrecto . . Demasiado alto ) si_no escribir ( Incorrecto . . Demasiado bajo ) fin_si fin_si pausa fin Programa: #include <stdio.h> main (void) { int magico = 123; /* numero magico*/ int intento; printf("adivine el numero magico: "); scanf("%d ", &intento); if (intento == magico) { printf("** Correcto**"); printf(" %d es el nmero mgico ", magico); } else if (intento > magico) printf(".. Incorrecto .. Demasiado alto"); else printf(".. Incorrecto .. Demasiado bajo"); return 0; }
Ahora bien dentro de las estructuras de decisin ramificadas tambin existe el ciclo switch como lo vimos anteriormente simple, pero ahora ramificado, recordaremos la sintaxis simple que se usa para de ella partir a la sintaxis ramificada: switch (expresin entera) { case exp_constante_1: acciones a realizar cuando la expresin tiene el valor exp_constante_1; break; case exp_constante_2: acciones a realizar cuando la expresin tiene el valor exp_constante_2; break; ...especificar todos los casos default: acciones a realizar cuando la expresin no coincide con ninguno de los casos; break; } La sintaxis del switch anidado sera: Algoritmo: segn_sea ( opcin uno ) hacer 1 : segn_sea ( opcion uno ) hacer 1 : escribir ( Mensaje ) break 2 : escribir ( Mensaje ) break 3 : escribir ( Mensaje ) break default: escribir ( Mensaje ) fin_segn_sea break 2 : segn_sea ( opcion dos ) hacer 1 : escribir ( Mensaje ) break 2 : escribir ( Mensaje ) break 3 : escribir ( Mensaje ) break default: escribir ( Mensaje ) fin_segn_sea break en caso contrario : break fin_segn_sea Programa: switch(opcion)
{ case 1:switch(opcion uno) { case 1:printf("Mensaje");break; case 2:printf("Mensaje");break; case 3:printf("Mensaje");break; default: printf(Mensaje);break; } break; case 2:switch(opcion dos) { case 1:printf("Mensaje");break; case 2:printf("Mensaje");break; case 3:printf("Mensaje");break; default: printf(Mensaje);break; } break; default:break; } Y as podramos continuar agregando ms switch anidados, cuantos sean necesarios para resolver la problemtica que se tenga, el ciclo switch anidado nos sirve para meter condiciones dentro de una ya establecida como en el ejemplo que sigue, nos da la conversin de nmeros arbigos a nmeros romanos de tal manera que se aniden los ciclos switch, en este primer ejemplo el ciclo switch tiene un pequeo error que se despeja en el ejercicio que le sigue, vamos a checar el primer caso: Ejemplo con switch anidado: Algoritmo: declarar funcin tranf (entera, entera) inicio declarar variables enteras um, c, d, u, n limpiar pantalla escribir ( Ingrese un nmero ) leer ( n ) um n/1000 c n/100%10 d n/10%10 u n%10 llamar a la funcin tranf(um,1) llamar a la funcin tranf(c,2) llamar a la funcin tranf(d,3) llamar a la funcin tranf(u,4) pausa fin funcin tranf (entera y, entera x ) inicio escribir ( Ingrese un nmero ) leer ( x ) segn_sea ( x ) hacer 1 : segn_sea ( y ) hacer 1 : escribir ( M )
break 2 : escribir ( MM ) break 3 : escribir ( MMM ) break default: break fin_segn_sea break 2 : segn_sea ( y ) hacer 1 : escribir ( C ) break 2 : escribir ( CC ) break 3 : escribir ( CCC ) Break 1 : escribir ( CD ) break 2 : escribir ( D ) break 3 : escribir ( DC ) break 1 : escribir ( DCC ) break 2 : escribir ( DCCC ) break break default: break fin_segn_sea break 3 : segn_sea ( y ) hacer 1 : escribir ( X ) break 2 : escribir ( XX ) break 3 : escribir ( XXX ) Break 4 : escribir ( XL ) break 5 : escribir ( L ) break 6 : escribir ( LX ) break 7 : escribir ( LXX ) break 8 : escribir ( LXXX ) break 9 : escribir ( CX ) break default: break fin_segn_sea break 4 : segn_sea ( y ) hacer 1 : escribir ( I ) break 2 : escribir ( II )
break 3 : escribir ( break 4 : escribir ( break 5 : escribir ( break 6 : escribir ( break 7 : escribir ( break 8 : escribir ( break 9 : escribir ( break default:break; fin_segn_sea break default: break fin_segn_sea Programa: #include<conio.h> #include<stdio.h>
III ) IV ) V ) VI ) VII ) VIII ) IX )
void tranf(int,int); void main(void) { int um,c,d,u,n; clrscr(); printf("ingrese numero"); scanf("%d",&n); um=n/1000; c=n/100%10; d=n/10%10; u=n%10; tranf(um,1); tranf(c,2); tranf(d,3); tranf(u,4); getch( ); } void tranf(int y, int x) { printf("ingrese numero"); scanf ( %d , &x); switch(x) { case 1:switch(y) { case 1:printf("M");break; case 2:printf("MM");break; case 3:printf("MMM");break; default:break; }
case 2:switch(y) { case 1:printf("C");break; case 2:printf("CC");break; case 3:printf("CCC");break; case 4:printf("CD");break; case 5:printf("D");break; case 6:printf("DC");break; case 7:printf("DCC");break; case 8:printf("DCC");break; case 9:printf("DCCC");break; default:break; } case 3:switch(y) { case 1:printf("X");break; case 2:printf("XX");break; case 3:printf("XXX");break; case 4:printf("XL");break; case 5:printf("L");break; case 6:printf("LX");break; case 7:printf("LXX");break; case 8:printf("LXXX");break; case 9:printf("XC");break; default:break; } case 4:switch(y) { case 1:printf("I");break; case 2:printf("II");break; case 3:printf("III");break; case 4:printf("IV");break; case 5:printf("V");break; case 6:printf("VI");break; case 7:printf("VII");break; case 8:printf("VIII");break; case 9:printf("IX");break; default:break; } default:break; } El ejemplo anterior contiene un pequeo error de llaves (rango), si es que lo pudieron detectar solo hay que corregirlo, pero si no, el ejemplo siguiente nos da la modificacin pertinente. El error radica en las llaves que le faltan al primer switch. Algoritmo: declarar funcin tranf (entera, entera) inicio declarar variables enteras um, c, d, u, n limpiar pantalla escribir ( Ingrese un nmero ) leer ( n )
um n/1000 c n/100%10 d n/10%10 u n%10 llamar a la funcin llamar a la funcin llamar a la funcin llamar a la funcin pausa fin
tranf(um,1) tranf(c,2) tranf(d,3) tranf(u,4)
funcin tranf (entera y, entera x ) inicio escribir ( Ingrese un nmero ) leer ( x ) segn_sea ( x ) hacer 1 : segn_sea ( y ) hacer 1 : escribir ( M ) break 2 : escribir ( MM ) break 3 : escribir ( MMM ) break default: break fin_segn_sea break 2 : segn_sea ( y ) hacer 1 : escribir ( C ) break 2 : escribir ( CC ) break 3 : escribir ( CCC ) Break 1 : escribir ( CD ) break 2 : escribir ( D ) break 3 : escribir ( DC ) break 1 : escribir ( DCC ) break 2 : escribir ( DCCC ) break break default: break fin_segn_sea break 3 : segn_sea ( y ) hacer 1 : escribir ( X ) break 2 : escribir ( XX ) break 3 : escribir ( XXX ) Break 4 : escribir ( XL ) break
5 : escribir ( L ) break 6 : escribir ( LX ) break 7 : escribir ( LXX ) break 8 : escribir ( LXXX ) break 9 : escribir ( CX ) break default: break fin_segn_sea break 4 : segn_sea ( y ) hacer 1 : escribir ( I ) break 2 : escribir ( II ) break 3 : escribir ( III ) break 4 : escribir ( IV ) break 5 : escribir ( V ) break 6 : escribir ( VI ) break 7 : escribir ( VII ) break 8 : escribir ( VIII ) break 9 : escribir ( IX ) break default:break; fin_segn_sea break default: break fin_segn_sea pausa fin Programa: #include <stdio.h> #include <stdlib.h> void tranf(int,int); int main(void) { int um,c,d,u,n; system("cls"); printf("ingrese numero: "); scanf("%d",&n); um=n/1000; c=n/100%10; d=n/10%10; u=n%10;
tranf(um,1); tranf(c,2); tranf(d,3); tranf(u,4); putchar('\n'); system("pause"); return 0; } void tranf(int y, int x) { switch(x){ case 1:switch(y) { case 1:printf("M");break; case 2:printf("MM");break; case 3:printf("MMM");break; default:break; } break; case 2:switch(y) { case 1:printf("C");break; case 2:printf("CC");break; case 3:printf("CCC");break; case 4:printf("CD");break; case 5:printf("D");break; case 6:printf("DC");break; case 7:printf("DCC");break; case 8:printf("DCC");break; case 9:printf("DCCC");break; default:break; } break; case 3:switch(y) { case 1:printf("X");break; case 2:printf("XX");break; case 3:printf("XXX");break; case 4:printf("XL");break; case 5:printf("L");break; case 6:printf("LX");break; case 7:printf("LXX");break; case 8:printf("LXXX");break; case 9:printf("XC");break; default:break; } break; case 4:switch(y) { case 1:printf("I");break; case 2:printf("II");break; case 3:printf("III");break; case 4:printf("IV");break; case 5:printf("V");break; case 6:printf("VI");break;
case 7:printf("VII");break; case 8:printf("VIII");break; case 9:printf("IX");break; default:break; } break; default:break; } getch(); } Este es un ejemplo que se resuelve mediante dos formas con ifs anidados y con switch anidados. Para demostrar que lo que se realiza con un ciclo if se puede realizar de la misma manera con un ciclo switch y viceversa. Ejemplo: Un restaurante ofrece el siguiente men, con los siguientes costos por platillo: 1.-Carne en su Jugo 89.60 2.- Hgado encebollado 60.25 Adicionalmente el cliente puede elegir uno de los siguientes postres, por los cuales se agregar al costo del platillo las cantidades que se indican: 1) Flan 5.00 2) Gelatina 3.50 3) No desea postre (el cliente pagar 10.00 pesos menos por su platillo). El programa deber pedir la informacin referente al platillo y al postre, a travs de un men y al final mostrar un mensaje con el monto que el cliente deber pagar. El siguiente programa soluciona el problema anterior con estructuras if anidadas. Algoritmo: inicio declarar variables enteras postre carcter platillo real postre 0.0 limpiar pantalla escribir ( Que platillo desea el cliente ) escribir ( a)Carne en su Jugo b)Hgado encebollado ) escribir ( Proporcione la Opcin (a b): [ ] ) leer ( platillo ) si ( platillo = 1 ) hacer escribir ( Que postre desea el cliente: ) escribir ( 1) Flan, 2) Gelatina 3) No desea postre ) escribir ( Proporcione la Opcin (1,2 3): [ ] ) leer ( postre ) si ( postre = 1 ) entonces costo 89.60+5.00 si_no si ( postre = 2 ) entonces costo 89.60+3.50 si_no si ( postre = 3 ) entonces costo 89.60-10.00 si_no escribir ( Error en la seleccin del postre ) si_no si ( platillo = 2 ) entonces
escribir ( Seleccione postre ) escribir ( Seleccione la opcin [ 1,2 3 ] : ) leer ( postre ) si ( postre = 1 ) entonces costo=60.25+5.00 si( postre = 2 ) entonces costo=60.25+3.50 si( postre = 3 ) entonces costo=60.25-10.00 si_no escribir ( Error en la seleccin del platillo ) fin_si fin_si escribir ( El total a pagar es ,costo ) pausa fin Programa: #include <stdio.h> #include<conio.h> void main() { int platillo,postre; float costo=0.0; printf("\n\n Que platillo desea el cliente\n"); printf(" 1)Carne en su Jugo 2)Hgado encebollado\n"); printf("Proporcione la Opcin (1 2): [ ]\b\b"); scanf("%d", &platillo); if(platillo==1) { printf("\n Seleccione postre\n"); printf("1-Flan, 2-Gelatina 3-No desea postre)\n"); printf("Proporcione la Opcin (1,2 3): [ ]\b\b"); scanf("%d",&postre); if (postre==1) costo=89.60+5.00; else if (postre==2) costo=89.60+3.50; else if (postre==3) costo=89.60-10.00; else printf("\n Existe un error en la seleccin del postre\n"); } else if(platillo==2) { printf("\n Seleccione postre\n"); printf("Proporcione la Opcin (1,2 3): [ ]\b\b"); scanf("%d", &postre); if (postre==1) costo=60.25+5.00; if (postre==2) costo=60.25+3.50; if (postre==3) costo=60.25-10.00; } else printf("Error en la seleccin del platillo\n"); printf("\n El total a pagar es %8.2f \n",costo);
getch(); } Solucin con estructuras switch anidadas, las opciones del platillo sern ahora a y b. Algoritmo: inicio declarar variables enteras postre carcter platillo real postre 0.0 limpiar pantalla escribir ( Que platillo desea el cliente ) escribir ( a)Carne en su Jugo b)Hgado encebollado ) escribir ( Proporcione la Opcin (a b): [ ] ) leer ( platillo ) segn_sea ( platillo ) hacer A : escribir ( Que postre desea el cliente: ) escribir ( 1) Flan, 2) Gelatina 3) No desea postre ) escribir ( Proporcione la Opcin (1,2 3): [ ] ) leer ( postre ) segn_sea ( postre ) hacer 1 : costo 89.60+5.00 break; 2 : costo 89.60+3.50 break; 3 : costo 89.60-10.00 break; default: escribir ( Error en la seleccin del postre ) break fin_segn_sea break B : escribir ( Que postre desea el cliente: ) escribir ( 1) Flan, 2) Gelatina 3) No desea postre ) escribir ( Proporcione la Opcin (1,2 3): [ ] ) leer ( postre ) segn_sea ( postre ) hacer 1 : costo 60.25+5.00 break; 2 : costo 60.25+3.50 break; 3 : costo 60.25-10.00 break; default: escribir ( Error en seleccin del postre ) break fin_segn_sea break default : escribir ( Error en la seleccin del platillo ) fin_segn_sea break escirbir ( El total a pagar es : , costo ) pausa fin Programa: #include <stdio.h>
#include<conio.h> void main() { char platillo; int postre; float costo=0.0; clrscr(); printf("\n\nQue platillo desea el cliente\n"); printf(" a)Carne en su Jugo b)Hgado encebollado\n"); printf("Proporcione la Opcin (a b): [ ]\b\b"); scanf("%c",&platillo); switch(platillo) { case 'A': printf("\n\n Que postre desea el cliente:\n"); printf("1) Flan, 2) Gelatina 3) No desea postre\n"); printf("Proporcione la Opcin (1,2 3): [ ]\b\b\b"); scanf("%d", &postre); switch(postre) { case 1:costo=89.60+5.00; break; case 2:costo=89.60+3.50; break; case 3:costo=89.60-10.00; break; default:printf("\n Error en la seleccin del postre\n"); } break; case 'B': printf("\n\n Que postre desea el cliente:\n"); printf("1) Flan, 2) Gelatina 3) No desea postre\n"); printf("Proporcione la Opcin (1,2 3): [ ]\b\b\b"); scanf("%d", &postre); switch(postre) { case 1:costo=60.25+5.00; break; case 2:costo=60.25+3.50; break; case 3:costo=60.25-10.00; break; default:printf("\n Error en seleccin del postre\n"); } break; default: printf("\n Error en la seleccin del platillo\n"); } printf("\nEl total a pagar es %8.2f \n", costo); getch(); }
3.2. Estructuras de Iteracin

Todos los programas que se han visto a lo largo de este manual se ejecutan en forma secuencial, es decir una sentencia despus de la otra y as sucesivamente. Cada instruccin empezando en el inicio se ejecutan una seguida de la otra y algo muy importante, ninguna de ellas se repite, por lo tanto se dice que s un programa secuencial porque sus instrucciones van ejecutndose una por una continuamente hasta llegar al final del programa.
As, esta programacin es muy sencilla y se realizan programas a su vez sencillos, por otro lado poco a poco se va requiriendo de una programacin ms controlada, en la cual podamos decidir en que momento ejecutamos una serie de instrucciones y bajo que condicin. En lenguaje C existen otras sentencias bajo las cuales se pueden repetir una serie de instrucciones mientras se cumpla una determinada condicin y caractersticas. Las estructuras de iteracin son tambin llamados ciclos y se usan en la programacin para realizar una y otra vez un conjunto de instrucciones hasta que se cumpla una determinada condicin. Estos ciclos de iteracin o repeticin son muy utilizados, ya que permiten al programador repetir un segmento de cdigo las veces que se desee; sin necesidad de volver a escribir cada vez que se va a utilizar y as lograr simplificar cdigo de programacin. Lenguaje C soporta tres tipos de estructuras de iteracin que son: while, do-while y for, los cules describiremos a continuacin. Dentro de estos tres tipos, existen los llamados pre condicionales y post condicionales que son el ciclo while y do while respectivamente y en lo que respecta al ciclo for, este puede entrar en cualquiera de los dos ya que con una serie de modificaciones en su estructura puede llegar a ser pre condicional o post condicional. El nombrar pre condicional a un ciclo quiere decir que primero va a evaluar la condicin para luego ver si realiza el bloque de sentencias, si esta condicin es verdadera o se cumple, entonces entramos a realizar el bloque de sentencias de dicho ciclo, pero si esta condicin es falsa desde el inicio, nunca entramos a realizar ninguna tarea del bloque de sentencias; esto es un ciclo pre condicional es el cual va a evaluar la condicin antes de realizar el bloque de sentencias, un ejemplo claro de esto es un ciclo while, y cuando se habla de un ciclo post condicional se dice que es cuando la condicin se evala al final del bloque de sentencias. Una vez que ya se realiz el bloque de sentencias en la parte final se encuantra la condicin, en ese momento se evala y si es falsa deja de repetir el bloque de sentencias, pero si es verdadera contina repitiendo el bloque de sentencias; por lo tanto un ejemplo de este ciclo es el do while; el cual primero realiza el bloque de sentencias sin importar la condicin y al final evala la condicin. En este caso el ciclo do while por fuerza siempre realiza al menos una vez todas las sentencias que se encuentran dentro de l, sin importar que la expresin de la condicin sea falsa desde un principio, mientras que el ciclo while si su condicin es falsa en un principio nunca se ejecuta el bloque de sentencias ni una sola vez, solo cuando esta sea verdadera.
Estructura de Iteracin while Analizaremos el ciclo while por primera instancia el cual primero evala la condicin para luego entonces, si sta se cumple o es (verdadera) realice el bloque de sentencias de dicha estructura, de lo contrario el control del programa pasar a la siguiente instruccin inmediata despus del ciclo de repeticin, ejemplo de esto es el siguiente diagrama de flujo donde se muestra como el ciclo while para poder realizar un bloque de sentencias determinado, primero tiene que evaluar su condicin (expresin lgica) mientras esta sea verdadera se ejecuta el bloque de sentencias y si est condicin es falsa el programa dirige su flujo a la sentencia siguiente instruccin inmediata despus del ciclo de repeticin como se muestra a continuacin. Diagrama de Flujo del ciclo While
sentencia
mientras condicin verdadera sentencia
falsa
sentencia
sentencia
Sentencia siguiente Figura 5. Diagrama de flujo ciclo While
La sintaxis o forma general del ciclo de repeticin while en su forma simple o ms sencilla es la del inciso a), mientras que el inciso b) muestra la forma ms estructurada de un ciclo while el cual consta de una serie de sentencias (bloque de sentencias) que van encerradas entre llaves { }, si la sentencia a ejecutar en el ciclo while es nicamente una no se utilizan la llaves, pero si el bloque consta de ms de una sentencia se le debe poner las llaves para indicar que todo ese bloque de sentencias se realizar cuando la condicin sea verdadera. Sintaxis: a) mientras (condicin) hacer Sentencia; b) mientras (condicin) hacer { Sentencia1; Sentencia2; . . . SentenciaN; } En lenguaje de programacin meramente Lenguaje C se escribira como sigue, tomando en cuenta lo anterior respectivamente: a) while (condicin) sentencia; b) while (condicin) { Sentencia1; Sentencia2;
Sentencia3; . . . sentenciaN; } Ntese que al terminar la lnea del while no se pone un punto y coma, mientras que en las dems instrucciones todas al final terminan con un punto y coma, exceptuando tambin las llaves; esto es debido a que un punto y coma ( ; ) indica la terminacin de una instruccin concluida y por lo tanto la lnea del while no es una instruccin para terminar, si no por el contrario; es el inicio del ciclo de repeticin. En esta estructura el conjunto de instrucciones que forma parte del bucle (un ciclo) se repite mientras se cumple una determinada condicin. Como es bien sabido la finalidad de la palabra reservada while es ejecutar una instruccin una y otra vez mientras que una condicin dada sea cierta, cuando la condicin de ciclo while ya no es lgicamente verdadera, el ciclo termina. Veamos ahora un ejemplo de la estructura de repeticin while. Este segmento de programa nos indica cuantas veces se ejecuta un ciclo de repeticin y lo muestra en pantalla. Algoritmo: R=0 mientras ( R < 6 ) hacer escribir ( R ) incrementar R en uno fin_mientras Programa: R = 0; while (R < 6) { printf( \n %d , R); R = R + 1; } La salida de este programa es el valor de la variable R, que va incrementndose de uno en uno cada vez que se ejecuta el bloque de sentencias ( conjunto de instrucciones dentro de las llaves) del ciclo y nos da: 0, 1, 2, 3, 4 y 5. Por lo tanto el bucle se repite seis veces. Este es otro ejemplo que contar los nmeros enteros positivos dados desde el teclado, en el momento en el que se teclee un nmero negativo se detiene la iteracin y da por terminado el programa. Algoritmo: algoritmo enteros variables enteras nmero, contador inicio escribir( Programa que cuenta los nmeros enteros positivos ) contador 0 leer (numero) mientras ( numero > 0 ) hacer contador contador + 1 leer (numero)
fin_mientras escribir ( El nmero de enteros dados fue , contador ) pausa fin Programa Enteros: #include <stdio.h> #include<conio.h> void main() { int numero, contador; printf("\n\n Programa que cuenta los nmeros enteros positivos\n"); contador=0; printf(" Dame un nmero \n"); scanf("%d",&numero); while ( numero > 0 ) { contador = contador + 1; scanf(%d,&numero); } printf( El nmero de enteros dados fue : \t %d , contador); getch(); } El programa anterior al final muestra cuantos nmeros enteros se introdujeron, dicho valor lo tiene la variable contador, que acta como un contador (trmino que ms adelante se describe) dando la acumulacin de uno en uno durante cada vuelta del ciclo. Una condicin est formada bsicamente por una serie de estructuras llamadas expresiones estas a su vez estn formadas por cualquier sentencia que devuelve una operacin booleana que como resultado dentro del parntesis nos den un dato expresado en falso o verdadero, en true or false o en cero o uno, para poder determinar si la condicin proporcionada se cumple o no se cumple y poder as saber, si se ejecuta el bloque de sentencias o no. La condicin tambin puede ser el nombre de una variable y el valor de la expresin depender del contenido de la variable. Aunque sea una variable no booleana, siempre se podr usar, si vale 0 ser como si la condicin no se cumpliera, y siempre que sea diferente de 0, se considerar que la condicin se cumple. Dentro de estas expresiones se usan los operadores aritmticos y lgicos vistos con anterioridad, y para saber que resultado arroja cada expresin podemos hacer uso de nuestras tablas de verdad, que a continuacin se muestran. Dentro de las formas ms usadas es sin duda las sentencias comparativas en donde se emplean implcitamente las tablas de verdad que es el resultado de una operacin lgica. Tablas de verdad And: A F F V V Or: A B A || B
B F V F V
Tabla 20. Tabla de verdad And
A&&B F F F V
OPERADOR < > <= >= == != F F V V
DESCRIPCIN Menor que Mayor que Menor o igual que Mayor o igual que Igual Diferente que F V F V
Tabla 21. Tabla de verdad Or
F V V V
Not: A F V ! A V F
Tabla 22. Tabla de verdad Not
Los operadores relacionales se usan para expresar condiciones y describir la relacin entre dos valores, son muy tiles porque con ellas la expresin se vuelve ms exacta, es decir; el rando ya no queda abierto sino tiene un lmite de inicio y fin con el cual se puede dar por terminado el ciclo de repeticin.
Tabla 23. Operadores Relacionales
Tambin para describir expresiones ms exactas y precisas en las condiciones se usan los operadores lgicos and, or y not, los cuales se pueden utilizar conjuntamente con los operadores relacionales para construir expresiones exactas a lo que queremos construir dentro de los programas.
OPERADOR ! && !=
DESCRIPCIN Not And Or

9
Autores: Alejandra Gutierrez Reyes - Enrique Martnez Roldn - Academia de Computacin Ingenieria Elctrica ESIME Zacatenco IPN
Tabla 24. Operadores Lgicos
Ejecucin de un bucle cero veces: Vase que en una estructura mientras (while) la primera cosa que ocurre es la evaluacin de la expresin (condicin) booleana; si esta condicin se evala a falsa en ese momento, entonces el cuerpo del bucle nunca se ejecuta. Puede parecer intil ejecutar el cuerpo del bucle cero veces, ya que no tendra efecto alguno el realizar un programa en donde nunca entraremos al cuerpo del while. Sin embargo, a veces es la operacin querida. Ejemplo: Algoritmo: K0 escribir ( Dame un nmero ) leer (numero) mientras ( numero > 0 ) hacer Kk+1 leer ( numero ) fin_mientras Este ciclo de repeticin nunca se ejecutar si el primer nmero ledo desde el teclado es un nmero negativo o es igual a cero. Programa: K = 0; printf( Dame un nmero: \n ); scanf(%d, &numero); while ( numero > 0) { K++; scanf (%d, &numero); } Bucles infinitos: Algunos bucles no exigen un fin y otros nunca encuentran el fin porque tienen un error en su diseo. Por ejemplo, en una estacin de tren se requiere de un programa que requiere del registro de altas y bajas de sus pasajeros, este ciclo se est repitiendo constantemente y nunca termina hasta que la computadora se apague y por el contrario puede haber un programa que nunca se repita o que nunca termine su repeticin porque nunca se cumpla la condicin. Un ciclo que nunca termine se le llama ciclo infinito o sin fin. Los ciclos infinitos que no son intencionalmente provocados, son dainos para la programacin ya que en muchas ocasiones no sabemos porque sucede un error en el ciclo sobre todo cuando se empieza a programar, muchos de estos errores no provocados se empiezan a comprender ms cuando tenemos un poco de prctica al programar. Consideremos el ejemplo de tasa de interes con un incremento de dos, en un rango entre 20 y 40 por 100. Algoritmo: escribir ( Dame el capital total que gustes ) leer (total_cap)
tasa_int 20 escribir ( Programa que realiza una tasa de interes ) mientras (tasa_int < > 40 ) hacer interes tasa_int * 0.01 * total_cap //el capital es capital/100 (0.01) escribir ( El interes que se produjo es: , interes) tasa_int tasa_int + 2 fin_mientras escribir ( Linea siguiente ) Los valores que siguen a la tasa_int seran 20, 22, 24, 26, 28, 30, 32, 34, 36, 38 y 40, de manera que al tomar la variable tasa_int el valor de 40 este bucle mientras (while) se termina y se va la ejecucin del programa a la siguiente instruccin despus del ciclo de repeticin que es el mensaje Lnea siguiente. Programa: printf( Dame el capital total que gustes \n\n); scanf(%d, &total_cap); tasa_int = 20; printf( Programa que realiza una tasa de interes \n\n ); while (tasa_int < > 40 ) { interes = tasa_int * 0.01 * total_cap; printf( El interes que se produjo es : \t %d , interes); tasa_int = tasa_int + 2; } printf( Lnea siguiente \n ); Supongamos que la lnea de ( tas_int = tasa_int + 2 ), se cambiara por ( tasa_int = tasa_int + 3), entonces aqu los valores de la tasa_int seran: 23, 26, 29, 32, 35, 38, 41 , por lo tanto la condicin del ciclo while nunca se cumplira y el bucle se vuelve infinito. Problemas como este nos determinan las maneras en que podemos terminar un ciclo de repeticin, sobre todo si utilizamos los operadores relacionales de menor o igual y mayor o igual podremos tener expresiones ms exactas. En el siguiente ejemplo se utilizan los operadores relacionales para que la condicin tenga un lmite determinado, realiza una suma acumulativa de nmeros dados desde el teclado, hay que poner atencin a la condicin para que se aprecie como est funcionando ahora esa condicin. Algoritmo: escribir ( Programa que suma N cantidad de nmeros ) suma 0 escribir ( Existen otros nmeros en la lista s/n ) leer (opcion) mientras ( opcion = S ) o ( opcion = s ) hacer escribir ( Dame un numero ) leer (numero) suma suma + numero escribir ( Hay ms numeros s/n ) leer (opcion) fin_mientras escribir ( El total de los numeros sumados es: , suma ) Programa: printf( Programa que suma N cantidad de numeros \n\n ); suma = 0;
printf( Existen otros numeros en a lista \n\n ); scanf( %c, &opcion); while (( opcion = S) || (opcion = s)) { printf( Dame un numero: \n\t ); scanf( %f, &numero); suma = suma + numero; printf( Hay ms nmeros s/n ); scanf( %c, &opcion); } printf( El total de los numeros sumados es: %f \n , suma ); Este mtodo es muy bueno pero poco eficaz sobre todo cuando una lista es demasiado grande, entonces se usan variables que tengan una seal de parada como las vistas anteriormente. Un mtodo muy interesante y eficaz para detener un ciclo de repeticin es usar un valor centinela. Un valor centinela es un valor especfico para indicar el final de una lista de datos. Por ejemplo, supongamos que tenemos una lista de calificaciones de los alumnos del tercer semestre de la carrera de ingeniera que entran en un rango de 0 a 10 de las cuales tenemos que obtener sus promedios, entonces un valor centinela es o podra ser -9, ya que esta jams podr ser una calificacin valida para un alumno y por lo tanto cuando este valor aparezca se dar por terminada la lista y por ende el bucle. Si la lista es de nmeros positivos un valor centnela podra ser un nmero negativo que ndique el final de la lista. El siguiente ejemplo muestra como se usa un valor centinela en una lista de calificaciones. Algortimo: suma_calif 0; Cont 0 escribir ( Da la calificain: ) leer (calif) mientras ( calif >= 0 ) hacer suma_calif suma_calif + calif escribir ( Da la calificacin: ) leer (calif) cont cont + 1 fin_mientras prom suma_calif / cont escribir ( Tu promedio es de : , prom) Programa: suma_calif = 0; cont = 0; prinf( Da la calificacin: \n ); scanf( %f , &calif); while (calif > = 0) { suma_calif = suma_calif + calif; cont = cont + 1; printf( Da la calificacin: \n ); scanf ( %f , &calif ); } prom = suma_calif / cont; printf( Tu promedio es de: \t %f ,prom);
Cuando se usa un valor centinela se podran dar por ejemplo los siguientes valores 10, 5.5, 7, 3.5, 9, y -9, entonces nuestro valor centinela sera -9 que es un valor que se lee pero no se suma en la lista, ntese tambien que el pedir la calificacin (valor que estamos comprobando) se hace al final del bloque de sentencias, esto para poder comprobar de inmediato el valor al entrar al while, si este es un valor negativo como lo es el -9 de inmediato el ciclo se detiene. Hay que poner atencin tambien en que el promedio de estas calificaciones se realiza fuera del ciclo de repeticin, para tener primero la acumulacin del nmero de calificaciones el cual es llevado por la variable cont; y luego la suma de las calificaciones la divide entre el nmero de calificaciones que son dando entonces un promedio de claificaciones final. Otros ejemplos para detener un ciclo de repeticin es dar una condicin en la cual ya no sea probable que existan ms datos de entrada, como el ejemplo siguiente: a) Algoritmo: i = 0; mientras ( i < 6 ) hacer escribir ( El valor de i es : , i ) i=i+1 fin_mientras
b) Algoritmo: i=0 mientras ( i < 6 ) hacer i=i+1 escribir ( i ) fin_mientras a) Programa: i = 0; while ( i < 6 ) { printf( El valor de i es : \t i = i + 1; } b) Programa: i = 0; while ( {
%d , i);
i < 6
i = i + 1; printf ( %d , &i ); } Estos algoritmos nos indican cuantas veces se ejecuta un ciclo de repeticin (bucle). El algoritmo a y el algoritmo b muestran exactamente lo mismo; las vueltas que da un ciclo de repeticin, pero el acomodar las lneas del contador y el printf de diferente manera nos muestra una salida diferente como se muestra a continuacin: La salida en el inciso a) es el valor que toma la variable de control i al inicio de cada ejecucin del ciclo: 0, 1, 2, 3, 4 y 5. Por lo tanto el bucle se ejecuta sies veces, mientras en inciso b) se ejecuta exactamente las mismas veces pero el contador i lleva los
siguientes valores: 1, 2, 3, 4, 5 y 6 debido a que en este caso el incremento de la variable i es primero y luego imprime el valor en pantalla por eso es el cambio de los valores. Estructura de iteracin Do While: El ciclo hacer mientras (do while ), es muy similar al ciclo while antes visto ambos realizan un ciclo de repeticin, solo cambia la manera en que se acomoda la condicin dentro del ciclo de repeticin. A veces es importante que un ciclo de repeticin se ejecute al menos una vez antes de comprobar la condicin, en el ciclo while si la expresin booleana era falsa no se ejecutaba el bloque de sentencias, por eso en ocasiones es necesario contar con otro tipo de estructuras de repeticin. Sintaxis: hacer { Bloque de sentencias; } mientras ( condicin ) hacer sentencia; mientras ( condicin ) Ntese que la diferencia entre los dos tipos de sintaxis es que en una mientras haya ms de una instruccin (lnea de codigo), se tienen que poner llaves que engloben al bloque de sentencias, mientras en el que solo hay una instruccin no se agregan llaves, la lnea se ejecuta automticamente como parte del ciclo de repeticin. El ciclo do while repite todo el bloque de sentencias al menos una vez ya que al entrar a este nunca evala alguna condicin, por lo tanto, entra y empieza a ejecutar las sentencias; hasta llegar al final de estas, es entonces donde compara la condicin para determinar si sta es falsa o verdadera. Si la condicin es falsa el flujo del programa contina en la siguiente instruccin fuera del ciclo de repeticin, pero si esta es verdadera entonces regresa el flujo al bloque inicial de instruccines del ciclo de repeticin y vuelve a repetirlas hasta llegar otra vez a la condicin y as sucesivamente mientras la condicin sea verdadera. Diagrama de Flujo:
sentencia
sentencia
sentencia
sentencia falsa mientras condicin
verdadera
Figura 6. Diagrama de Flujo del Ciclo Do
Ejemplo: Algoritmo que desarrolla el factorial de un nmero N con la formula: N! = N . (N-1) . (N-2), , 3 . 2 . 1 Algoritmo factorial_numero inicio declarar variables enteras Q, N real factorial escribir ( Programa que da el factorial de un numero dado desde el teclado ) escribir ( Da el nmero para obtener el factorial ) leer ( N ) factorial 1 Q1 hacer factorial factorial * Q QQ+1 mientras ( Q < = N ) escribir ( El factorial del nmero N es: , factorial ) pausa fin Programa factorial_numero #include <stdio.h> #include<conio.h> void main() { int Q, N; float factorial; printf("\n\n Programa que da el factorial de un numero dado desde el teclado ); printf( Da el nmero para obtener el factorial \n ); scanf("%d",&N); factorial = 1; Q = 1; do { factorial = factorial * Q; Q = Q + 1; } while ( Q < = N); printf( El factorial del nmero %d es: %f , N , factorial ); getch(); }
En un ciclo de repeticin como lo es el do-while primero se ejecuta el cuerpo del bucle siempre al menos una vez. Cuando este se ejecuta lo primero que se realiza es el bloque de sentencias, para al final evaluar la expresin booleana resultante de la condicin, si dicha condicin es falsa se ejecuta al menos una vez el bloque y si la condicin se evala a verdadera se regresa el control al inicio del bloque de sentencias y se vuelven a ejecutar todas para llegar de nueva cuenta a la evaluacin de la condicin; si esta sigue siendo verdadera se vuelve a repetir y as sucesivamente hasta que la condicin resulte ser falsa y da por terminado el proceso. El siguiente programa imprime los 100 primeros nmeros Algoritmo: Algoritmo cien_numeros inicio declarar variables enteras numero numero 1 escribir ( Programa cien nmeros ) hacer escribir ( numero ) numero numero + 1 mientras ( numero < = 100 ) pausa fin Programa: #include <stdio.h> #include<conio.h> void main() { int numero; numero = 1; printf ( Programa cien numerous \n ); do { printf( %d \n , numero); numero = numero + 1; } while ( numero < = 100); getch(); }
Diferencias de la estructura while y do-while: o La estructura while ejecuta el bloque de sentencias mientras la condicin sea verdadera, como esta se encuentra al inicio del ciclo; si esta es falsa nunca se ejecuta el bloque de sentencias. La estructura do-while ejecuta siempre el bloque de sentencias al menos una vez, sin importar la condicin que tenga, ya que esta se evala al final del ciclo de repeticin (despus de todas las sentencias). La estructura do-while se ejecuta al menos una vez, por el contrario, la estructura while es ms general y permite la posibilidad de que nunca se ejecute el bucle.
3.3. Estructuras de Control

Las estructuras de control de un lenguaje de programacin se refieren a l orden en que las instrucciones de un algoritmo se ejecutarn. El orden de ejecucin de las sentencias o instrucciones determina el flujo de control. Estas estructuras de control son por consiguiente fundamentales en los lenguajes de programacin y en los diseos de algoritmos especialmente los pseudocdigos. Las tres estructuras de control bsico son: secuencia seleccin repeticin
No C A
Si C Si
No
Secuencia
Seleccin Figura 7. Estructuras de Control
Iteracin
Por lo regular en un programa los enunciados son ejecutados uno despus del otro, en el orden en que aparecen escritos. Esto se conoce como ejecucin secuencial. Sin embargo, existen enunciados que le permiten al programador especificar que el enunciado siguiente a ejecutar pueda ser otro diferente al que sigue en secuencia. Esto se conoce como transferencia de control. Todos los programas pueden ser escritos en trminos de solo tres estructuras de control, a saber, la estructura de secuencia, la estructura de seleccin y la estructura de repeticin o bucle. Hay dos tipos de sentencias condicionales o de seleccin, la sentencia if y switch, por otro lado para las de iteracin se encuentran los bucles for, while, do-while. Sentencia if Sintaxis en su forma simple: si ( condicin ) entonces Sentencia1 fin_si Sintaxis en su forma compuesta: si ( condicin ) entonces
Sentencia1 si_no Sentencia2 fin_si La forma general de estas sentencias es: if (expresin) sentencia1
if (expresin) sentencia1 else sentencia2
/*bloque1*/ /*bloque2*/
Cuando dentro de cada sentencia se ejecutar ms de una proceso, se deben de poner llaves para delimitar cuantas sentencias ejecutar cada bloque y en donde han de terminar estas. Sintaxis del ciclo if con ms de una sentencia: si ( condicin ) entonces { bloque de Sentencias } fin_si Sintaxis en su forma compuesta: si ( condicin ) entonces { bloque de sentencias } si_no { bloque de sentencias } fin_si La forma general de estas sentencias es: if (expresin) { sentencia1; sentencia2; sentencia3; . . . SentenciaN; } if (expresin) { sentencia1a; sentencia2a; sentencia3a; .
/*bloque1*/
. . sentenciaNa; } else { Sentencia1b; Sentencia2b; Sentencia3b; . . . sentenciaNb; } Si la ejecucin es verdadera se ejecuta la sentencia1 bloque1, si es falsa se ejecuta la sentencia 2 o bloque2. En donde los objetos de if y else son sentencias simples. La sentencia if es opcional. Es importante saber que solo se ejecutar una sentencia o un bloque, nunca ambos. Diagrama de Flujo del ciclo If: /*bloque2*/
No Condicin
Si
Sentencia 2
Sentencia 1
Figura 8. Sentencia if
Un ejemplo de uso de esta sentencia es el siguiente fragmento de programa, que decide si un nmero es par: Algoritmo: declarar variables enteras numero 0 esPar 0 si ( ( numero % 2 ) = 0 ) entonces esPar 1 fin_si Programa: int numero = 0, esPar = 0;
if ((numero % 2) == 0) esPar = 1; Sentencia Switch: Esta sentencia es de decisin con bifurcacin mltiple, compara sucesivamente una variable con una lista de enteros. Cuando se obtiene una igualdad, se ejecuta una sentencia o bloque de sentencias. El default se ejecuta si no se encuentran igualdades. El default es opcional y si no esta presente no tiene lugar ninguna opcin cuando todas las comprobaciones fallan. El switch defiere del if del que solo puede probar una igualdad, mientras que if puede evaluar una expresin relacional o lgica. La sentencia break se utiliza dentro de cada case, originando que el control del programa salga de la sentencia completa del switch y continua en la sentencia siguiente al switch, si no se encuentran las sentencias break, todas las sentencias antes y despus de la igualdad se ejecutarn. Se puede pensar que case es una etiqueta para indicar donde debe seguir la ejecucin, despus de leer una opcin desde el teclado. La forma general de esta sentencia es: segn_sea (expresin exp) hacer { exp 1 : sentencia 1a; sentencia 2a; . . . break exp 2 : sentencia 1b; sentencia 2b; . . . break exp 3 : sentencia 1c; sentencia 2c; . . . break default : sentencia 1x break fin_segn_sea Su representacin en programacin es: switch (expresin) { case exp 1: sentencia 1; sentencia 2; break; case exp 2: sentencia 1; sentencia 2; break;
case exp N: sentencia N; break; default: sentencia D; } Diagrama de Flujo:

Inicio
Evala Expresin
Case 1
Case 1
Case 1
Case 1
sentencias sentencias
sentencias
sentencias
sentencias
break
break
break
break
fin Figura 9. Estructura Switch
Sentencia for Esta sentencia tiene como caracterstica que permite la declaracin de las variables dentro de su estructura. Ayudando a ser ms entendible y legible su ejecucin, como en l se inicializan los valores de las variables, se pueden dar incrementos o decrementos en las cantidades que uno desee al instante, esto es, antes de entrar al ciclo de repeticin el programador ya sabe como va empezar y terminar con exactitud el ciclo y de cuanto en cuanto va a ir avanzando la variable. Sintaxis: para ( inicializacin; condicin; incremento) hacer sentencia Con ms de una sentencia dentro del cuerpo del ciclo for quedara: para ( inicializacin; condicin; incremento) hacer { bloque de sentencias } En Lenguaje C propiamente estara:
for simple: for (expresion 1; expresion 2; expresion 3) sentencia; for compuesto por mas de una sentencia: for (expresion 1; expresion 2; expresion 3) { Sentencia1; Sentencia2; Sentencia3; . . . sentenciaN; } Expresin1 (inicializacin).- declaracin de las variables y asignacin de valores iniciales. Expresin2 (condicin).- instruccin que puede evaluarse de tal forma que se obtenga como resultado un valor de verdad (falso/true), mientras la condicin se cumpla, se ejecutar. Expresin3 (control).- es el conjunto de instrucciones, separadas por comas, que controlan la variacin de los valores de las variables utilizadas.
Sentencias
Diagrama de Flujo del

Si I vi I > vf I vi + y No Sentencias
ciclo For
Sentencias
Figura 10. Estructura for
En el diagram de flujo anterior se expresa el ciclo for con las literales siguientes: I = variable, vi = valor inicial, vf = valor final y Y = como un valor cualquiera de incremento para que nos ayude a salir del ciclo de repeticin. Si la variable no cumple la condicin, el ciclo se seguir repitiendo, hasta que la condicin se cumpla o sea verdadera el ciclo (bucle) se dar por terminado y por ende contina el programa en la siguiente instruccin despus del ciclo for. Algoritmo: inicio declarar entero contador para ( contador = 1; contador <= 10; contador++ ) hacer escribir ( contador ) fin_para Programa: #include <stdio.h> main() { int contador; for (contador=1; contador<=10; contador++) printf("%d ", contador); }
Sentencia while Si se desea hacer que una parte del programa se repita mientras se cumpla una cierta condicin, se puede usar la sentencia while. Mientras la condicin se mantenga verdadera, el bloque de instrucciones se ejecutar x cantidad de veces. Es necesario que alguna vez la condicin se haga falsa, pues de lo contrario se hara un bucle infinito, por lo tanto es necesario que en el bloque se ejecute alguna accin que haga falsa la condicin. La forma general de esta sentencia es: while (expresin) sentencia;
Algoritmo: De un mientras simple mientras ( condicin ) hacer sentencia Algoritmo: De un mientras compuesto con ms de una lnea en el cuerpo del bucle mientras ( condicin ) hacer { bloque de sentencias } Diagrama de Flujo del While
sentencias
No Mientras condicin Si Cuerpo del programa (sentencias)
Figura 11. Sentencia While
Un ejemplo que nos diga si cada nmero que tecleemos es positivo o negativo, y que pare cuando tecleemos el nmero 0, podra ser:
Algoritmo: inicio declarar variable entera numero escribir ( Teclea un nmero (0 para salir) ) leer numero mientras numero > 0 hacer si numero > 0 escribir ( Es positivo ) si_no
escribir ( Es negativo ) fin_si escribir ( Teclea otro numero ( 0 para salir ) ) leer numero fin_mientras fin Programa: #include <stdio.h> main() { int numero; printf("Teclea un nmero (0 para salir): "); scanf("%d", &numero); while (numero!=0) { if (numero > 0) printf("Es positivo\n"); else printf("Es negativo\n"); printf("Teclea otro nmero (0 para salir): "); scanf("%d", &numero); } } Sentencia do-while Tiene un comportamiento similar al while, solo que en este caso la sentencia do-while, primero ejecutar la serie de instrucciones y despus se evala la condicin, con esto se asegura que el bloque se ejecutar al menos una sola vez. Sintaxis: hacer sentencias mientras (condicin) En lenguaje C es as: do sentencia; while (condicin); En el caso de la siguiente sintaxis se abren y cierran llaves debido a que no solo es una sentencia la que se va a realizar dentro del ciclo de repeticin, sino que se ejecutarn muchas lneas de cdigo (sentencias). do { bloque de sentencias; }while (condicin); Diagrama de Flujo del
Acciones Sentencias
ciclo Do While
Falsa Mientras Autores: Alejandra Gutierrez Reyes - Enrique Martnez Roldn - Academia de Computacin Ingenieria Elctrica condicin ESIME Zacatenco IPN verdadera 1
Figura 12. Estructura do-while
Veremos ahora un ejemplo en el cual se va a requerir una clave de acceso y no se va a dejar entrar hasta que se teclee la opcin correcta.
Algoritmo: inicio declarar variables Enteras valida = 711, clave hacer escribir ( Introduzca su clave numrica: ) leer clave si clave != valida escribir ( No vlida ! ) fin_si mientras_que ( clave != valida ) escribir ( Aceptada. ) fin Programa:
#include <stdio.h> int main() { int valida = 711; int clave; do { printf("Introduzca su clave numrica: "); scanf("%d", &clave); if (clave != valida) printf("No vlida!\n"); } while (clave != valida); printf("Aceptada.\n"); }
3.3.1 Ruptura de un Lazo Los enunciados break y continue son utilizados para modificar el flujo de control dentro de un programa.
Sentencia break
La sentencia break tiene dos usos. El primer uso es terminar un case en la sentencia del switch. El segundo es ser utilizado dentro de las estructuras de control causa la inmediata salida de dicha estructura (por lo tanto no sigue repitindose el bloque y contina la ejecucin de las instrucciones que le siguen a la estructura de control). Cuando se encuentra la sentencia break en un bucle, la computadora termina inmediatamente el bucle y el control del programa vuelve a la sentencia siguiente del bucle, por ejemplo: Algoritmo: inicio declarar variables entero t para ( t = 0;t < 100;t++ ) hacer escribir ( t ) si ( t = 10 ) entonces romper fin_si fin_para pausa fin Programa: int main() { int t; for(t=0;t<100;t++) { printf(%d,t); if(t==10) break; } getch(); } Este programa imprime el nmero de 0 a 10 en la pantalla y despus termina porque el break causa la salida inmediata del bucle. El break salta la prueba condicional t<100 construida en el bucle.
Sentencia continue
La sentencia continue funciona de manera similar a la sentencia break. Sin embargo, en vez de forzar la continuacin, continue fuerza la siguiente iteracin y salta cualquier cdigo entre medias. Por ejemplo, el siguiente programa solo visualiza los nmeros pares. Algoritmo: inicio declarar variables entero x para ( x = 0; x < 100; x++ ) hacer si ( x % 2 ) entonces continua fin_si
escribir ( x ) fin_para pausa fin Programa: int main() { int x; for(x=0;x<100;x++) { if(x%2) continue; printf(%d,x); } getch(); } Cada vez que el programa genera un nmero impar, la sentencia if ejecuta ya que el resto de un numero impar entre 2 es igual a 1, que es verdad. As un nmero impar provoca la ejecucin de continue, que provocar que ocurra la siguiente iteracin, saltando la sentencia printf. En los bucles while y do - while, una sentencia continue provoca que el control del programa vaya directo a la prueba condicional y despus continue el proceso del bucle. En el caso del for la computadora realiza primero la parte de incremento del bucle y despus la prueba condicional, despus contina finalmente el bucle. Se puede usar continue para expeditar la terminacin de un bucle forzando a la computadora a realizar la prueba condicional tan pronto como encuentra alguna condicin de terminacin.
UNIDAD IV ESTRUCUTRAS DE DATOS
4.1. Arreglo Unidimensionales

4.1.1. Concepto y forma general Un arreglo unidimensional es un tipo de datos estructurado que est formado de una coleccin finita y ordenada de datos del mismo tipo. Es la estructura natural para modelar listas de elementos iguales. El tipo de acceso a los arreglos unidimensionales es el acceso directo, es decir, podemos acceder a cualquier elemento del arreglo sin tener que consultar a elementos anteriores o posteriores, esto mediante el uso de un ndice para cada elemento del arreglo que nos da su posicin relativa. Para implementar arreglos unidimensionales se debe reservar espacio en memoria, y se debe proporcionar la direccin base del arreglo, la cota superior y la inferior. La declaracin de arreglos sigue la estructura general de las declaraciones, es decir consta de un especificador de clase de almacenamiento opcional, un especificador de tipo de dato, el identificador del arreglo, el operador u operadores de arreglo con su respectiva dimensin y el inicializador es opcional. Sintaxis: Tipo de dato nombre_del_arreglo [dimensin]; Como ejemplo se tiene: int a[5]; float arre[50]; char vector[20]; El tipo de acceso a los arreglos unidimensionales es el acceso directo, es decir, podemos acceder a cualquier elemento del arreglo sin tener que consultar a elementos anteriores o posteriores, esto mediante el uso de un ndice para cada elemento del arreglo que nos da su posicin relativa. Para implementar arreglos unidimensionales se debe reservar espacio en memoria, y se debe proporcionar la direccin base del arreglo, la cota superior y la inferior.
Elemento 1 Elemento 2 Elemento 3 Elemento 4 . . . Elemento N
Figura 13. Arreglo Unidimensional
Un arreglo (array) matriz o vector es un conjunto ordenado de elementos homogneos; esto es, un arreglo unidimensional va de uno en uno empezando en la localidad nmero cero y de esta manera se puede accesar en cualquier instante a la localidad que se desee. Un arreglo se
dice que es homogneo porque todos sus elementos son del mismo tipo, por eso nunca podremos encontrar un arreglo que contenga en su interior valores enteros conjuntamente con valores de tipo carcter o veceversa. Los arreglos estn formados por un conjunto de elementos de un mismo tipo de datos que se almacenan bajo un mismo nombre, y se diferencian por la posicin que tiene cada elemento dentro del arreglo de datos. Al declarar un arreglo, se debe inicializar sus elementos antes de utilizarlos. Para declarar un arreglo tiene que indicar su tipo, un nombre nico y la cantidad de elementos que va a contener. Por ejemplo, las siguientes instrucciones declaran tres arreglos distintos: float costo_partes[50]; int edad_empleados [100]; float precios_acciones [25];
int calificaciones [100];
tipo
nombre_arreglo
Calificaciones [0] Calificaciones [1] Calificaciones [2] . . . Calificaciones [99]
tamao del arreglo
Figura 14. Estructura de un arreglo
Para acceder a valores especficos del arreglo, use un valor de ndice que apunte al elemento deseado. Por ejemplo, para acceder al primer elemento del arreglo calificaciones debe utilizar el valor de ndice 0 (calificaciones[0]). Los programas en C siempre indican el primer elemento de un arreglo con 0 y el ltimo con un valor menor en una unidad al tamao del arreglo. El ndice siempre va entre corchetes e indica la posicin y orden de un vector, por ejemplo estos seran ejemplos de arreglos y sus ndices. A[1], A[2], A[3], , A[N] Arr[0], arr[1], arr[2], , arr[n]
La inicializacin de arreglos se realiza por medio del conjunto de valores iniciales de los distintos elementos del arreglo, agrupado por medio de llaves. La asignacin de valores al arreglo unidimensional es en orden de secuencia con respecto al valor del ndice [0] a [N]. Asignacin de un arreglo de tipo entero llamado a y uno de tipo real llamado datos : int a[5] = {1,2,3,5,6}; float datos[6] = { 3.4, 6.8, 2.2, 10, 6.6, 9.9 } En el siguiente ejemplo se muestra el llenado de un arreglo (vector) con valores de cero a 10, empezando a llenar en la localidad cero y terminando en la localidad nueve. Algoritmo: inicio constante Tam 10 declarar variables entero i, a[Tam] para (i = 0; i < Tam; i++) hacer a[i] 0 fin_para para (i = 0; i < Tam; i++) hacer escribir ( a[i] ) fin_para return 0; fin Programa: #include <stdio.h> #define Tam 10 int main(void) { int i, a[Tam]; for(i = 0; i < Tam; i++) a[i] = 0; for(i = 0; i < Tam; i++) printf ("%d\n", a[i]); return 0; }
Cuando se usan arreglos, una operacin comn es usar una variable ndice para acceder a los elementos de un arreglo. Suponiendo que el arreglo se llamar valores, y la variable ndice i contiene el nmero 3, la siguiente instruccin asignar el valor 400 a dicho vector, como si fuera una variable simple al ocupar una posicin de memoria:
Valores [3] 400 Valores [3] = 400; Partes de un arreglo:

Nombre e ndice
X[0]
14.0
X[1]
8.0
X[2]
10.5
X[3]
4.5
X[4]
12.0
X[5]
5.5
X[6]
10.0
Elemento1 Elemento2 Elemento3

Figura 15. Elementos de un arreglo
Elemento7
Los componentes. Hacen referencia a los elementos que forman el arreglo, es decir, a los valores que se almacenan en cada una de las casillas del mismo. Los ndices, permiten hacer referencia a los componentes del arreglo, en forma individual especifican cuntos elementos tendr el arreglo y adems, de qu modo podrn accesarse a esos componentes.
S1
S2
S3
SN
Componentes
Figura 16. Componentes de un arreglo
Las operaciones que se pueden realizar con vectores durante el proceso de resolucin de un problema son: Lectura/ escritura Asignacin Actualizacin (insercin, eliminacin, modificacin) Recorrido (acceso secuencial) Ordenacin Bsqueda Ejemplos: Sea arre un arreglo de 70 elementos enteros con ndices enteros. Su representacin nos queda:
23
778
10
51
100
11
99
..
68
69
Figura 17. Arreglo de enteros
Lectura El proceso de lectura de un arreglo consiste en leer y asignar un valor a cada uno de sus elementos. Normalmente se realizan con estructuras repetitivas, aunque pueden usarse estructuras selectivas. Usamos los ndices para recorrer los elementos del arreglo: Algoritmo: para ( i = 1; i <= 70; i++ ) hacer leer ( arre[i]) fin_desde Programa: for ( i = 1; i <= 70; i++ ) scanf ( %d , & arre [i]);
Escritura: Es similar al caso de lectura, slo que en vez de leer el componente del arreglo, lo escribimos. Algoritmo: leer (N) para ( i = 1 ; i <= N ; i++ ) hacer escribir ( arre[i] ) fin_para Programa: scanf ( %d , & N); for ( i = 1; i <= N; i++ ) printf ( %d \n , arre [i]); Asignacin: No es posible asignar directamente un valor a todo el arreglo; sino que se debe asignar el valor deseado en cada componente. Con una estructura repetitiva se puede asignar un valor a todos los elementos del vector. Por ejemplo: arre[1] = 120;(asignacin de un valor constante nico a una casilla del vector) (asignar una operacin)
arre[3] = arre[1] / 4;
Se puede asignar un valor constante a todos los elementos del vector: Algoritmo: para ( i = 1; i <= 5; i++ ) hacer arre[i] 3 fin_desde Programa: for ( i = 1; i <= 5; i++ ) arre [i] = 3; O bien
arre = 3 (con arre del tipo arreglo) Inicializacin Para inicializar con cero todos los elementos del arreglo: Algoritmo: para ( i = 1; i <= 70; i++ ) hacer arre[i] 0 fin_para Programa: for ( i = 1; i <= 70; i++ ) arre [i] = 0;
5 Arre [ 70 ]
........
69
70
Figura 18. Arreglo con for
Acceso Secuencial. (Recorrido) El acceso a los elementos de un vector puede ser para leer en l o para escribir (visualizar su contenido). Recorrido del vector es la operacin de efectuar una accin general sobre todos los elementos de ese vector. Actualizacin. Incluye aadir (insertar), borrar o modificar algunos de los ya existentes. Se debe tener en cuenta si el arreglo est o no ordenado. Aadir datos a un vector consiste en agregar un nuevo elemento al final del vector, siempre que haya espacio en memoria. Ejemplo. Algoritmo: inicio declarar variables entero i entero a[ 5 ] para ( i = 0; i < 4; i++ ) hacer excribir ( Ingrese el elemento: ) leer ( a [ i ] ) fin_para para ( i = 0; i < 4; i++ ) hacer excribir ( Elemento: , a [ i ] ) fin_para pausa fin
Programa: #include<stdio.h> #include<conio.h> void main() { int a[5]; // Definicin de un arreglo de 5 posiciones int i; // Pedimos el ingreso de 5 nmeros for(i=0; i<4; i++) //No olvidar que los arreglos van de 0 a longitud-1 { printf( Ingrese el elemento: ); scanf(%d,&a[i]); } // Para imprimir ser for(i=0; i<4; i++) { printf( Elemento: %d ,a[i]); } getch(); }
4.1.2. Arreglos numricos y de caracteres Un vector a de 10 enteros de tipo int se declara as: int a[10]; El vector a comprende los elementos a[0], a[1], a[2], . . . , a[9], todos de tipo int. Los ndices de los vectores en C empiezan en cero. Al igual que ocurra con las variables normales, podemos dar valor a los elementos de un arreglo al principio del programa. Esta vez los indicaremos todos entre llaves, separados por comas Algoritmo: inicio declarar variables entero numero [ 5 ] = { 200, 150, 100, -50, 300 } entero suma suma = numero [0] + numero[1] + numero [2] + numero[3] + numero [4] escribir ( Su suma es , suma ) pausa fin Programa: #include <stdio.h> main() { int numero[5] ={200,150,100,-50,300}; //Un array de 5 nmeros enteros int suma; // Un entero que ser la suma
suma = numero[0]+numero[1]+numero[2]+numero[3]+numero[4]; printf("Su suma es %d", suma); getch(); } En una misma lnea puedes declarar ms de un vector, siempre que todos compartan el mismo tipo de datos para sus componentes. Las cadenas en C son vectores de caracteres (elementos de tipo char) con una peculiaridad: el texto de la cadena termina siempre en un carcter nulo. El carcter nulo tiene cdigo ASCII 0 y podemos representarlo tanto con el entero 0 como con el carcter \0. Declaracin de cadenas Las cadenas se declaran como vectores de caracteres, as que debes proporcionar el nmero mximo de caracteres que es capaz de almacenar: su capacidad. Esta cadena, por ejemplo, se declara con capacidad para almacenar 10 caracteres: char a[10]; Puedes inicializar la cadena con un valor en el momento de su declaracin: char a[10] = "cadena"; Se muestra la declaracin como un vector de 10 caracteres y lo hemos inicializado asignndole la cadena "cadena". Es decir, es como si hubisemos inicializado la cadena de este otro modo, equivalente: char a[10] = { c, a, d, e, n, a, \0 };
4.2. Arreglos bidimensionales

4.2.1. Concepto y forma general Los arreglo bidimensionales son una forma de lograr que nuestro programa pueda hacer tablas, utilizando un ndice que ser siempre un dato del tipo entero. La mayora de las definiciones de qu es una tabla son como la siguiente, "Una tabla es un conjunto de variables que comparten el mismo tipo de dato y nombre y a las que se hace referencia a travs de un ndice" (el ndice como ya se dijo antes debe ser un tipo de dato entero). Este tipo de arreglos al igual que los anteriores es un tipo de dato estructurado, finito ordenado y homogneo. El acceso a ellos tambin es en forma directa por medio de un par de ndices. Los arreglos bidimensionales se usan para representar datos que pueden verse como una tabla con filas y columnas. La primera dimensin del arreglo representa las columnas, cada elemento contiene un valor y cada dimensin representa una relacin. Elemento 1,1 Elemento 2,1 Elemento 3,1 . Elemento m,1 .. . . . . Elemento 1,n Elemento 2,n Elemento 3,n . Elemento m,n
Figura 19. Matriz M x N
Tambin es importante mencionar que algunos autores hacen uso del termino "vector" en los lenguajes de programacin (igual que en las matemticas) para referirse a las tablas de una sola dimensin y que matriz siempre se refiere a tablas bidimensionales. Sintaxis de un arreglo bidimensional: Tipo de dato nombre del arreglo [filas][columnas]; La representacin en memoria se realiza de dos formas: almacenamiento por columnas o por renglones. Un arreglo bidimensional a , que contienen tres filas y cuatro columnas (es decir un arreglo de tres por cuatro). En general, a este tipo de arreglo con m filas y n columnas se le llama arreglo de n x m (bidimensional). Es un conjunto de datos homogneo, finito y ordenado, donde se hace referencia a cada elemento por medio de dos ndices. El primero se utiliza para los renglones (filas) y el segundo para las columnas. Tambin puede definirse como un arreglo de arreglos. Internamente en memoria se reservan MxN posiciones consecutivas para almacenar todos los elementos del arreglo. Declaracin de una matriz: arreglo [ liminf1, limsup1, liminf2, limsup2 ] filas Por ejemplo: 1 <= I <= M 1 <= J <= N Se representara como se muestra a continuacin en forma de una tabla 1 1
2 I M Figura 20. Declaracin de una matriz
columnas
...
Algoritmo para el recorrido por filas: constantes M =valor1 N = valor2 declarar variables real Matriz [M][N] para ( i = 1; i<= M; i++ ) hacer
para ( j = 1; j<= N; j++ ) hacer escribir ( Matriz [ i] [j ] ) fin_desde fin_desde Programa: #include <stdio.h> #define M valor1 #define N valor2 main() { float Matriz[M][N] //Un array de M x N nmeros reales for(i=1;i<=M;i++) for ( j = 1; j<= N; j++ ) printf(" %f ", Matriz [M][N]); getch(); } El recorrido por columnas se hace de manera similar, invirtiendo el sentido de los ndices. constantes M valor1 N valor2 declarar variables real Matriz [N][M] para ( i = 1; i<= N; i++ ) hacer para ( j = 1; j<= M; j++ ) hacer escribir ( Matriz [ i] [j ] ) fin_desde fin_desde Programa: #include <stdio.h> #define M valor1 #define N valor2 main() { float Matriz[N][M] //Un array de M x N nmeros reales for(i=1;i<=N;i++) for ( j = 1; j<= M; j++ ) printf(" %f ", Matriz [N][M]); getch(); } Ejemplos. 1) Rellenar una matriz identidad de 4 por 4 elementos. Una matriz identidad es aquella en la que la diagonal principal est llena de unos y el resto de los elementos son cero. Para llenar la matriz identidad se debe verificar que cuando los ndices i y j sean iguales, la posicin vale 1, en caso contrario se asigna cero al elemento i, j.
1 0
0 1
0 0
0 0
1
Autores: Alejandra Gutierrez Reyes - Enrique Martnez Roldn - Academia de Computacin Ingenieria Elctrica ESIME Zacatenco IPN
0 0
0 0
1 0
0 1
Figura 21. Matriz Identidad
Algoritmo inicio para ( i = 1; i<= 4; i++ ) hacer para ( j = 1; j <= 4; j++) hacer si ( i = j ) entonces Matriz [i] [j] 1 si_no Matriz[i] [j] 0 fin_si fin_desde fin_desde fin Programa: #include <stdio.h> void main() { for(i=1;i<=4;i++) for ( j = 1; j<= 4; j++ ) if (i == j ) Matriz [i][j] = 1; else Matriz [i][j] = 0; getch(); } Las operaciones en arreglos pueden clasificarse de la siguiente forma: a) lectura Este proceso consiste en leer un dato de un arreglo y asignar un valor a cada uno de sus componentes. La lectura se realiza de la siguiente manera: Algoritmo: escribir ( Cuantos valores deseas que tenga el arreglo ) leer ( N ) para ( i=1; i<= N; i++ ) hacer leer ( arreglo[i] ) Programa: printf ( Cuantos valores deseas que tenga el arreglo ); scanf (%d, &N); for ( i=1; i<= N; i++ ) scanf ( %d, & arreglo [i] ); b) escritura Consiste en despus de asignarle valores a cada elemento del arreglo, mostrarlos en pantalla. La escritura se realiza de la siguiente manera:
Algoritmo: escribir ( Cuantos valores deseas que tenga el arreglo ) leer ( N ) para ( i=1; i<= N; i++ ) hacer leer ( arreglo[i] ) para ( i=1; i<= N; i++ ) hacer escribir ( arreglo [i] ); Programa: printf ( Cuantos valores deseas que tenga el arreglo ); scanf (%d, &N); for ( i=1; i<= N; i++ ) scanf ( %d, &arreglo [i] ); for ( i=1; i<= N; i++ ) printf( %d , arreglo [i] ); c) asignacin No es posible asignar directamente un valor a todo el arreglo, por lo que se realiza mediante los ciclo de repeticin cualquiera de ellos como el for, el do while el while con cualquiera de ellos el resultado es exactamente el mismo, y es de la manera siguiente: Algoritmo: escribir ( Cuantos valores deseas que tenga el arreglo ) leer ( N ) para ( i=1; i<= N; i++ ) hacer arreglo[i] i Programa: printf ( Cuantos valores deseas que tenga el arreglo ); scanf (%d, &N); for ( i=1; i<= N; i++ ) arreglo [i] = i; En el caso anterior el arreglo es llenado propiamente con la misma variable del ciclo for, por lo tanto; el arreglo contiene valores que van del 1 al valor N que dio el usuario. d) actualizacin Dentro de esta operacin se encuentran las operaciones de eliminar, insertar y modificar datos. Para realizar este tipo de operaciones se debe tomar en cuenta si el arreglo est o no ordenado. La definicin formal del parmetro le permite al compilador determinar las caractersticas del valor del puntero que ser pasado en tiempo de ejecucin. 4.2.2. Arreglos numricos y de caracteres En una cadena que definamos como char texto[40] lo habitual es que realmente no ocupemos las 39 letras que podramos llegar a usar. Si guardamos 9 letras (y el carcter nulo que marca el final), tendremos 30 posiciones que no hemos usado. Pero estas 30 posiciones generalmente contendrn basura, lo que hubiera previamente en esas posiciones de memoria, porque el compilador las reserva para nosotros pero no las limpia, por lo tanto el carcter que marca el final de nuestra cadena es el nulo /0.
Hay una funcin de cadena predefinida por lenguaje C que nos dice cuantas letras hemos usado realmente en nuestra cadena sin necesidad de contabilizarlo nosotros mismos, lo hace automticamente y es strlen, que se usa as: Algoritmo: inicio declarar variables carcter texto[ 40 ] escribir ( Introduce una palabra: ) leer ( texto ) escribir ( Has tecleado , strlen (texto) , letras ) pausa fin Programa: #include <stdio.h> #include <string.h> main() { char texto[40]; printf("Introduce una palabra: "); scanf("%s", texto); printf("Has tecleado %d letras", strlen(texto)); getch(); } Como es de esperar, si escribimos Hola, esta orden nos dir que hemos tecleado 4 letras (no cuenta el carcter nulo \0 que se aade automticamente al final). Si empleamos esta orden, o alguna de las otras rdenes relacionadas con cadenas de texto que veremos en este tema, debemos incluir la cabecera <string.h>, que es donde se definen todas ellas. Hemos visto que si leemos una cadena de texto con scanf, se paraba en el primer espacio en blanco y no segua leyendo a partir de ese punto. Existen otras rdenes que estn diseadas especficamente para manejar cadenas de texto, y que nos podrn servir en casos como ste. Para leer una cadena de texto (completa, sin parar en el primer espacio), usaramos la orden gets, as: gets(texto); De igual modo, para escribir un texto en pantalla podemos usar puts, que muestra la cadena de texto y avanza a la lnea siguiente: puts(texto); Sera equivalente a esta otra orden: printf("%s\n", texto); Cuando queremos dar a una variable el valor de otra, normalmente usamos construcciones como a = 2, o como a = b. Pero en el caso de las cadenas de texto, esta NO es la forma correcta, no podemos hacer algo como saludo = "hola" ni algo como texto1 = texto2. Si hacemos algo as, haremos que las dos cadenas estn en la misma posicin de memoria, y que los cambios que hagamos a una de ellas se reflejen tambin en la otra. La forma correcta de guardar en una cadena de texto un cierto valor es:
strcpy (destino, origen); Es decir, debemos usar una funcin llamada strcpy (cadena destino, cadena origen), que se encuentra tambin en <string.h>. Vamos a ver dos ejemplos de su uso: strcpy (saludo, "hola"); strcpy (textoDefinitivo, textoProvisional); En este ejemplo el mensaje cadena hola es copiado en la variable llamada saludo. Es nuestra responsabilidad que en la cadena de destino haya suficiente espacio reservado para copiar lo que queremos. Si no es as, estaremos sobrescribiendo direcciones de memoria en las que no sabemos qu hay. Para evitar este problema, tenemos una forma de indicar que queremos copiar slo los primeros n bytes de origen, usando la funcin strncpy, as: strncpy (destino, origen, n); Vamos a ver un ejemplo, que nos pida que tecleemos una frase y guarde en otra variable slo las 4 primeras letras: Algoritmo: inicio declarar variables carcter texto1[ 40 ] carcter texto2[ 40 ] carcter texto3[ 10 ] limpiar pantalla escribir ( Introduce una frase: ) leer ( texto1 ) copiar_cadena (text2, texto1) escribir ( Una copia de tu texto es: , texto2 ) copiar_cadena_n ( texto3, texto1, 4) escribir ( Y sus cuatro primeras letras son: , texto3 ) pausa fin Programa: #include <stdio.h> #include <string.h> main() { char texto1[40], texto2[40], texto3[10]; clrscr(); printf("Introduce un frase: "); gets(texto1); strcpy(texto2, texto1); printf("Una copia de tu texto es: %s\n", texto2); strncpy(texto3, texto1, 4); printf("Y sus cuatro primeras letras son %s\n", texto3); getch(); } Finalmente, existe otra orden relacionada con estas dos: podemos aadir una cadena al final de otra (concatenarla), con:
strcat (destino, origen); Vamos a ver un ejemplo de su uso, que nos pida nuestro nombre, nuestro apellido y cree una nueva cadena de texto que contenga los dos, separados por un espacio: Algoritmo: inicio declarar variables carcter texto1[ 40 ] carcter texto2[ 40 ] carcter texto3[ 40 ] limpiar pantalla escribir ( Introduce tu nombre: ) leer ( texto1 ) escribir ( Introduce tu apellido: ) leer ( texto2 ) concatenar ( texto1, ) concatenar (texto1, texto2 ) escribir ( Te llamas , texto1 ) pausa fin Programa: #include <stdio.h> #include <string.h> main() { char texto1[40], texto2[40], texto3[40]; clrscr(); printf("Introduce tu nombre: "); gets(texto1); printf("Introduce tu apellido: "); gets(texto2); strcat(texto1, " "); /* Aado un espacio al nombre */ strcat(texto1, texto2); /* Y luego el apellido */ printf("Te llamas %s\n", texto1); getch(); }
4.3. Apuntadores
Hasta ahora tenamos una serie de variables que declaramos al principio del programa o de cada funcin. Estas variables, que reciben el nombre de ESTTICAS, tienen un tamao asignado desde el momento en que se crea el programa.
Un Apuntador es una variable que contiene una direccin de memoria, la cual corresponder a un dato o a una variable que contiene el dato. Los apuntadores tambin deben de seguir las mismas reglas que se aplican a las dems variables, deben tener nombre nicos y deben de declararse antes de usarse. Cada variable que se utiliza en una aplicacin ocupa una o varias posiciones de memoria. Estas posiciones de memoria se accesan por medio de una direccin.
*h
Autores: Alejandra Gutierrez Reyes - Enrique Martnez Roldn - Academia de Computacin Ingenieria Elctrica ESIME Zacatenco IPN h
1000 1001 1002 1003 1004 1005
Figura 22. Puntero
En la figura el texto Hello esta guardado en memoria, comenzando en la direccin 1000. Cada carcter ocupa un espacio de direccin nico en memoria. Los apuntadores proporcionan un mtodo para conservar y llegar a estas direcciones en memoria. Los apuntadores facilitan el manejo de datos, debido a que conservan la direccin de otra variable o ubicacin de datos. Los apuntadores dan flexibilidad a los programas en C y en C++; tambin permiten que estos crezcan dinmicamente. Utilizando un apuntador hacia un bloque de memoria que se asigna al momento de ejecucin, un programa puede ser ms flexible que uno que asigna toda su memoria de una sola vez. Tambin, un apuntador es ms fcil de guardar que una estructura grande o un objeto de una clase. Debido a que un apuntador slo guarda una direccin, puede fcilmente pasarse a una funcin. Uno de las desventajas que pueden presentar los apuntadores es que un apuntador sin control o no inicializado puede provocar fallas en el sistema, adems de que su uso incorrecto puede generar fallas muy complejas de encontrar. Este tipo de variables son sencillas de usar y rpidas... si slo vamos a manejar estructuras de datos que no cambien, pero resultan poco eficientes si tenemos estructuras cuyo tamao no sea siempre el mismo. Es el caso de una agenda: tenemos una serie de fichas, e iremos aadiendo ms. Si reservamos espacio para 10, no podremos llegar a aadir la nmero 11, estamos limitando el mximo. Una solucin sera la de trabajar siempre en el disco: no tenemos lmite en cuanto a nmero de fichas, pero es muchsimo ms lento. Lo ideal sera aprovechar mejor la memoria que tenemos en el ordenador, para guardar en ella todas las fichas o al menos todas aquellas que quepan en memoria. Una solucin tpica (pero mala) es sobredimensionar: preparar una agenda contando con 1000 fichas, aunque supongamos que no vamos a pasar de 200. Esto tiene varios inconvenientes: se desperdicia memoria, obliga a conocer bien los datos con los que vamos a trabajar, sigue pudiendo verse sobrepasado, etc. La solucin suele ser crear estructuras DINMICAS, que puedan ir creciendo o disminuyendo segn nos interesen. Ejemplos de este tipo de estructuras son: Las pilas. Como una pila de libros: vamos apilando cosas en la cima, o cogiendo de la cima. Las colas. Como las del cine (en teora): la gente llega por un sitio (la cola) y sale por el opuesto (la cabeza). Las listas, en las que se puede aadir elementos, consultarlos o borrarlos en cualquier posicin. Y la cosa se va complicando: en los rboles cada elemento puede tener varios sucesores, etc. Todas estas estructuras tienen en comn que, si se programan bien, pueden ir creciendo o decreciendo segn haga falta, al contrario que un array, que tiene su tamao prefijado. En todas ellas, lo que vamos haciendo es reservar un poco de memoria para cada nuevo elemento que nos haga falta, y enlazarlo a los que ya tenamos. Cuando queramos borrar un elemento, enlazamos el anterior a l con el posterior a l (para que no se rompa nuestra estructura) y liberamos la memoria que estaba ocupando. 4.3.1. Concepto
Un puntero no es ms que una direccin de memoria. Lo que tiene de especial es que normalmente un puntero tendr un tipo de datos asociado: por ejemplo, un puntero a entero ser una direccin de memoria en la que habr almacenado (o podremos almacenar) un nmero entero. Hay 2 operadores que se usan cuando trabajan con direcciones en un programa en C; el Operador de Indireccin ( * ) y el de Direccin (&). Estos operadores son diferentes de los tratados anteriormente. El Operador de Direccin ( &) regresa la direccin de una variable. Este operador est asociado con la variable a su derecha: &h; esta lnea regresa la direccin de memoria de la variable h, la que contiene nuestra mquina internamente. El Operador de Indireccin ( * ) trabaja a la inversa del operador de Direccin. Tambin esta asociado con la variable a su derecha, toma la direccin y regresa el dato que contiene esa direccin de memoria. Por ejemplo, la siguiente lnea determina la direccin de la variable h y luego usa el operador de Indireccin para accesar la variable y darle un valor de 42: *(&h)=42; La declaracin de un puntero de manera general es: tipo *nombre del apuntador; Tipo : Especifica el tipo de objeto apuntado y puede ser cualquier tipo visto con anterioridad. Nombre de apuntador: Es el identificador del apuntador. El espacio de memoria requerido para un apuntador, es el nmero de bytes necesarios para especificar una direccin de memoria, debiendo apuntar siempre al tipo de dato correcto. Considere el siguiente programa y observe a las variables de direccin e Indireccin trabajar: Algoritmo: inicio declarar variables entero x 1, y 2 entero *ip limpiar pantalla escribir ( Antes del uso de los apuntadores ) escribir ( X = , x , Y = , y, *ip = , *ip ) ip &x y *ip *ip 10 escribir ( Despus del uso de los operadores ) escribir ( X = , x , Y = , y, *ip = , *ip ) pausa fin Programa: #include<stdio.h> #include<conio.h> int x=1; y=2;
int *ip; /* ip es apuntador a int */ void main() { clrscr(); printf( Antes del uso de los apuntadores ); printf( \n X = %d Y = %d *ip = %d , x,y,*ip); ip = &x; /* ip ahora apunta a x */ y = *ip; /* y vale 1 */ *ip = 10; /* ahora x vale 10 */ printf ( Despus del uso de los operadores ); printf( \n X = %d Y = %d *ip = %d , x,y,*ip); getch(); } La salida (corrida) del programa anterior es: Antes del uso de los operadores: X= 1 y=2 *ip = 0 Despus del uso de los operadores: X= 10 y=1 *ip = 10
Vamos a ver qu smbolo usamos en C para designar los punteros: int num; int *pos; /* "num" es un nmero entero */ /* "pos" es un "puntero a entero" (direccin de memoria en la que podremos guardar un entero) */
Es decir, pondremos un asterisco entre el tipo de datos y el nombre de la variable. Ese asterisco puede ir junto a cualquiera de ambos, tambin es correcto escribir int* pos; esta nomenclatura ya la habamos utilizado aun sin saber que era eso de los punteros. Por ejemplo, cuando queremos acceder a un fichero, hacemos FILE* fichero; antes de entrar en ms detalles, y para ver la diferencia entre trabajar con arrays o con punteros, vamos a hacer dos programas que pidan varios nmeros enteros al usuario y muestren su suma. El primero emplear un array (una tabla, de tamao predefinido) y el segundo emplear memoria que reservaremos durante el funcionamiento del programa. El primero podra ser as: Algoritmo: inicio declarar variables entero datos [100] entero cuantos entero i largo suma 0 limpiar pantalla hacer escribir ( Cuantos nmeros desea sumar ? ) leer ( cuantos ) si ( cuantos > 100 ) hacer escribir ( Demasiados. Solo se puede hasta 100. ) fin_si mientras ( cuantos > 100 ) para ( i = 0; i < cuantos; i++ ) hacer
escribir ( X = , x , Y = , y, *ip = , *ip ) pausa fin Programa: #include <stdio.h> main() { int datos[100]; /* Preparamos espacio para 100 numeros */ int cuantos; /* Preguntaremos cuantos desea introducir */ int i; /* Para bucles */ long suma=0; /* La suma, claro */ clrcsr(); do { printf(" Cuantos numeros desea sumar? "); scanf(" %d ", &cuantos); if (cuantos>100) /* Solo puede ser 100 o menos */ printf("Demasiados. Solo se puede hasta 100."); } while (cuantos>100); /* Si pide demasiado, no le dejamos */ /* Pedimos y almacenamos los datos */ for (i=0; i<cuantos; i++) { printf(" Introduzca el dato nmero %d: ", i+1); scanf(" %d ", &datos[i]); } /* Calculamos la suma */ for (i=0; i<cuantos; i++) suma += datos[i]; printf(" Su suma es: %ld\n ", suma); } Los ms avispados se pueden dar cuenta de que si slo quiero calcular la suma, lo podra hacer a medida que leo cada dato, no necesitara almacenar todos. Vamos a suponer que s necesitamos guardarlos (en muchos casos ser verdad, si los clculos son ms complicados). Entonces nos damos cuenta de que lo que hemos estado haciendo hasta ahora no es eficiente: Si quiero sumar 1000 datos, o 500, o 101, no puedo. Nuestro lmite previsto era de 100, as que no podemos trabajar con ms datos. Si slo quiero sumar 3 nmeros, desperdicio el espacio de 97 datos que no uso. Y el problema sigue: si en vez de 100 nmeros, reservamos espacio para 5000, es ms difcil que nos quedemos cortos pero desperdiciamos muchsima ms memoria. La solucin es reservar espacio estrictamente para lo que necesitemos, y eso es algo que podramos hacer as: Algoritmo: inicio declarar variables entero *datos entero cuantos entero i largo suma 0 limpiar pantalla
hacer escribir ( Cuantos nmeros desea sumar ? ) leer ( cuantos ) datos (entero *) malloc (cuantos * sizeof(entero)) si (datos = NULL) escribir ( No caben tantos datos en memoria. ) fin_si mientras ( datos = NULL ) fin_hacer escribir ( Introduzca el dato nmero , i+1 ) leer ( datos + i ) fin_para para ( i = 0; i < cuantos; i++ ) hacer suma suma + *datos + i fin_para escribir ( Su suma es: , suma ) liberar (datos) pausa fin Programa: #include <stdio.h> #include <stdlib.h> main() { int* datos; /* Necesitaremos espacio para varios numeros */ int cuantos; /* Preguntaremos cuantos desea introducir */ int i; /* Para bucles */ long suma=0; /* La suma, claro */ do { printf("Cuantos numeros desea sumar? "); scanf("%d", &cuantos); datos = (int *) malloc (cuantos * sizeof(int)); if (datos == NULL) /* Solo puede ser 100 o menos */ printf("No caben tantos datos en memoria."); } while (datos == NULL); /* Si pide demasiado, no le dejamos */ /* Pedimos y almacenamos los datos */ for (i=0; i<cuantos; i++) { printf("Introduzca el dato nmero %d: ", i+1); scanf("%d", datos+i); } /* Calculamos la suma */ for (i=0; i<cuantos; i++) suma += *(datos+i); printf("Su suma es: %ld \n", suma); free(datos); } Este programa funciona perfectamente si slo queremos sumar 5 nmeros, pero tambin si necesitamos sumar 120.000 (y si caben tantos nmeros en la memoria disponible de nuestro equipo, claro). Vamos a ver las diferencias: En primer lugar, lo que antes era int datos[100] que quiere decir a partir de la posicin de memoria que llamar datos, quede espacio para a guardar 100 nmeros enteros, se ha
convertido en int * datos que quiere decir a partir de la posicin de memoria que llamar datos voy a guardar varios nmeros enteros (pero an no s cuantos). Luego reservamos el espacio exacto que necesitamos, haciendo datos = (int *) malloc (cuantos * sizeof ( int ); Esta orden suena complicada, as que vamos a verla por partes: malloc es la orden que usaremos para reservar memoria cuando la necesitemos (es la abreviatura de las palabra memory y allocate). Como parmetro, le indicamos cuanto espacio queremos reservar. Para 100 nmeros enteros, sera 100*sizeof(int), es decir, 100 veces el tamao de un entero. En nuestro caso, no son 100 nmeros, sino el valor de la variable cuantos. Por eso hacemos malloc (cuantos*sizeof(int)). Para terminar, ese es el espacio que queremos reservar para nuestra variable datos. Y esa variable es de tipo int * (un puntero a datos que sern nmeros enteros). Para que todo vaya bien, debemos convertir el resultado de malloc al tipo de datos correcto, y lo hacemos forzando una conversin como vimos en el apartado 2.4 (operador molde), con lo que nuestra orden est completa: datos = (int *) malloc (cuantos * sizeof(int)); Si malloc nos devuelve NULL como resultado (un puntero nulo), quiere decir que no ha encontrado ninguna posicin de memoria en la que nos pudiera reservar todo el espacio que le habamos solicitado. Para usar malloc deberemos incluir stdlib.h al principio de nuestro fuente. La forma de guardar los datos que teclea el usuario tambin es distinta. Cuando trabajbamos con un array, hacamos scanf( %d , &datos[i]) (el dato nmero i), pero con punteros usaremos scanf( %d , datos+i) (en la posicin datos + i). Ahora ya no necesitamos el smbolo ampersand (&). Este smbolo se usa para indicarle a C en qu posicin de memoria debe almacenar un dato. Por ejemplo, float x; es una variable que podremos usar para guardar un nmero real. Si lo hacemos con la orden scanf, esta orden no espera que le digamos en qu variable deber guardar el dato, sino en qu posicin de memoria. Por eso hacemos scanf("%f", &x); En el caso que nos encontramos ahora, int* datos ya se refiere a una posicin de memoria (un puntero), por lo que no necesitamos & para usar scanf. Finalmente, la forma de acceder a los datos tambin cambia. Antes leamos el primer dato como datos[0], el segundo como datos[1], el tercero como datos[2] y as sucesivamente. Ahora usaremos el asterisco (*) para indicar que queremos saber el valor que hay almacenado en una cierta posicin: el primer dato ser *datos, el segundo *(datos+1), el tercero ser *(datos+2) y as en adelante. Por eso, donde antes hacamos suma += datos[i]; ahora usamos suma += *(datos+i). Tambin aparece otra orden nueva: free. Hasta ahora, tenamos la memoria reservada estticamente, lo que supone que la usbamos (o la desperdicibamos) durante todo el tiempo que nuestro programa estuviera funcionando. Pero ahora, igual que reservamos memoria justo en el momento en que la necesitamos, y justo en la cantidad que necesitamos, tambin podemos volver a dejar disponible esa memoria cuando hayamos terminado de usarla. De eso se encarga la orden free, a la que le debemos indicar qu puntero es el que queremos liberar. El ejemplo anterior era un caso real. Generalmente, los casos reales son ms aplicables que los ejemplos puramente acadmicos, pero tambin ms difciles de seguir. Por eso, antes de seguir vamos a ver un ejemplo ms sencillo que nos ayude a asentar los conceptos: Reservaremos espacio para un nmero real de forma esttica, y para dos nmeros reales de forma dinmica, daremos valor a dos de ellos, guardaremos su suma en el tercer nmero y mostraremos en pantalla los resultados.
Algoritmo: inicio declarar variables real n1 real *n2, *suma limpiar pantalla n1 5.0 n2 (float *) malloc (sizeof(float)) *n2 6.7 suma (float *) malloc (sizeof(float)) *suma n1 + *n2 escribir ( El valor prefijado para la suma era , *suma) escribir ( Ahora es tu turno: Introduce el primer nmero ) leer ( n1 ) escribir ( Introduce el segundo nmero ) leer ( n2 ) *suma n1 + *n2 escribir ( Ahora la suma es , *suma) liberar (n2) liberar (suma) pausa fin Programa: #include <stdio.h> #include <stdlib.h> main() { float n1; float *n2, *suma; n1 = 5.0;
/* Primer nmero, esttico */ /* Los otros dos nmeros */ /* Damos un valor prefijado a n1 (real) */ n2 = (float *) malloc (sizeof(float)); /* Reservamos espacio para n2 */ *n2 = 6.7; /* Valor prefijado para n2 (puntero a real) */ suma = (float *) malloc (sizeof(float)); /* Reservamos espacio para suma */ *suma = n1 + *n2; /* Calculamos la suma */ printf("El valor prefijado para la suma era %4.2f\n", *suma); printf("Ahora es tu turno: Introduce el primer nmero "); scanf("%f",&n1); /* Leemos valor para n1 (real) */ printf("Introduce el segundo nmero "); scanf("%f",n2); /* Valor para n2 (puntero a real) */ *suma = n1 + *n2; /* Calculamos nuevamente la suma */ printf("Ahora la suma es %4.2f\n", *suma); free(n2); /* Liberamos la memoria reservada */ free(suma); } Las diferencias son: n1 es un float, as que le damos valor normalmente: n1 = 0; Y pedimos su valor con scanf usando & para indicar en qu direccin de memoria se encuentra: scanf("%f", &n1).
n2 (y tambin suma) es un puntero a float, as que debemos reservarle espacio con malloc antes de empezar a usarlo, y liberar con free el epacio que ocupaba cuando terminemos de utilizarlo. Para guardar un valor en la direccin de memoria a la que apunta, usamos un asterisco: *n2 = 0; Y pedimos su valor con scanf, pero sin necesidad de usar &, porque el puntero ES una direccin de memoria: scanf("%f", n2). En este ejemplo, no hemos comprobado si el resultado de malloc era NULL, porque slo pedamos espacio para dos variables, y hemos dado por sentado que s habra memoria disponible suficiente para almacenarlas; en un caso general, deberemos asegurarnos siempre de que se nos ha concedido ese espacio que hemos pedido. 4.3.2. Tipos de Apuntadores Como se ha visto a lo largo de este manual todas las variables se enlazan a tipos especficos, con lo cual es de concluirse que una variable apuntador tambin; por lo cual se enlazan a tipos de datos especficos del lenguaje (apuntadores a variables de cierto tipo), de forma tal que a un apuntador slo se le pueden designar direcciones de variables del mismo tipo, que se especfico en la declaracin del apuntador. Este termino es algo complejo de entender por lo tanto se ver un ejemplo de su manejo: Algoritmo: entero *apun1 real *apun2 entero a apun1 &a apun2 &a Programa: int *apun1; float *apun2; int a; apun1 = &a; apun2 = &a;
// Esto es vlido // Esto no es vlido (ya que el puntero 2 es de tipo float, y por lo tanto debe apuntar hacia una variable del mismo tipo y en este caso no es as, con lo cual se genera un error)
Cotidianamente, un apuntador inicializado de una manera adecuada apunta a alguna posicin especfica de la memoria. Sin embargo, algunas veces es posible que un apuntador no contenga una direccin vlida, en cuyo caso es incorrecto desreferenciarlo (obtener el valor al que apunta) porque el programa tendr un comportamiento impredecible y probablemente errneo, aunque es posible que funcione bien. Un apuntador puede contener una direccin invlida debido a dos razones: 1. Cuando un apuntador se declara, al igual que cualquier otra variable, el mismo posee un valor cualquiera que no se puede conocer con anticipacin, hasta que se inicialice con algn valor (direccin), por ejemplo: Algoritmo: real *apun; escribir ( El valor apuntado por apun es: , *apun ) *apun 3.5 Programa: float *apun;
// Incorrecto // Incorrecto
printf ( " El valor apuntado por apun es: " , *apun );// Incorrecto *apun = 3.5; // Incorrecto 2. Despus de que un apuntador ha sido inicializado, la direccin que posee puede dejar de ser vlida si se libera la memoria reservada en esa direccin, ya sea porque la variable asociada termina su mbito o porque ese espacio de memoria fue reservado dinmicamente y luego se liber1, ejemplo de esto es el siguiente: Algoritmo: entero *apun entero b function func() entero a 40 apun &a b *apun; *apun 23; Fin_func inicio limpiar pantalla llamar a la funcin func() b *apun *apun 25 pausa fin Programa: int *apun, b; void func() { int a = 40; apun = &a; b = *apun; *apun = 23; } void main() { clrscr(); func(); b = *apun; *apun = 25; getch(); }
// Correcto // Correcto
// Correcto // Correcto
Si se intenta desreferenciar un apuntador que contiene una direccin invlida pueden ocurrir cosas como las siguientes: Se obtiene un valor incorrecto en una o ms variables debido a que no fue debidamente inicializada la zona de memoria que se accede a travs de la direccin en cuestin. Esto puede ocasionar que el programa genere resultados incorrectos. Si casualmente la direccin es la misma de otra variable utilizada en el programa, o est dentro del rango de direcciones de una zona de memoria utilizada, existe el riesgo de sobreescribir datos de otras variables. Existe la posibilidad de que la direccin est fuera de la zona de memoria utilizada para almacenar datos y ms bien est, por ejemplo, en la zona donde se almacenan las instrucciones del programa. Al intentar escribir en dicha zona, fcilmente puede
ocurrir que el programa genere un error de ejecucin y el sistema operativo lo detenga, o que el programa no responda y deje al sistema operativo inestable. En muchos casos el sistema operativo detecta el acceso inadecuado a una direccin de memoria, en cuyo caso detiene abruptamente el programa. 4.3.3. Operaciones con apuntadores Si declaramos una variable como int n=5 y posteriormente hacemos n++, debera resultar claro que lo que ocurre es que aumenta en una unidad el valor de la variable n, pasando a ser 6. Pero qu sucede si hacemos esa misma operacin sobre un puntero? Algoritmo: Declarer variables entero *n n (int *) malloc (sizeof(int)) *n 3 n n+1 Programa: int *n; n = (int *) malloc (sizeof(int)); *n = 3; n++; Despus de estas lneas de programa, lo que ha ocurrido no es que el contenido de la posicin n sea 4. Eso lo conseguiramos modificando *n, de la misma forma que le hemos dado su valor inicial. Es decir, deberamos usar (*n) ++. En cambio, nosotros hemos aumentado el valor de n. Como n es un puntero, estamos modificando una direccin de memoria. Por ejemplo, si n se refera a la posicin de memoria nmero 10.000 de nuestro ordenador, ahora ya no es as, ahora es otra posicin de memoria distinta, por ejemplo la 10.001. Porque, como ya sabemos, el espacio que ocupa una variable en C depende del sistema operativo. As, en un sistema operativo de 32 bits, un int ocupara 4 bytes, de modo que la operacin n++. Hara que pasramos de mirar la posicin 10.000 a la 10.004. Generalmente no es esto lo que se quiere, sino modificar el valor que haba almacenado en esa posicin de memoria. Olvidar ese * que indica que queremos cambiar el dato y no la posicin de memoria puede dar lugar a fallos muy difciles de descubrir (o incluso a que el programa se interrumpa con un aviso de Violacin de segmento porque estemos accediendo a zonas de memoria que no hemos reservado. 4.3.4. Relacin de apuntadores con arreglos En C hay muy poca diferencia interna entre un puntero y un array. En muchas ocasiones, podremos declarar un dato como array (una tabla con varios elementos iguales, de tamao predefinido) y recorrerlo usando punteros. Vamos a ver un ejemplo: Algoritmo: inicio declarar variables entero datos [ 10 ] entero i
limpiar pantalla para ( i = 1; i < 10; i++ ) hacer datos [ i ] i*2 fin_para para ( i = 1; i < 10; i++ ) hacer escribir ( datos + i ) fin_para pausa fin Programa: main() { int datos[10]; int i; /* Damos valores normalmente */ clrscr(); for (i=0; i<10; i++) datos[i] = i*2; /* Pero los recorremos usando punteros */ for (i=0; i<10; i++) printf ("%d ", *(datos+i)); getch(); } Pero tambin podremos hacer lo contrario, declarar de forma dinmica una variable usando malloc y recorrerla como si fuera un array: Algoritmo: inicio declarar variables entero *datos entero i limpiar pantalla datos ( entero * ) escribir ( Uso como puntero ) para ( i = 0; i < 20; i++ ) hacer *(datos + i ) i*2 fin_para para ( i = 0; i < 20; i++ ) hacer escribir ( *( datos + i ) ) fin_para escribir ( Uso como array ) para ( i = 0; i < 20; i++ ) hacer datos [ i ] i * 3 fin_para para ( i = 0; i < 20; i++ ) hacer escribir ( datos [ i ] ) fin_para liberar (datos) pausa fin Programa: #include <stdio.h> #include <stdlib.h>
main() { int *datos; int i; /* Reservamos espacio */ datos = (int *) malloc (20*sizeof(int)); /* Damos valores como puntero */ clrscr(); printf(" Uso como puntero... "); for (i=0; i<20; i++) *(datos+i) = i*2; /* Y los mostramos */ for (i=0; i<10; i++) printf ("%d ", *(datos+i)); /* Ahora damos valores como array */ printf("\n Uso como array... "); for (i=0; i<20; i++) datos[i] = i*3; /* Y los mostramos */ for (i=0; i<10; i++) printf ("%d ", datos[i]); /* Liberamos el espacio */ free(datos); getch(); } Existe otra posibilidad de usar punteros y arreglos, que son los arreglos de punteros, Igual que creamos arrays para guardar varios datos que sean nmeros enteros o reales, podemos hacerlo con punteros, esto es podemos reservar espacio para 20 punteros a enteros haciendo: int *datos[20]; Tampoco es algo especialmente frecuente en un caso general, porque si fijamos la cantidad de datos, estamos perdiendo parte de la versatilidad que podramos tener al usar memoria dinmica. Pero s es habitual cuando se declaran varias cadenas: char *mensajesError[3]={"Fichero no encontrado", "No se puede escribir", "Fichero sin datos"}; Un ejemplo de su uso sera este: Algoritmo: inicio declarar variables carcter *mensajesError[3]
{"Fichero no encontrado", "No se puede escribir", "Fichero sin datos"}
limpiar pantalla escribir ( El primer mensaje de error es: , mensajesError[0]) escribir ( El segundo mensaje de error es: , mensajesError[1]) escribir ( El tercer mensaje de error es: , mensajesError[2]) pausa fin
Programa: #include <stdio.h> main() { char *mensajesError[3]={"Fichero no encontrado","No se escribir","Fichero sin datos"}; clrscr(); printf("El primer mensaje de error es: %s\n",mensajesError[0]); printf("El segundo mensaje de error es: %s\n",mensajesError[1]); printf("El tercer mensaje de error es: %s\n",mensajesError[2]); getch(); }
puede

Fundamentos de Programacion

Caricato da

Informazioni sul documento

Descrizione originale:

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Fundamentos de Programacion

Caricato da

Copyright:

Formati disponibili

FUNDAMENTOSDE PROGRAMACIN

PrimerSemestre Profesores:AlejandraGutirrezReyes EnriqueMartnezRoldn

UNIDAD I INTRODUCCIN A LA PROGRAMACIN

Capitulo 2. 2.1. 2.2.

UNIDAD I INTRODUCCIN A LA PROGRAMACIN

UNIDAD I INTRODUCCIN A LA PROGRAMACIN

UNIDAD I INTRODUCCIN A LA PROGRAMACIN

Multitarea no preventivo cooperativo preventivo preventivo preventivo preventivo preventivo

Evolucin de los lenguajes de programacin

UNIDAD I INTRODUCCIN A LA PROGRAMACIN

UNIDAD I INTRODUCCIN A LA PROGRAMACIN

UNIDAD I INTRODUCCIN A LA PROGRAMACIN

UNIDAD II FUNDAMENTOS DE PROGRAMACIN ESTRUCTURADA

2.1. Estructura General de un Programa

UNIDAD II FUNDAMENTOS DE PROGRAMACIN ESTRUCTURADA

UNIDAD II FUNDAMENTOS DE PROGRAMACIN ESTRUCTURADA

UNIDAD II FUNDAMENTOS DE PROGRAMACIN ESTRUCTURADA

2.2. Tipos de Datos y Operadores

UNIDAD II FUNDAMENTOS DE PROGRAMACIN ESTRUCTURADA

El quinto operador es el que proporciona el resto de la divisin (residuo) Mdulo (%)

UNIDAD II FUNDAMENTOS DE PROGRAMACIN ESTRUCTURADA

UNIDAD II FUNDAMENTOS DE PROGRAMACIN ESTRUCTURADA

3.4E-38 a 3.4E+38 decimales(6) 4 1.7E-308 a 1.7E+308 decimales(10) 8 3.4E-4932 a 1.1E+4932 decimales(10) 10

UNIDAD II FUNDAMENTOS DE PROGRAMACIN ESTRUCTURADA

UNIDAD II FUNDAMENTOS DE PROGRAMACIN ESTRUCTURADA

UNIDAD II FUNDAMENTOS DE PROGRAMACIN ESTRUCTURADA

UNIDAD II FUNDAMENTOS DE PROGRAMACIN ESTRUCTURADA

UNIDAD II FUNDAMENTOS DE PROGRAMACIN ESTRUCTURADA

UNIDAD II FUNDAMENTOS DE PROGRAMACIN ESTRUCTURADA

letra = printf( letra = printf(

UNIDAD II FUNDAMENTOS DE PROGRAMACIN ESTRUCTURADA

Tabla 6. Tipos de datos

UNIDAD II FUNDAMENTOS DE PROGRAMACIN ESTRUCTURADA

UNIDAD II FUNDAMENTOS DE PROGRAMACIN ESTRUCTURADA

UNIDAD II FUNDAMENTOS DE PROGRAMACIN ESTRUCTURADA

Longitud 23484 45815 253u 253U 739l 739L 583ul 583UL

UNIDAD II FUNDAMENTOS DE PROGRAMACIN ESTRUCTURADA

Ejemplo 1.23 23.963f .00874 23e2 .874e-2 .874e-2f

Seguidos de otros que no son correctos: Ejemplos incorrectos de constantes

1,23 23963f .e4 -3.14

UNIDAD II FUNDAMENTOS DE PROGRAMACIN ESTRUCTURADA

UNIDAD II FUNDAMENTOS DE PROGRAMACIN ESTRUCTURADA

asocia un valor 1 a lunes, 2 a martes, 3 a mircoles, un 7 a jueves, un 8 a viernes, un 9 a sbado y un 10 a domingo.

2.3. Funciones de Biblioteca

UNIDAD II FUNDAMENTOS DE PROGRAMACIN ESTRUCTURADA

asin cos floor log sin tanh

atan cosh fmod log10 sinh

atan2 exp frexp modf sqrt

Tabla 12. Funcin math.h

memcmp strcat strcpy strncat strrchr strxfrm

memcpy strchr strcspn strncmp strspn

memmove strcmp strerror strncpy strstr

Tabla 13. Funcin string.h

UNIDAD II FUNDAMENTOS DE PROGRAMACIN ESTRUCTURADA

div labs mbstowcs realloc strtoul Biblioteca stdio.h

exit ldiv mbtowc srand system

free malloc qsort strtod wctomb

getenv mblen rand strtol

Tabla 14. Funcin stdlib.h

Tabla 15. Funcin stdio.h

Tabla 16. Funcin time.h

UNIDAD II FUNDAMENTOS DE PROGRAMACIN ESTRUCTURADA