Modulo C++

Área de programación - Grado 10 Lenguaje C++ ______________________________________________________________________________

Politécnico Colombiano Jaime Isaza Cadavid – Facultad de Ingenierías

1



2

PLAN DE TRABAJO

IIINNNTTTRRROOODDDUUUCCCCCCIIIÓÓÓNNN

Este texto fue elaborado tomando apartes de muchos de los manuales que existen en Internet los cuales se has revisado y adaptado con la intención que su nivel sea el razonable para una asignatura de “Programación en la media técnica” o similar, aunque quizá algunos centros (especialmente universitarios) exijan un nivel más alto que el que se cubre. Está organizado de una forma ligeramente distinta a los libros de texto “convencionales”, procurando incluir ejercicios prácticos lo antes posible, para evitar que un exceso de teoría en los primeros temas haga el texto pesado de seguir. Aun así, este texto no pretende “sustituir a un profesor”, sino servir de apoyo para que los alumnos puedan tener una guía para desarrollar sus prácticas. Pero es trabajo del profesor aclarar las dudas que surjan y proponer muchos más ejercicios que los que figuran aquí. Es necesario dejar claro, que el modulo no pretende ser un nuevo manual o texto guía, ya que de estos existen muchos en Internet, por ello tomamos apuntes de varios de estos buenos sitios (manuales) y lo único que se hizo fue darles un orden y adaptación a las necesidades del presente curso. Los sitios más utilizados para elaborar este modulo fueron: http://www.nachocabanes.com - www.monografias.com (Br. Manuel Antonio Ortez), www.monografias.com (Isabella Merici Miranda Vasquez), a quienes agradecemos por sus buenos trabajos.

OOOBBBJJJEEETTTIIIVVVOOO GGGEEENNNEEERRRAAALLL

Conocer la sintaxis básica del lenguaje C++,



3

OOOBBBJJJEEETTTIIIVVVOOOSSS EEESSSPPPEEECCCÍÍÍFFFIIICCCOOOSSS

1. Identificar las estructura básica de un programa en C++ 2. Conocer los diferentes tipos de datos y tipos de variables aceptadas por le

lenguaje C++ 3. Conocer las instrucciones necesarias para la entrada y salida de datos por medio

del lenguaje C++ 4. Conocer las diferentes expresiones y operadores utilizadas en el lenguaje C++ 5. Conocer las estructuras de selección 6. Conocer las estructuras cíclicas 7. Conocer la forma de implementar subprogramas o módulos 8. Conocer la forma de implementar arreglos 9. Conocer como es el manejo de archivos 10. Aprender a depurar un programa en C++

IIINNNTTTEEEGGGRRRAAACCCIIIÓÓÓNNN DDDEEELLL MMMÓÓÓDDDUUULLLOOO PPPOOORRR UUUNNNIIIDDDAAADDDEEESSS

• Unidad 1: Concepto Básicos

o Introducción o Estructura de Un programa en C o Lenguaje de Programación Estructurado C o Sintaxis de Algunos Elementos de Un Programa en C o Tipos de Datos en C o Tipos de Variables o Constantes o Entrada / Salida o Salida Hacia Pantalla [printf()] o Secuencias de Escapes o Entrada Desde Teclado o Operadores, Expresiones o Operadores o Expresiones

• Unidad 2: Estructuras (secuenciales, selectivas, múltiples) y Ciclos o Estructuras secuenciales o Estructura selectiva Simple o Estructura Selectiva doble o Estructura selectiva Múltiple o Funcionamiento de Un Ciclo o Ciclo de Entrada Asegurada (While) o Ciclo Controlado por contador (For).



4

o Ciclo Do... while

• Unidad 3: Subprogramas o Módulos, Estructuras de Datos (Arreglos) o Paso de Parámetros o Funciones Definidas Por El Usuario en C o Funciones que no devuelven ningún valor. o Funciones que devuelven un valor entero o Funciones que Devuelven un Valor Real o Funciones en las que usamos Menú o Vectores o Uso de Vectores dentro de las Funciones o Matrices

• Unidad 4: Manejo de archivos o Archivos de Texto o Archivos binarios o Archivos especiales 1: la impresora o Archivos especiales 2: salida de errores

• Unidad 5: Cómo depurar los programas o Conceptos básicos sobre depuración o Ejemplos de algunos entornos

• Unidad 6: Ejercicios de C++



5

LENGUAJE C++


Esta unidad busca que el estudiante distinga los conceptos básicos involucrados en el lenguaje de programación C++

JJJUUUSSSTTTIIIFFFIIICCCAAACCCIIIÓÓÓNNN

El lenguaje de programación C está caracterizado por ser de uso general, con una sintaxis sumamente compacta y de alta portabilidad.

Es común leer que se lo caracteriza como un lenguaje de "bajo nivel". No debe confundirse el término "bajo" con "poco", ya que el significado del mismo es en realidad "profundo", en el sentido que C maneja los elementos básicos presentes en todas las computadoras: caracteres, números y direcciones.

Esta particularidad, junto con el hecho de no poseer operaciones de entrada-salida, manejo de arreglo de caracteres, de asignación de memoria, etc, puede al principio parecer un grave defecto; sin embargo el hecho de que estas operaciones se realicen por medio de llamadas a Funciones contenidas en Librerías externas al lenguaje en sí, es el que confiere al mismo su alto grado de portabilidad, independizándolo del "Hardware" sobre el cual corren los programas, como se irá viendo a lo largo de las siguientes unidades.


Proporcionar los conocimientos que permitan al estudiante reconocer los conceptos básicos en el manejo del lenguaje C++.



6


• Identificar las estructura básica de un programa en C++ • Conocer los diferentes tipos de datos y tipos de variables aceptadas por le

lenguaje C++ • Conocer las instrucciones necesarias para la entrada y salida de datos por medio

del lenguaje C++ • Conocer las diferentes expresiones y operadores utilizadas en el lenguaje C++ • Conocer las estructuras de selección • Conocer las estructuras cíclicas

CCCOOONNNTTTEEENNNIIIDDDOOO

1. Introducción 2. Estructura de Un programa en C 3. Lenguaje de Programación Estructurado C 4. Sintaxis de Algunos Elementos de Un Programa en C 5. Tipos de Datos en C 6. Tipos de Variables 7. Constantes 8. Entrada / Salida 9. Salida Hacia Pantalla [printf()] 10. Secuencias de Escapes 11. Entrada Desde Teclado 12. Operadores, Expresiones 13. Operadores 14. Expresiones



7


El lenguaje de programación C está caracterizado por ser de uso general, con una sintaxis sumamente compacta y de alta portabilidad. Es común leer que se lo caracteriza como un lenguaje de "bajo nivel". No debe confundirse el término "bajo" con "poco", ya que el significado del mismo es en realidad "profundo", en el sentido que C maneja los elementos básicos presentes en todas las computadoras: caracteres, números y direcciones. Esta particularidad, junto con el hecho de no poseer operaciones de entrada-salida, manejo de arreglo de caracteres, de asignación de memoria, etc, puede al principio parecer un grave defecto; sin embargo el hecho de que estas operaciones se realicen por medio de llamadas a funciones contenidas en Librerías externas al lenguaje en sí, es el que confiere al mismo su alto grado de portabilidad, independizándolo del "Hardware" sobre el cual corren los programas, como se irá viendo a lo largo de los siguientes capítulos. La descripción del lenguaje se realiza siguiendo las normas del ANSI C, por lo tanto, todo lo expresado será utilizable con cualquier compilador que se adopte; sin embargo en algunos casos particulares se utilizaron funciones Compilador ó Sistema Operativo-dependientes, explicitándose en estos casos la singularidad de las mismas. Este lenguaje presenta varias características, entre las cuales están:

1. Lenguaje de programación de propósitos generales 2. Permite la Programación Estructurada 3. Abundancia de Operadores y Tipos de Datos 4. No está asociado a ningún sistema operativo ni a ninguna máquina 5. Popular y Eficaz 6. Permite el desarrollo de Sistemas Operativos y programas de aplicación 7. Portabilidad 8. Existen las librerías en las bibliotecas 9. Tiene sólo 32 palabras reservadas

EEESSSTTTRRRUUUCCCTTTUUURRRAAA DDDEEE UUUNNN PPPRRROOOGGGRRRAAAMMMAAA EEENNN CCC++++++

Antes de iniciar los conceptos propios del lenguaje C es necesario, primero; mencionar algunos de los errores típicos al programar, para que el lector sepa como identificarlos y así los pueda corregir. ERROR DE SINTAXIS: Estos errores son producidos, cuando se hace mal uso de las reglas del lenguaje de programación, y se violan las normas de sintaxis, de ese lenguaje



8

(en nuestro caso C); estos errores son fáciles de detectar por que generalmente es el compilador, que los identifica (Y hasta muestra la línea donde se encuentra dicho error, pero eso depende de la versión del compilador que estemos usando). ERRORES DE EJECUCIÓN: Estos errores se producen, cuando le indicamos a la computadora, realizar una determinada acción, y esta la comprende, pero no puede ejecutarla. Por ejemplo, indicarle a la computadora una división entre cero, sumar dos variables a las cuales no se les ha signado valor alguno, etc. ERRORES DE LÓGICA: Muchas veces, cuando estamos programando, el compilador no nos indica errores de sintaxis, ni de lógica; pero el resultado de nuestro programa, esta fuera del rango esperado, esto es producto de un error de lógica en el código de nuestro programa. Este tipo de errores son muy difíciles de identificar y por supuesto de corregir, ya que generalmente hay que revisar línea por línea de nuestro programa. Ejemplo: El sueldo negativo de un empleado, etc. La estructura de un programa en C, consta de algunas partes esenciales: las cuales son uno o más módulos llamadas funciones, siendo main() la primera función que es llamada cuando empieza la ejecución del programa . Cada función debe contener: • Directivas de pre-procesador (instrucciones que se le dan al compilador antes de

compilar)

#include #define ejemplo: #include <stdio.h>

Lo que se le esta indicando, es que de las librerías, “Incluya” en nuestro programa la directiva stdio.h, la cual contiene las funciones de entrada y salida de datos (standar input output, en inglés). Si necesitamos las funciones matemáticas, debemos especificarlo con la declaratoria: #include <math.h> Si necesitamos las funciones de cadenas: #inlcude <stlib.h> Es necesario aclarar que esto se hace al inicio del programa, y las declaratorias deben llevar el símbolo de numeral (#) seguido de la sentencia “include”, y entre signos de mayor y menor que (<>) el nombre de la directiva.

• Declaraciones Globales



9

Pueden ser: • Prototipos de Funciones: También llamadas declaraciones de funciones, lo cual

se tratará más adelante • Declaraciones de Variables

Cabe destacar, que esto se hace seguido de los #include y los #define.

Función Principal main() Esta es la función principal de nuestro programa, su cuerpo, por ello NUNCA debe faltar, ya que en ella van contenidas todas las instrucciones de nuestro programa.

main() { declaraciones locales /*Comentarios */ sentencias }

La función main() va al inicio, luego abrimos llaves y dentro de ellas van las declaraciones de variables, las sentencias de lectura, cálculos, asignaciones e impresiones, y con la última llave ( } ), le indicamos el final del programa. Ejemplo:

Programa que a partir del radio, calcula el área de un círculo #include <stdio.h> #include <conio.h> main() { float radio, area; printf("Radio=\n"); scanf("%f", &radio); area=3.14159*radio*radio; printf("El Area es %f\n\n", area); getch(); return 0; }

Explicación: Le indicamos al compilador, que usaremos las bibliotecas <stdio.h> y <conio.h>, ¿por qué <conio.h>?, por que esta biblioteca, contiene las funciones getche(), getch(), etc., y de una de ellas hacemos uso en este pequeño ejemplo. Luego, le indicamos a nuestro programa el inicio de nuestro programa (función main()). Declaramos, como valores reales, las variables radio y área (de esto se hablará más adelante). Luego, con la instrucción printf(), mostramos en pantalla el mensaje (Radio=) y



10

scanf se encarga de leer el valor digitado por el usuario. Posteriormente area, es igual al la multiplicación de pi (3.14159), el radio al cuadrado. Se muestra en pantalla ese resultado, luego el programa espera que se presiones cualquier tecla (getch() ) y no retorna ningún valor (return 0).

AAACCCTTTIIIVVVIIIDDDAAADDD………

1. Indique que tipo de error (Error de sintaxis, error de ejecución o error lógico), en cada

uno de los siguientes enunciados

• Utilizar una variable antes de asignarle un valor: _______________________ • Asignarle un valor real a una variable declarada como entero: ____________ • Al cometer este error, los resultados arrojados por el programa no son los que se

esperaban: ______________________________________________ • Un programa no puede ser ejecutado por el computador, mientras tenga este

tipo de errores: __________________________________________ • Estos errores no son detectados por el compilador, ni tampoco son errores de

ejecución: ______________________________________________

2. Mencione y Explique, la estructura general de un programa en C:

LLLEEENNNGGGUUUAAAJJJEEE DDDEEE PPPRRROOOGGGRRRAAAMMMAAACCCIIIÓÓÓNNN EEESSSTTTRRRUUUCCCTTTUUURRRAAADDDOOO CCC

Si el lector recuerda, en el apartado anterior, se hablaba de las características del lenguaje C, y en una de ellas se decía que, el Lenguaje de Programación C, permite la programación estructurada. Esto implica que, haremos uso de una técnica llamada Lógica Estructurada, y esto no es más ni menos que una de las técnicas básicas y fundamentales de la programación estructurada, su objetivo es diseñar soluciones “correctas” y confiables a los problemas, ignorando al principio consideraciones de eficiencia como la minimización del uso de memoria y el tiempo de su respuesta. Lo que significa que, haremos uso de esa técnica para crear programas correctos; esta es una técnica que ayuda al programador (un tanto a la fuerza), a ser ordenado, al momento de programar. Los frutos de ésta técnica se reflejan cuando, queremos darle mantenimiento al programa, es más fácil hacerlo ya que hemos programado de una manera lógica y ordenada. Al igual que al momento de corregir errores de sintaxis y lógica, esta técnica nos facilita el trabajo. Ahora iniciemos, de una vez por todas, lo que el lector está esperando:



11

SSS IIINNNTTTAAAXXXIIISSS DDDEEE AAALLLGGGUUUNNNOOOSSS EEELLLEEEMMMEEENNNTTTOOOSSS DDDEEE UUUNNN PPPRRROOOGGGRRRAAAMMMAAA EEENNN CCC

Identificadores: Como su nombre lo indica, estos son los nombres, con los que identificamos las variables, constantes, funciones, vectores, etc., de nuestro programa. Para ello debemos tener presente algunas reglas: • Pueden tener de 1 hasta un máximo de 31 caracteres • Debe de iniciar con una letra o subrayado

Ejemplo:

Correctos c2 _c2 Incorrectos 2c 2 c

• No es lo mismo una minúscula que una mayúscula, ya que c distingue de entre ellas.

Ejemplo: BETA ≠ Beta ≠ beta ≠ BeTa • No son válidos los identificadores de palabras reservadas. En un inicio hablamos que c

posee 32 palabras reservadas, entre ellas están:

float char while int else return Estas palabras no pueden ser utilizadas para identificar variables, constantes, funciones etc

Comentarios En todo programa que estemos diseñando en C (o en cualquier otro lenguaje de programación); es necesario insertar ciertos comentarios en el código, para que en posteriores modificaciones y cuando se realice el mantenimiento, se puedan recordar cosas importantes ya que, en los comentarios, se pueden incluir aspectos importantes del programas, explicaciones del funcionamiento de las sentencias, etc. El formato de los comentarios en C, es el siguiente: /*este es un comentario en C */ /*Podemos colocar mucha información importante de nuestro Programa */



12

La Directiva #include Permite que, el preprocesador, incluya funciones proporcionadas por el fabricante, a nuestro programa. Ejemplo:

#include <stdio.h> /* le decimos al compilador que incluya la librería stdio.h */

La directiva #define Permite definir constantes simbólicas. Pero hasta ahora ha sido poco lo que se ha hablado acerca de las constantes, es por ello que aprovechando este especio; se dedicarán unas cuantas líneas para aclarar ello. Las variables pueden cambiar de valor, durante la ejecución del programa, por eso es que se llaman variables. Y las constantes como su nombre lo indica, son valores que permanecen constantes durante toda la ejecución del programa, un ejemplo de ello, es el valor de π (pi) que equivale a 3.14159.... En C existen diferentes tipos de variables, entre ellas tenemos:

• Constates Numéricas: Son valores numéricos, enteros o de reales (de punto flotante). Se permiten también constantes octales y hexadecimales.

• Constantes Simbólicas: las constantes simbólicas tiene un nombre (identificador), y en esto se parecen las variables. Sin embargo, no pueden cambiar de valor a lo largo de la ejecución del programa. En C, se pueden definir mediante el preprocesador.

• (Tomado del Manual “Aprenda Lenguaje ANSI C como si estuviera en Primero” Escuela superior de Ingenieros Industriales. Universidad de Navarra. Febrero de 1998).

Ejemplo:

#define N 100 #define PI 3.1416 #define B 45

Esta directiva (#define) va, inmediatamente después de los #include. Se escribe la directiva, se deja un espacio y se escribe el identificador de la constante, otro espacio y su valor.

Signos de Puntuación y de Separación / % ^ & * () - + {} [] \ ; : <> ¿ .



13

Todas las Instrucciones o sentencias del programa terminan con un punto y coma (;) Al momento de programar en C, esta es una regla de oro, y la causa por la cual nuestro programa puede darnos muchos errores de sintaxis, cuando se omite, al final de cada sentencia un punto y coma (;). Ya que con ello le indicamos al compilador que ha finalizado una sentencia. NOTA: el lector no debe confundirse, las directivas: #include, #define. Main(), no llevan punto y coma, por que no son sentencias. Recordemos el ejemplo anterior, y veamos que al final de cada sentencia lleva su correspondiente punto y coma:

#include <stdio.h> #include <conio.h> main() { float radio, area; printf("Radio=\n"); scanf("%f", &radio); area=3.14159*radio*radio; printf("El Area es %f\n\n", area); getch(); return 0; }

Todo Bloque de Instrucciones debe ir entre llaves Esta consideración toma mayor auge, cuando veamos las instrucciones anidadas en condiciones, ciclos, etc. Ejemplo:

{ ... printf(“Hola\n\b”); ... }

En una línea se pueden escribir más de una instrucción separada por un punto y coma Esto es posible, por que con el punto y coma, le estamos indicando al compilador el fin de una sentencia o instrucción.



14

Ejemplo:

b = c + d; d = 2*k;

TTTIIIPPPOOOSSS DDDEEE DDDAAATTTOOOSSS EEENNN CCC

Un tipo de dato, se define como un conjunto de valores que puede tener una variable, junto con ciertas operaciones que se pueden realizar con ellas.

Definición de Variables Si se desea imprimir los resultados de multiplicar un número fijo por otro que adopta valores entre 0 y 9, la forma normal de programar esto sería crear una CONSTANTE para el primer número y un par de VARIABLES para el segundo y para el resultado del producto. Una variable, en realidad, no es más que un nombre para identificar una (o varias) posiciones de memoria donde el programa guarda los distintos valores de una misma entidad. Un programa debe DEFINIR a todas las variables que utilizará, antes de comenzar a usarlas, a fin de indicarle al compilador de que tipo serán, y por lo tanto cuanta memoria debe destinar para albergar a cada una de ellas. Veamos el EJEMPLO:

Ejemplo: #include <stdio.h> main() { int multiplicador; /* defino multiplicador como un entero */ int multiplicando; /* defino multiplicando como un entero */ int resultado; /* defino resultado como un entero */ multiplicador = 1000 ; /* les asigno valores */ multiplicando = 2 ; resultado = multiplicando * multiplicador ; printf("Resultado = %d\n", resultado); /* muestro el resultado */ return 0; }

En las primeras líneas de texto dentro de main() defino mis variables como números enteros , es decir del tipo "int" seguido de un identificador (nombre) de la misma. Este identificador puede tener la cantidad de caracteres que se desee, sin embargo de acuerdo al Compilador que se use, este tomará como significantes sólo los primeros n de ellos; siendo por lo general n igual a 32. Es conveniente darle a los identificadores de las variables, nombres que tengan un significado que luego permita una fácil lectura del programa. Los identificadores deben comenzar con una letra ó con el símbolo de subrayado "_”, pudiendo continuar con cualquier otro carácter alfanumérico ó el símbolo "_”. El único símbolo no alfanumérico aceptado en un nombre es el "_”. El lenguaje C es sensible al tipo de letra usado; así tomará como variables distintas a una llamada "variable”, de otra escrita como "VARIABLE". Es una convención entre los programadores



15

de C escribir los nombres de las variables y las funciones con minúsculas, reservando las mayúsculas para las constantes. El compilador dará como error de "Definición incorrecta" a la definición de variables con nombres del tipo de:

4pesos $variable primer-variable !variable etc.

NOTA: Los compiladores reservan determinados términos ó palabras claves (Keywords) para el uso sintáctico del lenguaje, tales como: asm, auto, break, case, char, do, for, etc. Si bien estas palabras están definidas para el ANSI C, los distintos compiladores extienden esta definición a OTROS términos, por lo que es aconsejable leer la tabla completa de palabras reservadas del compilador que se vaya a usar, para no utilizarlas en nombres de variables. Vemos en las dos líneas subsiguientes a la definición de las variables, que puedo ya asignarles valores (1000 y 2) y luego efectuar el cálculo de la variable "resultado". Si prestamos ahora atención a la función printf(), ésta nos mostrará la forma de visualizar el valor de una variable. Insertada en el texto a mostrar, aparece una secuencia de control de impresión "%d" que indica, que en el lugar que ella ocupa, deberá ponerse el contenido de la variable (que aparece luego de cerradas las comillas que marcan la finalización del texto, y separada del mismo por una coma) expresado como un número entero decimal. Así, si compilamos y corremos el programa, obtendremos una salida :

Inicialización de variables Las variables del mismo tipo pueden definirse mediante una definición múltiple separándolas mediante “, " a saber:

int multiplicador, multiplicando, resultado; Esta sentencia es equivalente a las tres definiciones separadas en el ejemplo anterior. Las variables pueden también ser inicializadas en el momento de definirse.

int multiplicador = 1000, multiplicando = 2, resultado; De esta manera el ejemplo anterior podría escribirse:

#include <stdio.h> main() { int multiplicador=1000, multiplicando=2 ; printf("Resultado = %d\n", multiplicando * multiplicador); return 0; }



16

Obsérvese que en la primera sentencia se definen e inicializan simultáneamente ambas variables. La variable "resultado" la hemos hecho desaparecer ya que es innecesaria. Si analizamos la función printf() vemos que se ha reemplazado "resultado" por la operación entre las otras dos variables. Esta es una de las particularidades del lenguaje C: en los parámetros pasados a las funciones pueden ponerse operaciones (incluso llamadas a otras funciones), las que se realizan ANTES de ejecutarse la función, pasando finalmente a esta el valor resultante de las mismas. El EJEMPLO funciona exactamente igual que antes pero su código ahora es mucho más compacto y claro.

TTTIIIPPPOOOSSS DDDEEE VVVAAARRRIIIAAABBBLLLEEESSS

Variables del tipo entero En el ejemplo anterior definimos a las variables como enteros (int). De acuerdo a la cantidad de bytes que reserve el compilador para este tipo de variable, queda determinado el "alcance" ó máximo valor que puede adoptar la misma. Debido a que el tipo int ocupa dos bytes su alcance queda restringido al rango entre -32.768 y +32.767 (incluyendo 0 ). En caso de necesitar un rango más amplio, puede definirse la variable como "long int nombre_de_variable" ó en forma más abreviada "long nombre_de_variable" Declarada de esta manera, nombre_de_variable puede alcanzar valores entre - 2.347.483.648 y +2.347.483.647. A la inversa, si se quisiera un alcance menor al de int, podría definirse "short int " ó simplemente "short", aunque por lo general, los compiladores modernos asignan a este tipo el mismo alcance que "int". Debido a que la norma ANSI C no establece taxativamente la cantidad de bytes que ocupa cada tipo de variable, sino tan sólo que un "long" no ocupe menos memoria que un "int" y este no ocupe menos que un "short", los alcances de los mismos pueden variar de compilador en compilador, por lo que sugerimos que confirme los valores dados en este parágrafo (correspondientes al compilador de Borland C++) con los otorgados por el compilador que esté trabajando. Para variables de muy pequeño valor puede usarse el tipo "char" cuyo alcance está restringido a -128, +127 y por lo general ocupa un único byte. Todos los tipos citados hasta ahora pueden alojar valores positivos ó negativos y, aunque es redundante, esto puede explicitarse agregando el calificador "signed" delante; por ejemplo:



17

signed int signed long signed long int signed short signed short int signed char

Si en cambio, tenemos una variable que sólo puede adoptar valores positivos (como por ejemplo la edad de una persona) podemos aumentar el alcance de cualquiera de los tipos, restringiéndolos a que sólo representen valores sin signo por medio del calificador "unsigned". En la TABLA 1 se resume los alcances de distintos tipos de variables enteras

TABLA 1 VARIABLES DEL TIPO NUMERO ENTERO

TIPO BYTES VALOR MÍNIMO VALOR MÁXIMO signed char 1 -128 127 unsigned char 1 0 255 unsigned short 2 -32.768 +32.767 unsigned short 2 0 +65.535 signed int 2 -32.768 +32.767 unsigned int 2 0 +65.535 signed long 4 -2.147.483.648 +2.147.483.647 unsigned long 4 0 +4.294.967.295

NOTA: Si se omite el calificador delante del tipo de la variable entera, éste se adopta por omisión (default) como "signed".

Variables de número real o punto flotante Un número real ó de punto flotante es aquel que además de una parte entera, posee fracciones de la unidad. En nuestra convención numérica solemos escribirlos de la siguiente manera: 2,3456, lamentablemente los compiladores usan la convención del PUNTO decimal (en vez de la coma). Así el numero Pi se escribirá: 3.14159 Otro formato de escritura, normalmente aceptado, es la notación científica. Por ejemplo podrá escribirse 2.345E+02, equivalente a 2.345 * 100 ó 234.5 De acuerdo a su alcance hay tres tipos de variables de punto flotante, las mismas están descriptas en la TABLA 2

TABLA 2 TIPOS DE VARIABLES DE PUNTO FLOTANTE

TIPO BYTES VALOR MÍNIMO VALOR MÁXIMO float 4 3.4E-38 3.4E+38 double 8 1.7E-308 1.7E+308 long double 10 3.4E-4932 3.4E+4932



18

Las variables de punto flotante son SIEMPRE con signo, y en el caso que el exponente sea positivo puede obviarse el signo del mismo.

Conversión automática de tipos Cuando dos ó mas tipos de variables distintas se encuentran DENTRO de una misma operación ó expresión matemática, ocurre una conversión automática del tipo de las variables. En todo momento de realizarse una operación se aplica la siguiente secuencia de reglas de conversión (previamente a la realización de dicha operación):

1. Las variables del tipo char ó short se convierten en int 2. Las variables del tipo float se convierten en double 3. Si alguno de los operandos es de mayor precisión que los demás , estos se

convierten al tipo de aquel y el resultado es del mismo tipo. 4. Si no se aplica la regla anterior y un operando es del tipo unsigned el otro se

convierte en unsigned y el resultado es de este tipo. Las reglas 1 a 3 no presentan problemas, sólo nos dicen que previamente a realizar alguna operación las variables son promovidas a su instancia superior. Esto no implica que se haya cambiado la cantidad de memoria que las aloja en forma permanente Otro tipo de regla se aplica para la conversión en las asignaciones. Si definimos los términos de una asignación como,"lvalue" a la variable a la izquierda del signo igual y "rvalue" a la expresión a la derecha del mismo, es decir:

"lvalue" = "rvalue" ; Posteriormente al cálculo del resultado de "rvalue" (de acuerdo con las reglas antes descriptas), el tipo de este se iguala al del "lvalue". El resultado no se verá afectado si el tipo de "lvalue" es igual ó superior al del "rvalue", en caso contrario se efectuará un truncamiento ó redondeo, según sea el caso. Por ejemplo, el pasaje de float a int provoca el truncamiento de la parte fraccionaria, en cambio de double a float se hace por redondeo.

Enclavamiento de conversiones (casting) Las conversiones automáticas pueden ser controladas a gusto por el programador, imponiendo el tipo de variable al resultado de una operación. Supongamos por ejemplo tener:

double d, e, f = 2.33; int i = 6; e = f * i; d = (int) ( f * i ) ;

En la primer sentencia calculamos el valor del producto (f * i), que según lo visto anteriormente nos dará un double de valor 13.98, el que se ha asignado a e. Si en la variable d quisiéramos reservar sólo el valor entero de dicha operación bastará con



19

anteponer, encerrado entre paréntesis, el tipo deseado. Así en d se almacenará el número 13.00. También es factible aplicar la fijación de tipo a una variable, por ejemplo obtendremos el mismo resultado, si hacemos:

d = (int) f * i;

En este caso hemos convertido a f en un entero (truncando sus decimales)

Variables de tipo carácter El lenguaje C guarda los caracteres como números de 8 bits de acuerdo a la norma ASCII extendida, que asigna a cada carácter un número comprendido entre 0 y 255 (un byte de 8 bits) Es común entonces que las variables que vayan a alojar caracteres sean definidas como:

char c; Sin embargo, también funciona de manera correcta definirla como:

int c; Esta última opción desperdicia un poco más de memoria que la anterior, pero en algunos casos particulares presenta ciertas ventajas. Pongamos por caso una función que lee un archivo de texto ubicado en un disco. Dicho archivo puede tener cualquier carácter ASCII de valor comprendido entre 0 y 255. Para que la función pueda avisarme que el archivo ha finalizado deberá enviar un número NO comprendido entre 0 y 255 (por lo general se usa el -1, denominado EOF, fin de archivo ó End Of File), en este caso dicho número no puede ser mantenido en una variable del tipo char, ya que esta sólo puede guardar entre 0 y 255 si se la define unsigned ó no podría mantener los caracteres comprendidos entre 128 y 255 si se la define signed (ver TABLA 1). El problema se obvia fácilmente definiéndola como int. Las variables del tipo carácter también pueden ser inicializadas en su definición, por ejemplo es válido escribir:

char c = 97; Para que c contenga el valor ASCII de la letra "a", sin embargo esto resulta algo engorroso, ya que obliga a recordar dichos códigos. Existe una manera más directa de asignar un caracter a una variable; la siguiente inicialización es idéntica a la anterior:

char c = 'a'; Es decir que si delimitamos un carácter con comilla simple, el compilador entenderá que debe suplantarlo por su correspondiente código numérico. Lamentablemente existen una serie de caracteres que no son imprimibles, en otras palabras que cuando editemos nuestro programa fuente (archivo de texto) nos resultará



20

difícil de asignarlas a una variable ya que el editor las toma como un COMANDO y no como un carácter. Un caso típico sería el de "nueva línea" ó ENTER. Con el fin de tener acceso a los mismos es que aparecen ciertas secuencias de escape convencionales. Las mismas están listadas en la TABLA 3 y su uso es idéntico al de los caracteres normales, así para resolver el caso de una asignación de "nueva línea" se escribirá:

char c = '\n' ; /* secuencia de escape */

TABLA 3 SECUENCIAS DE ESCAPE

CÓDIGO SIGNIFICADO VALOR ASCII

(DECIMAL) VALOR ASCII

(HEXADECIMAL) '\n' nueva línea 10 0x0A '\r' retorno de carro 13 0x0D '\f' nueva página 2 x0C '\t' tabulador horizontal 9 0x09 '\b' retroceso (backspace) 8 0x08 '\'' comilla simple 39 0x27 '\"' Comillas 4 0x22 '\\ ' Barra 92 0x5C '\? ' Interrogación 63 0x3F '\nnn' cualquier caracter (donde nnn es el código ASCII expresado en

octal) '\xnn' cualquier caracter (donde nn es el código ASCII expresado en

hexadecimal)

Tamaño de las variables (sizeof) En muchos programas es necesario conocer el tamaño (cantidad de bytes) que ocupa una variable, por ejemplo en el caso de querer reservar memoria para un conjunto de ellas. Lamentablemente, como vimos anteriormente este tamaño es dependiente del compilador que se use, lo que producirá, si definimos rígidamente (con un número dado de bytes) el espacio requerido para almacenarlas, un problema serio si luego se quiere compilar el programa con un compilador distinto del original Para salvar este problema y mantener la portabilidad, es conveniente que cada vez que haya que referirse al TAMAÑO en bytes de las variables, se lo haga mediante un operador llamado "sizeof" que calcula sus requerimientos de almacenaje Está también permitido el uso de sizeof con un tipo de variable, es decir:

sizeof(int) sizeof(char) sizeof(long double), etc.



21

Definición de nuevos tipos (typedef) A veces resulta conveniente crear otros tipos de variables, ó redefinir con otro nombre las existentes, esto se puede realizar mediante la palabra clave "typedef", por ejemplo:

typedef unsigned long double enorme; A partir de este momento, las definiciones siguientes tienen idéntico significado:

unsigned long double nombre_de_variable; enorme nombre_de_variable;

CCCOOONNNSSSTTTAAANNNTTTEEESSS

Aquellos valores que, una vez compilado el programa no pueden ser cambiados, como por ejemplo los valores literales que hemos usado hasta ahora en las inicializaciones de las variables (1000, 2, 'a', '\n', etc), suelen denominarse CONSTANTES. Como dichas constantes son guardadas en memoria de la manera que al compilador le resulta más eficiente suelen aparecer ciertos efectos secundarios, a veces desconcertantes, ya que las mismas son afectadas por las reglas de RECONVERSION AUTOMATICA DE TIPO vista previamente. A fin de tener control sobre el tipo de las constantes, se aplican las siguientes reglas: Una variable expresada como entera (sin parte decimal) es tomada como tal salvo que se la siga de las letras F ó L (mayúsculas ó minúsculas) ejemplos:

1: tomada como ENTERA 1F: tomada como FLOAT 1L: tomada como LONG DOUBLE

Una variable con parte decimal es tomada siempre como DOUBLE, salvo que se la siga de la letra F ó L

1.0 : tomada como DOUBLE 1.0F : tomada como FLOAT 1.0L : tomada como LONG FLOAT

Si en cualquiera de los casos anteriores agregamos la letra U ó u la constante queda calificada como UNSIGNED (consiguiendo mayor alcance):

1u: tomada como UNSIGNED INT 1.0UL: tomada como UNSIGNED LONG DOUBLE

Una variable numérica que comienza con "0" es tomado como OCTAL así: 012 equivale a 10 unidades decimales



22

Una variable numérica que comienza con "0x" ó "0X" es tomada como hexadecimal: 0x16 equivale a 22 unidades decimales y 0x1A a 26 unidades decimales.

Constantes simbólicas Por lo general es una mala práctica de programación colocar en un programa constantes en forma literal (sobre todo si se usan varias veces en el mismo) ya que el texto se hace difícil de comprender y aún más de corregir, si se debe cambiar el valor de dichas constantes. Se puede en cambio asignar un símbolo a cada constante, y reemplazarla a lo largo del programa por el mismo, de forma que este sea más legible y además, en caso de querer modificar el valor, bastará con cambiarlo en la asignación. El compilador, en el momento de crear el ejecutable, reemplazará el símbolo por el valor asignado. Para dar un símbolo a una constante bastará, en cualquier lugar del programa (previo a su uso) poner la directiva:

#define, por ejemplo: #define VALOR_CONSTANTE 342 #define PI 3.1416

EEENNNTTTRRRAAADDDAAA /// SSSAAALLLIIIDDDAAA

Las funciones gets, puts, getch, etc; son utilizadas, en una forma un poco rudimentaria, sin embargo; C posee otra serie de funciones, que son más completas, las cuales nos permiten leer e imprimir (en pantalla), datos con un formato determinado, el cual ha sido definido por el programador.

SSSAAALLLIIIDDDAAA HHHAAACCCIIIAAA PPPAAANNNTTTAAALLLLLLAAA [[[PPPRRRIIINNNTTTFFF((()))]]]

Se utiliza para imprimir en pantalla cadenas de texto solas, o mandar a pantalla el valor de alguna variable, o constante, o una combinación de las anteriores. Su formato es el siguiente:

Printf(“cadena de control”, nombre_de_variables); En donde: Cadena de control: contiene códigos de formato que se asocian con los tipos de datos contenidos en las variables.



23

CÓDIGO FORMATO %d Un entero %i Un entero %c Una caracter %s Una cadena %f Un real %ld Entero largo %u Decimal sin signo %lf Doble posición %h Entero corto %o Octal %x Hexadecimal %e Notación Científica %p Puntero %% Imprime Porcentaje

Ejemplo:

Int suma=10; Printf(“La suma es %d”, suma);

Explicación: Declaramos primero la variable como entero, con un valor de 10, luego la función printf, el mensaje va entre comillas dobles, luego en el lugar que queremos que aparezca el valor, colocamos el formato de la variable, cerramos comillas, luego una coma y el nombre de la variable. Es importante recalcar, que en la posición que coloquemos el formato es donde aparecerá el valor de la variable en este caso, 10. Ejemplo:

Char nombre[7]=”Manuel”; printf(“%s es en creador de este manual”, nombre);

NOTA: el número de argumentos que tendrá la función printf() es indefinido, por lo que se puede transmitir cuantos datos sean necesarios. Ejemplo:

Int x=12, y=15; char z=’D’; float v=10.2563; printf(“Estos son números %d %d %f; y esta es una letra %c”, x,y,v,z);



24

También podemos hacer algunos arreglos, al formato de salida, por ejemplo, si deseamos imprimir un número real justificado a la izquierda podemos colocar:

printf(“%-f”, z); Para justificar colocarle signo: %+f

%20f >> Longitud numérica del campo %.2f >>Imprime el valor con sólo dos decimales

SSSEEECCCUUUEEENNNCCCIIIAAASSS DDDEEE EEESSSCCCAAAPPPEEESSS

Indica que debe ejecutar algo extraordinario.

CARÁCTER DE

ESCAPE

EXPLICACIÓN

\n Simula un Enter. Se utiliza para dejar una línea de por medio \t Tabulador horizontal. Mueve el cursor al próximo tabulador \v Tabulador vertical. \a Hace sonar la alarma del sistema \\ Imprime un carácter de diagonal invertida \? Imprime el carácter del signo de interrogación \” Imprime una doble comilla

Ejemplos:

printf(“Manuel \n Antonio \n Ortez\n\n); int x=15; printf(“El Valor de la variable es %d\n\n”, x); float x=8.5689, pi=3.1416; printf(“El valor de x es %.2f\t\n”,x); printf(“\t Y el valor de pi es %.2f\n\n”, pi);

EEENNNTTTRRRAAADDDAAA DDDEEESSSDDDEEE TTTEEECCCLLLAAADDDOOO

Se realiza mediante la función scanf(), su formato es:

scanf(“Cadena de control”, Dirección y nombre de la variable);



25

Ejemplo

Diseñe un programa que guarde y muestre la nota del examen final de 3 alumnos #include <stdio.h> #include <conio.h> main() { float n1, n2, n3; char nom1[10], nom2[10], nom3[10]; printf("Introduzca el Nombre del Primer alumno:\n"); scanf("%s", nom1); printf("Introduzca la nota de este alumno:\n"); scanf("%f", &n1); printf("Digite el nombre del segundo alumno:\n"); scanf("%s", nom2); printf("Su nota es:\n"); scanf("%f", &n2); printf("Finalmente el ultimo alumno es:\n"); scanf("%s", nom3); printf("Y su nota es:\n"); scanf("%f", &n3); getch(); return 0; }

Explicación: Primero, iniciamos con las directivas del preprocesador:

#include <stdio.h> #include <conio.h>

Con la cual le indicamos al compilador, que de su librería añada a nuestro programa las funciones estándar de entrada y salida; así como las entradas y salidas por consola (stadio.h y conio.h, respectivamente). Luego declaramos la variables, que contendrán las notas como reales (o de punto flotante:

float n1, n2, n3; Ya que, las notas pueden ser deciamales, por ejemplo 9.6, 8.5; etc. Luego declaramos las variables, que contendrán las notas, cabe aclarar que al momento de las declaraciones las podemos hacer en el orden que deseemos, pueden ser primeros los tipo char y luego los float, o viceversa, pero teniendo el cuidado que las variables que contendrán las nombres lleven la longitud máxima entre corchetes, para nuestro caso, 10. ([10]).



26

Posteriormente, mostramos en pantalla, un mensaje con el cual le indicamos al usuario que introduzca los datos respectivos:

printf("Introduzca el Nombre del Primer alumno:\n"); A continuación, va la función scanf, primero y entre comillas el tipo de dato que va a leer:

scanf("%s", nom1); Como puede notarse, va a leer la cadena de texto que contendrá la variable nom1. cabe aclarar, que cuando se van a leer cadenas de texto, no es necesario colocar la dirección (&), lo cual no sucede con los otros tipos de datos:

scanf("%f", &n1); Después de haber leído los datos, espera a que se presiones cualquier tecla para finalizar la ejecución del programa. Ejemplo Programa que imprime dos veces, la cadena de texto que se ha introducido:

#include <stdio.h> #include <conio.h> main() { char cadena[15]; printf("Digite la cadena:\n\n"); scanf("%s", cadena); printf("\n\t LA CADENA ES LA SIGUIENTE:\n\n"); printf("***********************************************\n"); printf("%s\n", cadena); printf("%s\n", cadena); printf("***********************************************\n"); getch(); return 0; }

Es importante, que el lector, intente correr, en su máquina estos ejemplos, para que comprenda con mayor facilidad. NOTA: Cuando la entrada, es una cadena de carácter, no es necesario el operador direccional (&). El nombre de la cadena contiene la dirección. Ejemplo:

scanf(), finaliza la captación de la cadena al encontrar un espacio en blanco o fin de línea.



27

Ejemplo:

char cadena[15]; printf("Digite la cadena:\n\n"); scanf("%s", cadena);

Casos Especiales • JUEGO DE INSPECCIÓN: Define Un conjunto de caracteres que puede leerse

utilizando scanf().

Así: %[ABC]s: A, B y C son los únicos caracteres que puede leer al encontrar uno diferente, finaliza con un valor nulo. %[ A-Z ]s: También pueden ser rangos de carácter en este caso sólo acepta mayúsculas.

• JUEGO INVERSO: Aquí se declaran que caracteres NO puede tomar, la función

scanf(), se utiliza el circunflejo (^), que acepta cualquiera menos...

Ejemplo: %[^\n]s: Acepta cualquier carácter menos un salto de línea. %[^0-9]s: Acepta cualquier carácter menos del 0 al 9. Ejemplo: Scanf(“%[0-9]s”, &edad);


Mencione y Explique que es la lógica estructurada: ____________________________________________________________________________________________________________________________

Para que sirven las funciones getch() y putchar() ________________________________________________________________________________________________________________

Menciones las diferencias fundamentales entre las funciones de entrada y salida por consola, con las funciones de entrada y salida por consola con for__________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________

_______________________________

Escriba algunas restricciones que deben cumplir los Identificadores:



28

__________________________________________________________________________________________________________________________________________________

¿Cuál es la diferencia entre el tipo de dato %c, y el tipo de dato %s?: ________________________________________________________________________________________________________________

Para que sirve la directiva <stdio.h>: _______________________________________________________________________________________________________________

¿Y la directiva <conio.h>? __________________________________________________________________________________________________________________________

¿Para que sirve a declaratoria #define?: _______________________________________________________________________________________________________________________

Para que sirve el punto y coma (;) en C: ____________________________________________________________________________________________________________________

En C, no existe el tipo de dato string; sin embargo, podemos hacer uso de las cadenas de texto, ¿Por qué? Explique: ________________________________________________________________________________________________________________________________________________________________________________________________________________________

Ejercicios:

1. Haciendo uso de las funciones gets y puts, diseñe un programa en C, que se lea el nombre del usuario y lo muestre en pantalla junto con un saludo. 2. Diseñe un programa en C, que lea y muestre en pantalla el valor de tres variables de tipo Entero. 3. Diseñe un programa que muestre, los diferentes tipos de datos, usados en C. Primero, debe indicársele al usuario que introduzca un valor, de un tipo dado; luego y después de haber introducido valores en todas las variables, debe imprimirse el contenido de ellas, junto con un mensaje que indique, el tipo de dato:

4. Diseñe un programa, en el cual se introduzcan el nombre y el peso y de un alumno, y luego la muestre en pantalla. El Nombre debe incluir el apellido, y en el campo del peso, solo deben incluir valores numéricos.

5. Diseñe un programe en C, en el cual después de haber introducido, una tabla de multiplicación cualquiera, imprima ésta en forma de tabla:

2x2=4 2x3=6



29

2x4=8 . . . 2x10=20

6. Realice el siguiente ejercicio, tal como se muestra, luego ejecútalo, nuevamente, pero quitándole al código las sentencias: ge

#include <stdio.h> #include <conio.h> main() { char cadena[15]; printf("Digite la cadena:\n\n"); scanf("%s", cadena); printf("\n\t LA CADENA ES LA SIGUIENTE:\n\n"); printf("***********************************************\n"); printf("%s\n", cadena); printf("%s\n", cadena); printf("***********************************************\n"); getch(); return 0; }

OOOPPPEEERRRAAADDDOOORRREEESSS,,, EEEXXXPPPRRREEESSSIIIOOONNNEEESSS

Hasta ahora, prácticamente hemos visto, como el protocolo esencial, para realizar un programa en C; y algunas funciones muy importantes, como son las funciones de lectura e impresión (scanf y printf, respectivamente). Ahora veremos, otros aspectos fundamentales, como lo son los operadores, que pueden ser: lógicos, matemáticos, relacionales, etc. Las expresiones, y las estructuras: de secuenciación, de selección y de iteración.

OOOPPPEEERRRAAADDDOOORRREEESSS

Un operador, es un símbolo que indica al compilador que se lleve a cabo ciertas manipulaciones matemáticas o lógicas.

Operadores Aritméticos

Operador Propósito



30

+ Suma - Resta * Multiplicación / División

% Resto de la división entera Todos estos operadores se pueden aplicar a constantes, variables y expresiones. El resultado es el que se obtiene de aplicar la operación correspondiente entre los dos operandos. (Tomado de “Aprenda Lenguaje ANSII C, como si estuviera en primero”. Pag. 25). Los operandos sobre los que actúan los operadores aritméticos deben ser valores Numéricos, es decir datos enteros, punto flotante o de carácter (Int, float y char, respectivamente). Una aclaración especial, merece el operador “%”, que indica el resto de la división entera. Veámoslo con un ejemplo: Si dividimos 30/3, su cociente es 10, y su residuo es 0. Si dividimos 25/3, su cociente es 8, y tiene un residuo de 1. Entonces de lo que se encarga, este operador, es de devolvernos el valor del residuo de una división. Cabe aclarar que los datos deben de ser tipo entero, y su sintaxis es la siguiente:

25%3 NOTA: Este Operador, NO puede aplicarse a los datos de tipo float. Una Expresión, Es un conjunto de variable, constantes y otras expresiones más sencillas, relacionadas por algún tipo de operador. De las cuales hablaremos con más detalle, posteriormente.

Operadores de Relaciónales, Lógicos y Unarios Estos Operadores, los podemos dividir, en varios tipos, entre los cuales están: OPERADORES UNARIOS: C, incluye una clase de operadores que actúan sobre un solo operador para producir un nuevo valor. Por eso el nombre de unarios, por que para poder funcionar solo necesitan de un operador.

OPERADOR PROPÓSITO

-

Menos Unario: Es el signo menos que va delante de una variable, constante o expresión.

++

Operador Incremento: Hace que la variable, constante o expresión se aumente en uno.

--

Operador Decremento: Hace que su variable, constante o expresión disminuya en uno.



31

Ejemplo:

Int i=1, x=5; Printf(“%d”, ++i); Printf(“%d”, - -i);

Estos operadores, el incremento y el decremento, pueden utilizarse de dos maneras, eso depende del orden de aparición de los mismos: • Si el operador precede al operando el valor del operando se modifica antes de ser

utilizado. • Si el operador aparece después del operando, este se modifica después de ser

utilizado. Ejemplo:

Utilizando los operadores Unarios: #include <stdio.h> #include <conio.h> main() { int x=5; printf("\tPRIMERO OBSERVAREMOS EL RESULTADO DE ++X\n\n"); printf("%d\n", ++x); printf("%d\n", ++x); printf("%d\n", ++x); printf("\tAHORA OBSERVAREMOS EL RESULTADO DE --X\n\n"); printf("%d\n", --x); printf("%d\n", --x); printf("%d\n", --x); printf("\tEL RESULTADO DE X++ ES:\n\n"); printf("%d\n", x++); printf("%d\n", x++); printf("\tY EL DE X-- ES:\n\n"); printf("%d\n", x--); printf("%d\n", x--); getch(); return 0; }



32

Operadores relacionales o de comparación

OPERADOR SIGNIFICADO < Menor que

<= Menor o igual que > Mayor que

>= Mayor o igual que == Igual que (Para las comparaciones) != No igual a

Estos Operadores se encuentran dentro del mismo grupo de procedencia, que es menor que la de los Operadores Unarios y aritméticos. La Asociatividad de éstos es de izquierda a derecha. Cabe mencionar la diferencia entre los operadores = y ==, el primero (=), se utiliza para asignaciones de valores, mientras que el otro (==), se usa para comparaciones. Ejemplo: Si x>5, entonces x==6.

Operadores lógicos Estos son los que nos permiten unir varias comparaciones: 10>5 y 6==6. Los operadores lógicos son: AND (&&), OR (||), NOT(!). Operador && (AND, en castellano Y): Devuelve un 1 si se cumplen dos condiciones.

printf( "Resultado: %i", (10==10 && 5>2 ); Operador || (OR, en castellano O): Devuelve un 1 si se cumple una de las dos condiciones. Operador ! (NOT, negación): Si la condición se cumple NOT hace que no se cumpla y viceversa.

Operadores de Asignación Los Operadores de Asignación, como su nombre lo indica, se encargan de atribuirle, asignarle, confinarle, etc a una variable, el resultado de una expresión o el valor de otra variable. Se utilizan en forma de expresiones de asignación en los que se asigna en el valor de una expresión a un identificador. El operador de asignación más utilizado es “=” y su formato es:

identificador = expresión;



33

Donde el identificador representa por lo general una variable y una constante, una variable o una expresión más compleja. Si los dos operandos de la expresión de asignación son de tipo de datos diferentes el valor de la expresión de la derecha se convertirá automáticamente al tipo de identificador de la izquierda de ésta forma la expresión de asignación será del mismo tipo de datos. Ejemplo: • Un valor en coma flotante puede ser truncado, se asigna a un identificador entero. • Un valor de doble precisión puede ser redondeado si se asigna a un identificador de

coma flotante. En C, están permitidas las asignaciones múltiples, así:

Identificador1 = identificador2 = identificador3.....= identificadorn=expresión C, posee además los siguientes operadores de asignación:

OPERADOR EXPLICACIÓN += Expresión1+=expresión2. Equivale a:

expresión1=expresión1 + expresión2 -= i-=1. equivale a: i=i-1 *= J*=2. Equivale a: j=j*2 /= K/=m, equivale a: k=k/m

%= P%n. Equivale a: p=p%n Los Operadores de asignación tiene menos procedencia que el resto de los operadores y tienen asociatividad de izquierda a derecha. Ejemplo:

Programa que calcula el valor de la expresión X^2+X+1 #include <stdio.h> #include <conio.h> main() { float x, y, z; clrscr(); printf("\tPROGRAMA QUE CALCULA EL VALOR DE LA ECUACION X^2+X+1\n\n"); printf("Introduzaca el valor de x:\n"); scanf("%f", &x); y=x*x;



34

z=y+x+1; printf("**************************************\n"); printf("**El valor de la expresi¢n es: %.2f**\n", z); printf("**************************************\n"); getch(); return 0; }

Jerarquía de Operadores

CATEGORÍA DEL OPERADOR OPERADOR 1. Operadores Unarios -, ++, --, ! 2.Operadores Aritméticos:

a. Multiplicación, división y Resto entero

b. Suma y Resta

*, /, % +,-

3. Operadores Relacionales <, <=, >, >= 4. Operadores de Igualdad ==, != 5. Operadores Lógicos && (Y Lógico), || (NO Lógico) 6. Operadores de Asignación =, +=, -=, *=, /?, %=,

Reglas de jerarquía

1. Se ejecuta primero el operador de más alta jerarquía 2. Operadores que tienen igual jerarquía se evalúan de izquierda a derecha 3. Si existen expresiones encerradas entre paréntesis, estas se evalúan primero. 4. Si existen paréntesis anidados se evalúan primero los paréntesis más internos.

EEEXXXPPPRRREEESSSIIIOOONNNEEESSS

(Tomado de “Aprenda ANSII C como si estuviera en Primero”, Universidad de Navarra. 1998). Ya han aparecido algunos ejemplos del lenguaje C en las secciones precedentes. Una Expresión es una combinación de variables y/o constantes, y operadores. La expresión es equivalente al resultado que proporciona al aplicar sus operadores a sus operandos. Por ejemplo 1 + 5 es una expresión formada por dos operandos (1 y 5)y el operador (el +); esta expresión es equivalente al valor 6, por lo cual quiere decir que allí donde esta expresión aparece en el programa, en el momento de la ejecución es evaluada y sustituida por su resultado. Una expresión puede estar formada por otras expresiones más sencillas, y puede contener paréntesis de varios niveles agrupando distintos



35

términos. En C, existen diferentes tipos de expresiones. El cual depende del tipo de operadores que se estén utilizando. Por ejemplo: Expresiones lógicas, aritméticas, etc. Se debe hacer hincapié en que, si existen algunas expresiones encerradas entre paréntesis, estas se evalúan primero. Ejemplo:

9*(8+5) primero sumamos 8+5, cuyo resultado es 13, y este lo multiplicamos por nueve, con lo que la expresión anterior, da cómo resultado: 117. Si existen expresiones en paréntesis anidadas, es decir, que uno se encuentra dentro de otros paréntesis, se evalúan los más internos.

Ejemplo:

2*((20/(12-2))+5) Se evalúa la operación 12-2, que da como resultado 10, luego se divide 20, entre el resultado anterior, es decir 10. el resultado es 2, y a este número se le suma 5, obteniendo 7. ahora se multiplica por dos, para determinar así que la expresión anterior es igual a 14.



36

Estructuras Secuenciales y Cíclicas


Esta unidad busca que el estudiante conozca la forma de implementar las diferentes estructuras algorítmicas en el lenguaje de programación C++


La escritura de algoritmos implica, en muchas ocasiones, llegar a algo más que una simple secuencia. Es el caso, cuando existe una serie de caminos o alternativas a escoger dependiendo del resultado de una determinada situación. O bien, existe la exigencia de que un grupo de acciones no se hagan para un ente específico, sino que sea aplicado a muchos para realizar el mismo cálculo.


Proporcionar los conocimientos que permitan al estudiante reconocer y aplicar las diferentes estructuras algorítmicas implementadas en el lenguaje C++.


1. Conocer las estructuras de selección 2. Conocer las estructuras cíclicas



37


1. Estructuras secuenciales 2. Estructura selectiva Simple 3. Estructura Selectiva doble 4. Estructura selectiva Múltiple 5. Funcionamiento de Un Ciclo 6. Ciclo de Entrada Asegurada (While) 7. Ciclo Controlado por contador (For). 8. Ciclo Do... while

EEESSSTTTRRRCCCTTTUUURRRAAASSS SSSEEECCCUUUEEENNNCCCIIIAAALLLEEESSS

Se les denomina así, por que; son estructuras en un programa, que después de ejecutar una instrucción o sentencia, continúan con la otra, hasta llegar al final del programa. Los ejemplos que hemos visto anteriormente, son ejemplos de estructuras secuenciales. Veamos otros ejemplos: Ejemplo:

Diseñe un programa que calcula el cuadrado y el cubo de tres números introducidos por el usuario. #include <stdio.h> #include <conio.h> main() { int x, x1, x2, y, y1, y2, z, z1, z2; clrscr(); printf("\tPROGRAMA QUE CALCULA EL CUADRADO Y EL CUBO DE 3 NUMEROS\n\n"); printf("Introduzaca el primer numero:\n"); scanf("%d", &x); printf("Ahora ingrese el siguiente numero:\n"); scanf("%d", &y); printf("Y el tercer numero es:\n"); scanf("%d", &z); x1=x*x; x2=x*x*x; y1=y*y;



38

y2=y*y*y; z1=z*z; z2=z*z*z; printf("*********************************\n"); printf("**Numero****Cuadrado*****Cubo****\n"); printf("**%d **** %d ***** %d ****\n", x, x1, x2); printf("**%d **** %d ***** %d ****\n", y, y1, y2); printf("**%d **** %d ***** %d ****\n", z, z1, z2); printf("*********************************\n"); getch(); return 0; }

Ejemplo

Una empresa necesita conocer el sueldo neto a pagar a un empleado. Teniendo como entrada el salario produzca una salida de sueldo neto. Los descuentos a aplicar son: ISSS 5%, AFP 7% y Renta 10%, estos descuentos son sobre el salario, y es sueldo neto es la diferencia entre el salario y el total de las retenciones: #include <stdio.h> #include <conio.h> main() { float sueldo, afp, isss, renta, sn; char nombre[50]; clrscr(); printf("Introduzca el Nombre del empleado:\n"); scanf("%s", nombre); printf("Su sueldo es:\n"); scanf("%f", &sueldo); afp=sueldo*0.07; isss=sueldo*0.05; renta=sueldo*0.10; sn=sueldo-(afp+isss+renta); printf("El empleado %s\n", nombre); printf("Posee un sueldo neto de %.2f\n", sn); getch(); return 0; }

Ejemplo:

Diseñe un programa que calcule el promedio y la suma de tres números ingresados por el usuario:



39

#include <stdio.h> #include <conio.h> main() { float x, y, z, sum, prom; clrscr(); printf("El Primer n£mero es:\n"); scanf("%f", &x); printf("Ahora el segundo n£mero:\n"); scanf("%f", &y); printf("El Ultimo numero es:\n"); scanf("%f", &z); sum=x+y+z; prom=sum/3; printf("*****************************************\n"); printf("**La suma es %.2f y el promedio es %.2f*\n", sum, prom); printf("*****************************************\n"); getch(); return 0; }

EEESSSTTTRRRCCCTTTUUURRRAAA SSSEEELLLEEECCCTTTIIIVVVAAA SSSIIIMMMPPPLLLEEE

Los pequeños programas que hemos diseñada hasta el momento, han sido del tipo secuencial, es decir, una sentencia se ejecuta después de otra, hasta el final del programa. Pero en la vida diaria muchas veces debemos elegir entre un camino y otro para llegar a nuestro destino. Lo mismo pasa en programación, al realizar alguna actividad, nuestro programa debe ser capaz de elegir uno u otro camino, a seguir dependiendo del valor de alguna condición evaluada. Para ello C, dispone de tres tipos de 3 tipos de estructuras selectivas, la cuales son:

1. Estructura Selectiva Simple 2. Estructura Selectiva Doble 3. Estructura Selectiva Múltiple

Estructura selectiva simple Funciona de la siguiente manera: se evalúa una condición, de ser cierta efectúa una acción, de lo contrario, continúa con la ejecución normal del programa. Su sintaxis es la siguiente:

If(condición) Acción;



40

O también: If(Condición) Acción;

Donde:

Condición: Es una expresión lógica que es evaluada por el compilador Acción: es la Acción o Acciones que realizará el programa de resultar cierta la condición NOTA: En C, no existe la sentencia “End If”, como en otros lenguajes de programación para indicar que ha terminado el bloque de selección, sino que este se especifica con el punto y coma al final. Además que, después de la condición NO se escribe un punto y coma. Si son varias acciones, estas deben ir dentro de llaves {}, para indicarle al compilador que son un solo bloque de acciones que deben ejecutarse.

Ejemplo:

En una tienda se venden artículos de primera necesidad, a los cuales se les aplica un descuento del 20%, de la compra total, si esta es igual o mayor a $50. Diseñe un programa en C, que a partir del importe total de la compra muestre lo que debe pagar el cliente. #include <stdio.h> #include <conio.h> main() { float compra; clrscr(); printf("Introduzca el valor de la compra:\n"); scanf("%f", &compra); if(compra>=50) compra=compra*0.8; printf("El Importe de la compra es %.2f\n\n", compra); getch(); return 0; }

EEESSSTTTRRRCCCTTTUUURRRAAA SSSEEELLLEEECCCTTTIIIVVVAAA DDDOOOBBBLLLEEE

Esta estructura, se caracteriza por el hecho que ofrece dos caminos a seguir, dependiendo si al evaluar la condición resulta cierta o falsa. Su sintaxis es la siguiente:



41

if(Condición) Acción 1; else Acción 2;

Funciona, de la siguiente manera si condición, al evaluarla resulta cierta, realiza la acción 1. de lo contrario, es decir; si al evaluar la condición resulta falsa, realiza la acción 2. Se debe tener en cuenta la condición puede ser compuesta, es decir haciendo uso de los operadores && y || (Y lógico y No lógico), además que cuando tenemos más de una sentencia por ejecutar ya sea del lado del cierto o del falso, estas van dentro de llaves. Ejemplo:

Se desea saber si un número es par o impar. Diseñe un programa en el cual el usuario, ingrese el número y el programa muestre con un mensaje, si éste es par o no. #include <stdio.h> #include <conio.h> main() { int num; printf("Ingrese el n£mero:\n"); scanf("%d", &num); if(num%2==0) printf("ES PAR\n\n"); else printf("ES IMPAR\n\n"); getch(); return 0; }

Ejemplo:

Diseñe un programa, que dada la nota de alumno, imprima en la pantalla un comentario sobre esa nota. El criterio para los comentarios es el siguiente: Si nota es mayor o igual a 9 “Excelente” Si nota es mayor o igual a 8 “Muy Bueno” Si nota es mayor o igual a 7 “Bueno” Si nota es mayor o igual a 6 “Regular” Si nota es menor que 6 “Necesita Mejorar” #include <stdio.h> #include <conio.h> main() { float nota; printf("Digite la nota, porfavor:\n");



42

scanf("%f", &nota); if(nota >= 9.0) printf("EXCELENTE\n\n"); else if(nota >= 8.0) printf("MUY BUENO\n\n"); else if(nota >= 7.0) printf("BUENO\n\n"); else if(nota >=6.0) printf("REGULAR\n\n"); else printf("NECESITA MEJORAR\n\n"); getch(); return 0; }

Este ejemplo, muestra que C, permite hacer anidamientos, es decir, una selección dentro de otra, ya sea del lado del cierto, o del falso o de ambos. El lector, puede tratar de hacer sus propias conclusiones, además de buscar otras posibles solucione para este mismo problema. Por ejemplo, ¿que pasaría si iniciamos con la condición del 6.0? ¿Qué pasaría si el usuario digita una neta negativa? ¿Cómo podrías darle solución a este problema? Como programadores, debemos hacernos muchas preguntas al momento de diseñar nuestros programas, ya que estos No serán usados por nosotros, sino por otras personas.

Ejemplo:

• Dada el peso, la altura y el sexo, de unos estudiantes. Determinar la cantidad de vitaminas que deben consumir estos estudiantes, en base al siguiente criterio:

• Si son varones, y su estatura es mayor a 1.60, y su peso es mayor o igual a 150 lb,

su dosis, serán: 20% de la estatura y 80% de su peso. De lo contrario, la dosis será la siguiente: 30% de la estatura y 70% de su peso.

• Si son mujeres, y su estatura es mayor de a 1.50 m y su peso es mayor o igual a

130 lb, su dosis será: 25% de la estatura y 75% de su peso. De lo contrario, la dosis será: 35% de la estatura y 65% de su peso. La dosis debe ser expresada en gramos.

#include <stdio.h> #include <conio.h> main() { float peso, estatura, dosis; char sexo;



43

printf("Introduzca el sexo del alumno(a)<H/M>:\n"); scanf("%c", &sexo); printf("Peso:\n"); scanf("%f", &peso); printf("La estatura es de:\n"); scanf("%f", &estatura); if(sexo=='H' || sexo=='h') { if(estatura>1.60 && peso >=150) { dosis=(0.20*estatura)+(0.8*peso); printf("La dosis de este alumno ser : %.2f gramos\n\n", dosis); } else { dosis=(0.3*estatura)+(0.7*peso); printf("La dosis de este alumno sera %.2f gramos\n\n", dosis); } } else { if(estatura>1.50 && peso >=130) { dosis=(0.25*estatura)+(0.75*peso); printf("La dosis de esta alumna debe ser de %.2f gramos\n\n", dosis); } else { dosis=(0.35*estatura)+(0.65*peso); printf("La dosis de esta alumna debe ser de %.2f gramos\n\n", dosis); } } getch(); return 0; }

SSSEEELLLEEECCCCCCIIIÓÓÓNNN MMMÚÚÚLLLTTTIIIPPPLLLEEE

Como su nombre lo indica, permite seleccionar entre varios caminos para llegar al final. En este caso se pueden elegir un camino o acción a ejecutar de entre varios posibles que se debe de evaluar, llamada selector. Sintaxis:



44

switch(selector) { case Etiqueta A: Acción A; break; case Etiqueta B: Acción B; break; case Etiqueta n: Acción n; break; default: Excepción; break; }

En donde: Selector: Variables, expresiones simples de tipo ordinal, (enteros y caracteres –int y char-) Etiqueta: Tiene que ser del mismo tipo de datos de selecto. Estas deber ser constantes únicas y diferentes de otras. Excepción: Es opcional. Ejemplo:

Diseñe un programa en C, que dado un número del 1 al 3, muestre en pantalla y en letras, el mismo número: #include <stdio.h> #include <conio.h> main() { int n; clrscr(); printf("El N£mero es:\n"); scanf("%d", &n); switch(n) { case 0: puts("Cero"); break; case 1: puts("Uno"); break; case 2: puts("Dos"); break; case 3: puts("Tres"); break;



45

default: puts("Dato No valido"); break; } getch(); return 0; }


Mencione las diferencias entre las expresiones y los operadores: ________________________________________________________________________ ________________________________________________________________________ ________________________________________________________________________ Que tipo de datos son válidos para los operadores aritméticos: ________________________________________________________________________ ________________________________________________________________________ ________________________________________________________________________ Explique, el resultado de los operadores incremento y decremento, dependiendo de su posición: ________________________________________________________________________ ________________________________________________________________________ ________________________________________________________________________ ¿Qué son y para que sirven los operadores unarios?: ________________________________________________________________________ ________________________________________________________________________ ________________________________________________________________________ Explique, el funcionamiento de los operadores de asignación: ________________________________________________________________________ ________________________________________________________________________ ________________________________________________________________________ Ejercicios:

1. Diseñe un programa que dados tres números indique cual es el mayor de ellos. 2. Diseñe un programa que dados tres números indique cual de ellos es el menor. 3. En un cine se exhiben, películas para mayores de edad, diseñe un programa que

dada la edad, indique si la persona puede o no ver la película.



46

4. En un supermercado, se realizan descuentos por las compras a partir de unas bolitas de colores. Si el cliente saca una bolita color azul, tiene un descuento del 20%, si la bolita es roja, se aplica un descuento del 30% y si saca una bolita color blanca, no se aplica ningún descuento. Diseñe un programa que a partir del importe de la compra y el color de la bolita, muestre lo que debe pagar dicho cliente.

5. Se procesan las notas de 5, alumnos, de las cuales se desea saber cual es el

promedio de esas 5 notas, y cual fue la nota mayor y menor, además de imprimir al final el nombre y la nota de cada alumno en forma de tabla.

6. Un estudiante desea saber cuál fue su promedio en matemática I, para ello

dispone de la siguiente información: tiene 3 exámenes, con una ponderación del 20% cada uno y 2 laboratorios con una ponderación del 30% cada uno. Diseñe un programa que dadas las notas calcule el promedio del alumno y muestre en pantalla si el alumno esta reprobado o no (para aprobar esta materia se requiere de una nota mayor o igual a 6.00).

7. En un estacionamiento, se cobra de la siguiente manera: los primeros 10 minutos

son gratis, los siguientes 30 minutos tiene un valor de $0.30 y la hora $0.60. diseñe un programa que reciba tanto minutos como horas y muestre lo que debe cancelar el cliente. Tomando en cuenta que si es Martes y Sábado se hace un descuento del 12.56% sobre el monto total.

8. Diseñe un programa que al introducir un dígito del 0 a 9, muestre como se lee. 9. Diseñe unA pequeña calculadora que, al digitar un código realice una operación

específica: si el código es 1, la operación es la suma, si es 2, Resta. 3, multiplicación y 4 división. Si el usuario a escrito otro código inválido, mostrar un mensaje de error.

10. Construya un programa que dado el salario de un empleado, permita aplicarle un

aumento de 10% si el salario es inferior a $500, si es mayor se le aumentará un 8%. Luego debe aplicar una retención del 0.96% en concepto de Renta a ambos casos.

11. Se desea calcular el sueldo de un trabajador, a partir de las horas trabajadas en la

semana y la clase a la que pertenece: Trabajadores Clase “A”, se les paga $7 por hora. Trabajadores clase “B”, se paga $5 por hora. Trabajadores clase “C”, se les paga $4 por hora y los de clase “D”, $3.5 por hora.

12. Un comerciante se dedica a la venta de sillas únicamente. Vende tres tipos de

sillas: tipo A, tipo B y Tipo C los precios son $5.00, $7.00 y $10.00 respectivamente. Por cada cinco sillas compradas del tipo A, del tipo B o del tipo C los clientes reciben un descuento de 3%, 5% y 7%, las demás se cobran a precio normal. Diseñe un programa que imprima en forma de factura, con el nombre, precio unitario, precio total, nombre de la tienda, etc lo que debe cancelar cada cliente en concepto de la compra.



47

Descubre donde está el error.

El siguiente código, es de un programa que a partir de una nota determina si un alumno esta o no reprobado, y este puede presentar algunos errores de lógica, de sintaxis o de ejecución. ¿Puedes descubrirlos y modificarlos? #Include <stdio.h> #incluide <conio.h> main() { float nota; printf(“Digite la nota:\n”) scanf(“%f”, nota); if(nota>=6.00) printf(“Aprobado\n\n); else printf(Reprobado\n\n); getch(); return 0; }

CCCÍÍÍCCCLLLOOOSSS

Es muy común encontrar en los programas operaciones que se deben ejecutar un número repetido de veces en períodos más o menos espaciados. Si bien las instrucciones son las mismas, los datos sobre los que operan varían. A nuestro alrededor, encontramos problemas que presentan esas características, por ejemplo: el cálculo de la nota final de los estudiantes de Programación I, se realizará tantas veces como alumnos hayan inscritos en dicha asignatura, el cálculo del salario de los empleados de una empresa, etc. En estos casos la solución que se diseñe para un solo grupo de datos se debe repetir tantas veces como sea necesario (de acuerdo al número de estudiantes y de empleados para los ejemplos anteriores). Los cálculos simples o la manipulación de pequeños conjuntos de datos se pueden realizar fácilmente a mano, pero las tareas grandes o repetitivas son realizadas con mayor eficacia por una computadora, ya que estas están especialmente preparadas para ello. Para repetir varias veces un proceso determinado haremos uso de los ciclos repetitivos, a los cuales se les conoce con el nombre de estructura repetitiva, estructura iterativa, lazo o bucle. (Tomado de Los guiones de clase de Introducción a la Informática. Universidad de El Salvador. Año 2005)



48

En C, podemos encontrar tres tipos de ciclos:

1. Entrada Asegurada (while) 2. Ciclo Controlado Por Contador (for) 3. Hacer Mientras (do.. while)

Este ultimo, no está lógicamente estructurado, por tanto no haremos mucho hincapié en él.

FFFUUUNNNCCCIIIOOONNNAAAMMMIIIEEENNNTTTOOO DDDEEE UUUNNN CCCIIICCCLLLOOO

Un ciclo, funciona de la siguiente manera: Evalúa una condición de resultar cierta, realiza una acción o bloque de acciones, luego vuelve a evaluar la condición y si nuevamente resulta cierta, realiza la (s) acción (es). Cuando la condición de cómo resultado falso, se sale del ciclo y continúa con la ejecución normal del programa. Acumulador: Es una variable, que, como su nombre lo indica se encarga de acumular valores. Esto se vuelve muy útil, por ejemplo, cuando queremos encontrar la suma de los números del 0 al 9, en el acumulador, vamos guardando los valores de dichas cifras. Puede ser tanto real como entera. Su valor inicial, en la mayoría de los casos es cero. Contador: Es una variable de tipo entero, que nos ayuda, en el programa a contabilizar el número de ejecuciones de una misma acción, de un grupo de alumnos etc. Un acumulador tiene tres valores distintos:

• Valor Inicial: es el valor con el cual iniciamos nuestro contador. Generalmente es cero. Esta asignación puede hacerse cuando se declara la variable.

• Valor Final: después de la ejecución del ciclo, el valor del contador, será distinto

a su valor inicial, este puede ser mayo o menor que el mismo, todo depende si fue una cuenta creciente o decreciente.

• Valor de Cambio: Es el valor Constante, en el cual se irá incrementando nuestro

contador, este puede ser positivo o negativo; es decir, si la cuanta se realiza de manera ascendente o descendente.

NOTA: el lector no debe confundirse entre las variables tipo acumulador y tipo contador, estas se diferencian unas de otras en que: los contadores, su valor de cambio es una constante, ya que aumenta y disminuyen en el mismo valor, mientras que los acumuladores su valor de cambio no es constante. Un acumulador necesariamente lo inicializamos con cero (o al menos en la mayoría de los casos). Un contador puede iniciar con cualquier valor.



49

Bandera: Las variables tipo bandera son aquellas que sólo admiten dos valores: cierto o falso, true o false, hombre o mujer... etc.

CCCIIICCCLLLOOO DDDEEE EEENNNTTTRRRAAADDDAAA AAASSSEEEGGGUUURRRAAADDDAAA (((WWWHHHIIILLLEEE)))

La sintaxis es la siguiente:

while(condición) Acción;

Funciona de la siguiente manera: primero evalúa la condición, si da como resultado cierta realiza la acción, luego vuelve a evaluar la condición, si su resultado es falso, se sale del ciclo y continúa con la ejecución del programa. Hay que tener mucho cuidado, cuando trabajamos con ciclos, ya que podemos caer en un ciclo infinito, es decir que nunca se sale de él. Lo cual no es un error de sintaxis sino de lógica. Por lo cual en las acciones debemos siempre colocar algo que haga que se modifique el resultado de la condición, lo cual puede ser una bandera, un contador o un acumulador. Ejemplo:

Diseñe un Programa que imprima los primeros 10 números. #include <stdio.h> #include <conio.h> main() { int i=1; /*Declaramos nuestro contador con su Valor Inicial*/ while(i<=10) /*Mientras i sea menor o igual a 10:*/ { printf("%d\t", i);/*Imprimir el valor de i*/ i+=1;/*Aumentar el contador en 1*/ } getch(); return 0; }

Ejemplo:

Se desea conocer el promedio de los números mayores que cero, en una serie de números ingresados por el usuario. De los cuales no se sabe la cantidad, haciendo uso de una bandera, diseñe un programa en el cual el usuario ingrese los números que desee. #include <stdio.h>



50

#include <conio.h> main() { int i=0, sum=0, ban=1, n; float prom; while(ban==1) { printf("Ingrese un n£mero por Favor:\n"); scanf("%d", &n); if(n>0) { i=i+1; sum+=n; } printf("Desea Ingresar Otro N£mero? (Si=1 y No=0)\n"); scanf("%d", &ban); } prom=sum/i; printf("************************************************************\n"); printf("*** El Promedio de los numeros mayores que cero es: %.2f ***\n", prom); printf("************************************************************\n"); getch(); return 0; }

Ejercicio:

En un salón se tienen las notas de 14, alumnos; de los cuales se desea saber cual fue el promedio de todas las notas, cual fue la nota mayor y la nota menor. Así como la cantidad de aprobados en el curso (Para Aprobar la asignatura se requiere de una nota mayor o igual a 6.0) #include <stdio.h> #include <conio.h> main() { float suma=0, prom, menor=11, mayor=-1, nota; int i=1,j=0; while(i<=14) { printf("Ingrese la Nota del alumno %d:\n", i); scanf("%f", &nota); while(nota<0.00 || nota >10.00) { printf("ERROR, la nota debe estar entre 0 y 10\n"); scanf("%f", &nota); }



51

if(nota>=6.00) j=j+1; if(nota>mayor) mayor=nota; if(nota<menor) menor=nota; i=i+1; suma=suma+nota; } prom=suma/14; printf("El Promedio es %.2f\n\n", prom); printf("El total de Aprobados es %d\n", j); printf("La Mayor nota fue %.2f\n", mayor); printf("%.2f corresponde a la nota menor\n", menor); getch(); return 0;

}

CCCIIICCCLLLOOO CCCOOONNNTTTRRROOOLLLAAADDDOOO PPPOOORRR CCCOOONNNTTTAAADDDOOORRR (((FFFOOORRR)))

En algunas ocasiones, sabemos a ciencia cierta el número de veces que se tiene que repetir una misma acción o bloque de acciones. Y para ello es que nos sirve, esta estructura. Su sintaxis es la siguiente:

for( valor inicial; condición; incremento) accion;

Donde: Valor inicial: es el valor con el cual inicializamos nuestra variable de control. Condición: si la cumple, ejecuta la acción o acciones e incrementa o decrementa la variable de control, sino la cumple la condición, se sale del ciclo. Incremento; que puede ser positivo o negativo (decremento). Ejemplo:

Diseñe un programa que imprima los primeros 10 números: #include <stdio.h> #include <conio.h> main() { int i; for(i=1; i<=10; i++) printf("%d\t", i); getch();



52

return 0; }

Ejemplo:

Diseñe un programa en C, que calcule las compras totales, realizadas por un grupo de 20 amas de casa. Luego con esa información obtenga la media. #include <stdio.h> #include <conio.h> main() { int i; float compra, desvia, prom, varinza, sum=0; for(i=1; i<=10; i++) { printf("Ingrese la cantidad que gast¢ la ama de casa %d:\n", i); scanf("%f", &compra); while(compra<0) { printf("ERROR, la compra debe ser mayor que cero, vuelva a intentarlo:\n"); scanf("%f", &compra); } sum=sum+compra; } prom=sum/12; printf("El promedio de las compras es %.2f\n\n\a", prom); getch(); return 0; }

Cabe, mencionar que, en el ciclo for, podemos hacer cuentas decrecientes, es decir asignarle un valor grande a nuestra variable de control y luego irla disminuyendo hasta un valor determinado. Ejemplo:

En un cine, se tienen 3 diferentes clases de boletos. Se pide que diseñe un programa en el cual: • Se lea el precio de las 3 clase de boletos • Se lea el número de boletos vendidos de cada tipo • Calcular cual boleto es el que se vendió menos • El total recaudado en taquilla • Además se sabe que durante el día se realizaron un total de n ventas.



53

#include <stdio.h> #include <conio.h> main() { float preciob1, preciob2, preciob3, sum=0, sum1=0, sum2=0, sum3=0; int n, i, boletos1, boletos2, boletos3, boleto; clrscr(); printf("\t\tBIENVENIDO(A)\n\n\n"); printf("Ingrese el precio de los boletos 1:\n"); scanf("%f", &preciob1); while(preciob1<0) { printf("ERROR\n"); scanf("%f", &preciob1); } printf("Ingrese el precio de los boletos 2:\n"); scanf("%f",&preciob2); while(preciob2<0) { printf("ERROR\n"); scanf("%f", &preciob2); } printf("Ingrese el precio de los boletos 3:\n"); scanf("%f",&preciob3); while(preciob3<0) { printf("ERROR\n"); scanf("%f", &preciob3); } printf("¨Cu ntas ventas se realizaron este d¡a?:\n"); scanf("%d", &n); while(n<0) { printf("ERROR\n"); scanf("%d", &n); } for(i=1; i<=n; i++) { printf("Ingrese el Boleto:\n"); scanf("%d", &boleto); switch(boleto) { case 1: printf("Ingrese la cantidad de boletos vendidos:\n"); scanf("%d", &boletos1); sum1+=boletos1; sum=sum+(boletos1*preciob1); break; case 2: printf("Ingrese la cantidad de boletos vendidos:\n");



54

scanf("%d", &boletos2); sum2+=boletos2; sum=sum+(boletos2*preciob2); break; case 3: printf("Ingrese la cantidad de boletos vendidos:\n"); scanf("%d", &boletos3); sum3+=boletos3; sum=sum+(boletos3*preciob3); break; default: printf("ERROR, Vuelva a intentarlo\n\n"); break; } } clrscr(); if(sum3<sum2 && sum3<sum1) printf("Los Boletos que se vendieron menos fueron los boletos numero UNO\n\n"); if(sum2<sum3 && sum2<sum1) printf("Los Boletos que se vendieron menos fueron los boletos numero DOS\n\n"); if(sum1<sum2 && sum1<sum3) printf("Los Boletos que se vendieron menos fueron los boletos numero TRES\n\n"); printf("El total recaudado en taquilla, durante este dia fue: %.2f\n\n", sum); getch(); return 0; }

CCCIIICCCLLLOOO DDDOOO......... WWWHHHIIILLLEEE

Es te ciclo funciona de la siguiente manera, realiza la acción o conjunto de acciones, luego evalúa una condición de resultar cierta vuelve a realizar la/s accion/es. Cuando sea falsa, se sale del ciclo. Esta estructura, no está lógicamente, estructurada, por ello, no hablaremos mucho, sin embargo realizaremos un par de ejemplos, de este ciclo. Formato:

do { sentencia; . . } while(<expL>);

La diferencia fundamental, entre el ciclo while y do...while, es que en este ultimo, las sentencias se realizarán por lo menos una vez, en cambio, con while, solo se cumplirán mientras se cumpla la condición, lo cual puede ser nunca.



55

Ejemplo:

Programa que determina si un año es bisiesto o no. Y un año es bisiesto si es múltiplo de cuatro, pero excluyendo aquellos que son múltiplos de 100 pero no de 400 #include <stdio.h> #include <conio.h> void main() { int anio; char respuesta; printf("\n\n\nINICIO DEL PROGRAMA\n\n\n"); printf("\n\nEl programa te pide un anio y te dice exactamente si es bisiesto o no"); do { /*ENTRADA DE DATOS*/ printf("\n\nIntroduzca un anio determinado "); scanf("%d",&anio); /*PROCESO Y SALIDA DE DATOS*/ if ((anio%4==0 && anio%100!=0)||(anio%400==0)) printf("\n\nEl anio es bisiesto"); else printf("\n\nEl anio no es bisiesto"); printf("\n\nDesea introducir mas datos\n\n"); respuesta=getch(); } while(respuesta=='S' || respuesta=='s'); printf("\n\n\nFIN DEL PROGRAMA\n\n\n"); }

NOTA: este código ha sido tomado de “Practicas de Programación en C”, de Fernando Muñoz Ledesma. Practica 3, ejercicio 5.


¿Qué es y cómo funciona un ciclo? ________________________________________________________________________ ________________________________________________________________________ ________________________________________________________________________ ¿Cuál es la diferencia entre un contador y un acumulador? ________________________________________________________________________ ________________________________________________________________________ ________________________________________________________________________ ¿Cuál es la mejor manera de validar datos? ________________________________________________________________________ ________________________________________________________________________ ________________________________________________________________________



56

¿Cómo se evita un ciclo infinito? ________________________________________________________________________ ________________________________________________________________________ ________________________________________________________________________ ¿Qué diferencia existe entre un ciclo de entrada asegurada y el do... while?: ________________________________________________________________________ ________________________________________________________________________ ________________________________________________________________________ Descubre donde está el error.

El siguiente código muestra la serie:

1^2+2^2+3^2....n^2

En el cual hay errores de lógica, de sintaxis o hasta de ejecución, ¿puedes descubrirlos y corregirlos? #include <stdio.h> #include <conio.h> main() { int n i, x, sum=0; printf("Inrtroduzca el valor de n:\n"); scanf("%d", &n); while(n<0) { printf("Error, vuelva a digitar el valor de n:\n"); scanf("%d", n); } for(i=1; i<=n, i++) x=i*i; sum+=n; printf("El valor de la suma es:%d\n\n", sum) getch(); return 0; }

Ejercicios

1. Se desea conocer la suma de los números enteros, positivos menores que n, el cual es un dato dado por el usuario.



57

2. Muestre un programa en c, que imprima en pantalla los números desde un valor inicial, hasta un valor final, ingresados por el usuario, tanto en forma descendente como ascendente.

3. Diseñe un programa que imprima la serie de Fugonacci, así: 0 1 1 2 3 5 8 13.... hasta un número n dado por el usuario.

4. Calcule el promedio de edades de un grupo de estudiantes, de los cuales no se conoce la cantidad.

5. Diseñe un programa que obtenga, la calificación mayor y la calificación menor, de un grupo de 40 estudiantes, además de los nombres de dichos alumnos.

6. En un país hubieron elecciones para elegir al presidente. El país consta de 7 provincias o regiones, de las cuales se han levantado actas que contiene el total de votos obtenidos por los 4 partidos políticos en dicha región. Diseñe un programa en c, que lea las actas de las 7 provincias, muestre que partido ganó las elecciones y en caso de empate, lo especifique con un mensaje.

7. en un supermercado, hay 3 departamentos (de ropa, comestibles y perfumería), en lo cuales se realizan un descuento de 5%, 3.5% y 8% respectivamente, por las compras totales mayores de $100.00. diseñe un programa que dado el monto de la compra, realice los descuentos pertinentes por departamento, le indique al usuario a cuanto asciende su nuevo monto e indique, cuanto fue lo recaudado al final del día.

8. La Empresa, el porvenir s.a de c.v desea conocer lo que debe pagar en concepto de horas extras aun grupo de n empleados. Se sabe que una hora extra diurna, se paga el doble que una hora normal. Y una hora extra nocturna se paga el doble de una hora normal más el 25%. Además que todos los empleados tiene sueldos diferentes, muestre el nuevo sueldo de cada uno de ellos y lo que tendrá que pagar la empresa en concepto de horas extra.

9. Una compañía de teléfonos, cobra $0.03 por minuto la llamada nacional local, $0.06 por la llamada de larga distancia nacional y $0.10 la llamada de larga distancia internacional. Diseñe un programa que calcule las facturas mensuales de los clientes, sabiendo que, si las llamadas fueron realizadas por la mañana tienen un doble valor, y si los 10 primeros minutos de llamadas locales son gratis, en cualquier horario.



58

SUBPROGRAMAS O MÓDULOS - ARREGLOS


Esta unidad busca que el estudiante aprenda a trabajar con subprogramas o módulos, de igual manera, la forma de trabajar con arreglos unidimensionales o bidimensionales.


Una de las grandes ventajas que tiene la programación estructurada es la división de problemas grandes en subproblemas y, a su vez, éstos también pueden dividirse en problemas más pequeños. Cada una de las divisiones que se hacen para obtener la solución de un problema se denomina módulo y su implementación se hace por medio de subprogramas.

Por otro lado los datos siempre que estén relacionados se pueden organizar en estructuras, de tal manera que podamos tener un conjunto de datos manejados a través de un mismo nombre de variable.


Proporcionar los conocimientos que permitan al estudiante conocer y aplicar los conceptos de funciones (subprogramas) y arreglos (Vectores y Matrices)



59


1. Conocer la forma de implementar subprogramas o módulos 2. Conocer la forma de implementar arreglos


1. Subprogramas o Módulos 2. Paso de Parámetros 3. Funciones Definidas Por El Usuario en C 4. Funciones que no devuelven ningún valor. 5. Funciones que devuelven un valor entero 6. Funciones que Devuelven un Valor Real 7. Funciones en las que usamos Menú 8. Vectores 9. Uso de Vectores dentro de las Funciones 10. Matrices

SSSUUUBBBPPPRRROOOGGGRRRAAAMMMAAASSS OOO MMMÓÓÓDDDUUULLLOOOSSS

La modularización, es una técnica usada por los programadores para hacer sus códigos más cortos, ya que consiste en reducir un gran problema complejo, en pequeños problemitas más sencillos, concentrándose en la solución por separado, de cada uno de ellos. En C, se conocen como funciones aquellos trozos de códigos utilizados para dividir un programa con el objetivo que, cada bloque realice una tarea determinada. En las funciones juegan un papel muy importe las variables, ya que como se ha dicho estas pueden ser locales o globales. Variables Globales: Estas se crean durante toda la ejecución del programa, y son globales, ya que pueden ser llamadas, leídas, modificadas, etc; desde cualquier función. Se definen antes del main(). Variables Locales: Estas, pueden ser utilizadas únicamente en la función que hayan sido declaradas.



60

La sintaxis de una función es la siguiente:

Tipo_de_datos nombre_de_la_funcion(tipo y nombre de argumentos) { acciones }

Donde:

• Tipo_de_datos: Es el tipo de dato que devolverá esa función, que puede ser real, entera, o tipo void(es decir que no devolverá ningún valor).

• Nombre_de_la_funcion: Es el identificador que le damos a nuestra función, la cual debe cumplir las reglas que definimos en un principio para los identificadores.

• Tipo y nombre de argumentos: son los parámetros que recibe la función. Los argumentos de una función no son más que variables locales que reciben un valor. Este valor se lo enviamos al hacer la llamada a la función. Pueden existir funciones que no reciban argumentos.

• Acciones: Constituye el conjunto de acciones, de sentencias que cumplirá la función, cuando sea ejecutada. Entre ellas están:

• Asignaciones • Lecturas • Impresiones • Cálculos, etc

Una función, termina con la llave de cerrar, pero antes de esta llave, debemos colocarle la instrucción return, con la cual devolverá un valor específico. Es necesario recalcar que si la función no devuelve ningún valor, es decir, es tipo void, no tiene que ir la sentencia return, ya que de lo contrario, nos dará un error. Pero, es válido que nos hagamos la siguiente pregunta: ¿Cómo es que funcionan los Subprogramas? A menudo, utilizamos el adjetivo de “Subprogramas”, para referirnos a las funciones, así que, el lector debe familiarizarse también con este término. Los subprogramas se comunican con el programa principal, que es el que contiene a las funciones, mediante parámetros, que estos pueden ser: Parámetros Formales y Parámetros Actuales. Cuando se da la comunicación los parámetros actuales son utilizados en lugar de los parámetros formales.

PPPAAASSSOOO DDDEEE PPPAAARRRÁÁÁMMMEEETTTRRROOOSSS

Existen dos formas de pasar parámetros, las cuales son:



61

Paso por Valor También conocido como parámetros valor. Los valores se proporcionan en el orden de cálculos de entrada. Los parámetros se tratan como variables locales y los valores iniciales se proporcionan copiando los valores de correspondientes argumentos. Los parámetros formales-Locales de una función reciben como inicilaes los valores de los parámetros actuales y con ellos se ejecutan las acciones descritas en el subprograma. Ejemplo:

A=5; B=7; C=proc1(A, 18, B*3+4); Proc1(X, Y, Z)

Explicación: Donde, se encuentra c, se está llamando la función, denominada proc1, en la cual se están enviando como parámetros el valor de A, que es cinco; el cual es recibido por la variable X, en la definición de la función proc1; en la misma función, Y tendrá el valor de 18; por que ese es el valor del parámetro formal, mientras que Z, tendrá un valor inicial de 25, ya que ese es el resultado del tercer parámetro que resulta ser una expresión aritmética.

FFFUUUNNNCCCIIIOOONNNEEESSS DDDEEEFFFIIINNNIIIDDDAAASSS PPPOOORRR EEELLL UUUSSSUUUAAARRRIIIOOO EEENNN CCC

Una función, como ya se ha dicho, es un bloque de código dentro del programa que se encarga de realizar una tarea determinada. Por lo tanto un programa en c debe constar de una o más funciones, y por su puesto no puede faltar la función principal main(). Un viejo adagio dice: Separa y vencerás, lo cual se acopla perfectamente cuando tenemos un programa que es bastante grande; podemos separarlos en pequeños subprogramas (funciones), y concentrarnos en la solución por separados de cada uno de ellos y así resolver un gran problemas, en unos cuantos problemitas más pequeños. Si un programa, está constituido por más de una función, las llamadas a la misma, pueden realizarse desde cualquier parte del programa, y la definición de ellas debe ser independiente unas de otras. Por lo tanto sería un grave error el tratar de definir una función dentro de otra. Una función puede ser llamada desde cualquier parte del programa no sólo una vez, y cuando es llamada, empieza a ejecutar las acciones que están escritas en código.



62

Para mayor comodidad del lector vamos a ver varios ejemplos, del uso de funciones y a medida que vayamos avanzando se volverán más complejos. El orden será el siguiente: • Funciones que no devuelven ningún valor • Funciones que devuelven un valor entero • Funciones que devuelven un valor Real • Funciones combinadas • Funciones en las que usamos Menú.

FFFUUUNNNCCCIIIOOONNNEEESSS QQQUUUEEE NNNOOO DDDEEEVVVUUUEEELLLVVVEEENNN NNNIIINNNGGGÚÚÚNNN VVVAAALLLOOORRR...

Cómo se ha dicho las funciones pueden o no devolver algún valor, para mi parecer, este tipo de funciones son las más sencillas, ya que cuando se llama la función, esta realiza lecturas, asignaciones, cálculos o impresiones, finaliza la ejecución de la función y el programa continúa normalmente. Ejemplo:

Diseñe un programa que dados dos números enteros determine la suma y cual de ellos es mayor, usando dos funciones diferentes. #include <stdio.h> #include <conio.h> void suma (int a, int b); /*Declaraci¢n de la funci¢n*/ void mayor (int a, int b); /*Tipo de dato, nombre de la funci¢n y el tipo y nombre de los argumentos*/ main() { int a, b; printf("Ingrese el valor de a:\n"); scanf("%d", &a); printf("Ingrese el valor de b:\n"); scanf("%d", &b); suma(a,b); /*Llamado de la funci¢n*/ mayor(a,b); /*Unicamente el nombre de la funci¢n y de los par metros*/ getch(); return 0; } void suma(int a, int b) /*Definici¢n de la funci¢n*/ { /*Abrimos llaves al inicio de la definici¢n*/ int sum; /*Declaraci¢n de las variables locales*/ sum=a+b; printf("El valor de la suma es %d:\n\n", sum);



63

} /*Fin de la funci¢n suma*/ void mayor(int a, int b) { if(a==b) printf("Son iguales\n\n"); else { if(a>b) printf("El valor de a es mayor que el de b\n\n"); else printf("El valor de b es mayor que el de a\n\n"); } }

Definición de la Función La función ha sido declarada, ha sido llamada y por lo tanto deber haber sido definida. Lo cual consta de dos partes, las cuales son: • La Primera Línea

Que como su nombre lo indica, es la primera línea de la definición de la función y con ella le indicamos al compilador que está en presencia de una función. Su formato es el siguiente: Tipo_de_dato nombre_de_la_función (tipo y nombre de los argumentos)

• Cuerpo de la función

Se inicia con una llave “{“, y en ella, se pueden realizar asignaciones, cálculos, impresiones, así como la declaración de las variables locales. Puede estar constituidas por estructuras secuenciales, selectivas, iterativas, anidamientos, se pueden llamar otras funciones, etc; finaliza con “}”. Puede devolver uno o ningún valor.

Ejemplo:

Diseñe un Programa en C, que Dado un número entero y mayor que cero, Determine si es o no un número Primo. Ojo, los números primos sólo son divisibles por el mismo y por la unidad (1). #include <stdio.h> #include <conio.h> void primo (int numero); main() { int numero, ban=1; clrscr(); while(ban==1) {



64

printf("Introduzca el n£mero por favor:\n"); scanf("%d", &numero); while(numero<0) { printf("ERROR, el valor del n£mero debe ser mayor que cero\n"); scanf("%d", &numero); } primo(numero); printf("¨Otro n£mero (si=1 y No=0)?\n"); scanf("%d", &ban); } getch(); return 0; } void primo (int numero) { int div, primo=1; for(div=2; div<numero; div++) { if(numero%div==0) { primo=0; printf("%d NO es primo\n\n\n", numero); return 0; } else primo=1; } if(primo!=0) printf("%d es primo\n\n\n", numero); }

FFFUUUNNNCCCIIIOOONNNEEESSS QQQUUUEEE DDDEEEVVVUUUEEELLLVVVEEENNN UUUNNN VVVAAALLLOOORRR EEENNNTTTEEERRROOO...

Las funciones que devuelven algún valor, se les llama PROTOTIPOS DE FUNCIONES: Antes de usar una función C debe tener conocimiento acerca del tipo de dato que regresara y el tipo de los parámetros que la función espera. El estándar ANSI de C introdujo una nueva (mejor) forma de hacer lo anterior respecto a las versiones previas de C. La importancia de usar prototipos de funciones es la siguiente:



65

• Se hace el código mas estructurado y por lo tanto, más fácil de leer. • Se permite al compilador de C revisar la sintaxis de las funciones llamadas. Lo anterior es hecho, dependiendo del alcance de la función. Básicamente si una función ha sido definida antes de que sea usada (o llamada), entonces se puede usar la función sin problemas. Si no es así, entonces la función se debe declarar. La declaración simplemente maneja el tipo de dato que la función regresa y el tipo de parámetros usados por la función. Es una práctica usual y conveniente escribir el prototipo de todas las funciones al principio del programa, sin embargo esto no es estrictamente necesario. Para declarar un prototipo de una función se indicara el tipo de dato que regresará la función, el nombre de la función y entre paréntesis la lista del tipo de los parámetros de acuerdo al orden que aparecen en la definición de la función. Por ejemplo:

int longcad(int n); Lo anterior declara una función llamada longcad que regresa un valor entero y acepta otro valor entero como parámetro. (Tomado de “Manual de C” de Héctor Tejada Villela) Ejemplo:

Diseñe un programa, que dado un número entero y mayor que cero, muestre su factorial. (El factorial de 5 es 120; 5x4x3x2x1=120) #include <stdio.h> #include <conio.h> int factorial (int num); main() { int num, ban=1; clrscr(); while(ban==1) { printf("Ingrese el valor del n£mero por favor:\n"); scanf("%d", &num); while(num<0) { printf("ERROR, el valor del n£mero debe ser mayor que cero:\n"); scanf("%d", &num); } printf("El valor del factorial es %d\n\n", factorial (num)); printf("¨Desea Realizar otro calculo?Si=1 y No=0\n"); scanf("%d", &ban); } getch(); return 0; } int factorial (int num)



66

{ int sum=1, i; for(i=2; i<=num; i++) { sum=sum*i; } return (sum); }

Explicación: Quizá, lo único nuevo, e importante de explicar, radica en la llamada y la definición de la función. Cuando una función nos devolverá un valor entero, al identificador de dicha función debe precederle el tipo de dato. En el lugar, donde llamamos la función, es que aparecerá el valor que nos devuelva, como valor de retorno. En nuestro ejemplo, en una impresión. Y al momento de definirla, no se nos debe olvidar, colocarle la sentencia return(); ya que, mediante esta declaratoria, está retornando el valor calculado. Pero, que sucede cuando se está trabajando, con valores bastante grandes, al utilizar solamente el int, se producirá un error lógico; ya que como valor de retorno podría ser un cero o una cifra negativa. Por tanto debemos usar el tipo de dato “long int”. Ejemplo:

Diseñe un programa, que dada una cifra entera y mayor que cero, sea elevada a una potencia introducida por el usuario, la cual. (Ejemplo: 5^2=25). #include <stdio.h> #include <conio.h> long int potencia (int base, int exponente); main() { int base, exponente; clrscr(); printf("La Base es:\n"); scanf("%d", &base); while (base<0) { printf("ERROR, el dato debe ser mayor que cero:\n"); scanf("%d", &base); } printf("El Exponente es:\n"); scanf("%d", &exponente); printf("%d ^ %d es %ld\n\n", base, exponente, potencia(base,exponente)); getch(); return 0; } long int potencia (int base, int exponente) {



67

long int sum=0, i,x; for(i=1; i<exponente; i++) { x=base*base; sum=sum+x; } return (sum); }

Este método es un poco complejo y puede realizarse de manera más fácil, haciendo uso de las funciones predefinidas en C, de las cuales hablaremos a continuación.

FFFUUUNNNCCCIIIOOONNNEEESSS QQQUUUEEE DDDEEEVVVUUUEEELLLVVVEEENNN UUUNNN VVVAAALLLOOORRR RRREEEAAALLL...

Antes que nada, trataremos las funciones predefinidas en C. Ya que C, posee ciertas funciones que nos ayudan hacer nuestros programas más fáciles y utilizar menos código. El lenguaje c, cuenta con una serie de funciones de bibliotecas que realizan operaciones y cálculos de uso frecuente. Para acceder a una función, se realiza mediante el nombre seguido de los argumentos que le servirán a la función a realizar la tarea específica.

Nombre(arg1, arg2,...argn);

Funciones Matemáticas Para acceder a ellas, se debe colocar la directiva #include <math.h> en el encabezado del programa.

FUNCIÓN

(SINTAXIS) TIPO DE

DATO PROPÓSITO

acos(d) double Devuelve el arco coseno de d asin(d) double Devuelve el arco seno de d atan(d) double Devuelve el arco tangente de d atan(d1, d2) double Devuelve el arco tangente de d1/d2 ceil(d) double Devuelve el valor redondeado por exceso, al

siguiente entero mayor cos(d) double Devuelve el coseno de d cosh(d) double Devuelve coseno hiperbólico de d exp(d) double Eleva a la potencia d fabs(d) double Devuelve el valor absoluto de d



68

floor(d) double Devuelve el valor redondeado por defecto al entero menor más cercano

log(d) double Devuelve el logaritmo natural de d log10(d) double Devuelve el lo. (base10) de d pow(d1, d2) double Devuelve d1 elevado a la potencia d2 sin(d) Double Devuelve el seno de d sinh(d) double Seno hiperbólico de d sqrt(d) double Raíz cuadrada de d Tan(d) double Devuelve la tangente de d tanh(d) double Devuelve la tangente hiperbólica de d

Las siguientes funciones se encuentran en las librerías: stdid.h ó stdlib.h:

FUNCIÓN (SINTAXIS) TIPO PROPÓSITO

abs(i) int Devuelve el valor absoluto de i ran() int Devuelve un entero aleatorio srand(u) void Inicializa el generador de números aleatorios div(d1/d2) Double/

int Devuelve el cociente y el resto de la división

atuf(s) Double Convierte la cadena a una cantidad de doble precisión

atoi(s) int Convierte cadenas a un entero atol(s) long Convierte cadenas a un entero largo

Hay muchas otras funciones, pero para ahondar más, debes saber cuál es la versión de C, instalada en tu máquina y así verificar cuáles funcionan correctamente; pero por lo general, estas funciones son muy estándar para la mayoría de compiladores. A continuación, pasaremos a desarrollar una serie de ejercicios, en los cuales haremos uso de las funciones predefinidas en c, así como la modularización, es decir; el uso de funciones definidas por el usuario. Ejemplo:

Se desea conocer el resultado de las siguientes operaciones:

a+b |a-b| ab

Las variables a y b, son de tipo real, y pueden ser positivas o negativas.

#include <stdio.h> #include <conio.h>



69

#include <math.h> double raiz(float a, float b); double valor_absoluto(float a, float b); double exponente (float a, float b); main() { float a, b; clrscr(); printf("\t\tBIENVENIDO\n\n"); printf("Ingrese el valor de a, por favor:\n"); scanf("%f", &a); printf("Ahora el valor de b:\n"); scanf("%f", &b); printf("El resultado de la ra¡z cuadrada de %.2f + %.2f es %.2f\n\n", a,b,raiz(a,b)); printf("|%.2f-%.2f| es igual a %.2f\n\n", a,b,valor_absoluto(a,b)); printf("%.2f^%.2f es igual a %f\n\n", a,b,exponente(a,b)); getch(); return 0; } double raiz(float a, float b) { float x; double y; x=a+b; y=sqrt(x); return (y); } double valor_absoluto(float a, float b) { float x; double y; x=a-b; y=fabs(x); return (y); } double exponente (float a, float b) { double x; x=pow(a,b); return (x); }

Supongo que, este ejemplo no requiere mayor explicación. Pero me gustaría que el lector, comprenda la gran cantidad de usos que podemos darle, a aquellas funciones matemáticas, junto con las funciones definidas por el usuario, esta es una gran ayuda, ya que ¿se imaginan la cantidad de código que deberíamos colocar, para determinar cosas tan elementales como el valor absoluto?; con estas funciones matemáticas, C, nos ahorra mucho trabajo y código.



70

Funciones Combinadas A continuación veremos un ejemplo de un programa en el cual utilizamos dos funciones de diferente tipo de dato. Ejemplo:

El valor del número e se puede aproximar sumando n términos de la serie: e = 1 + 1/1! + 1/2! + 1/3! +... Escribir un programa que solicite el número de términos de la serie a sumar e informe del valor aproximado de e. Téngase en cuenta que el termino i de la anterior serie se obtiene dividiendo por (i-1). (La exclamación es el factorial). #include <stdio.h> #include <conio.h> #include <stdlib.h> void calculodatos(int numero); double factorial(int dato); void main(void) { int numero; char respuesta; printf("\n\n\nINICIO DEL PROGRAMA\n\n\n"); printf("\n\nEl programa te calcula el valor del numero e."); do { do { printf("\n\nIntroduzca un numero de terminos de la serie: "); scanf("%d",&numero); } while (numero<0); calculodatos(numero); printf("\n\n¨Desea introducir mas datos\?\n\n"); respuesta=getch(); system("cls"); } while (respuesta=='s' || respuesta=='S'); printf("\n\n\n\t\tÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛ"); printf("\n\t\tÛÛÛ FIN DEL PROGRAMA ÛÛÛ"); printf("\n\t\tÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛ\n\n\n"); } void calculodatos(int numero) { register int i; register double e=1.;



71

for (i=1;i<=numero;i++) { e=e+1./factorial(i); } printf("\n\nEl valor de e para %d terminos es %f.",numero,e); } double factorial(int dato) { register int i; register double resultado=1; for (i=dato;i>0;i--) resultado=resultado*i; return resultado; }

El ejemplo anterior ha sido tomado de “Practicas de C”, de Fernando Muñoz Ledesma. Y así como este ejemplo, podemos realizar muchas otras combinaciones de funciones, según necesitemos y lo solicite nuestro programa.

FFFUUUNNNCCCIIIOOONNNEEESSS EEENNN LLLAAASSS QQQUUUEEE UUUSSSAAAMMMOOOSSS MMMEEENNNÚÚÚ...

En la práctica, muchas veces debemos diseñar programas, que nos permitan elegir la acción o acciones a realizar, es decir haciendo uso de un menú. El cual, no es más ni menos que la aplicación de un selector múltiple. Un switch. Ejemplo:

Diseñe un programa, que dado un ángulo, muestre su seno, coseno o tangente; según lo desee el usuario. #include <stdio.h> #include <conio.h> #include <math.h> void seno (float angulo); void coseno (float angulo); void tangente (float angulo); main() { float angulo; int opcion, ban=1; clrscr(); while(ban==1) {



72

printf("\t\tBIENVENIDO/A\n\n"); printf("Introduzca el valor del angulo, por favor:\n"); scanf("%f", &angulo); printf("¨Que desea hacer?:\n\n"); printf("********************************************\n"); printf("**** 1. seno del angulo ****\n"); printf("**** 2. coseno del angulo ****\n"); printf("**** 3. tangente del angulo ****\n"); printf("********************************************\n"); scanf("%d", &opcion); while(opcion<0 || opcion>3) { printf("ERROR, la opcion debe estar entre 0 y 3:\n"); scanf("%d", &opcion); } clrscr(); switch(opcion) { case 1: seno (angulo); break; case 2: coseno (angulo); break; case 3: tangente (angulo); break; } printf("¨Hay mas datos? (si=1 y no=0)\n"); scanf("%d",&ban); } getch(); return 0; } void seno (float angulo) { float y; y=sin (angulo); printf("El seno de %f es %f\n\n", angulo, y); } void coseno (float angulo) { float y; y=cos(angulo); printf("El coseno de %f es %f\n\n", angulo, y); } void tangente (float angulo) { float y; y=tan(angulo); printf("La tangente de %f es %f\n\n", angulo, y); getch();



73

}


Mencione y explique, las partes en las que se componen las funciones definidas por el usuario en C: ________________________________________________________________________ ________________________________________________________________________ ________________________________________________________________________ ¿Cuál es la diferencia entre las funciones predefinidas en c y las funciones definidas por el usuario? ________________________________________________________________________ ________________________________________________________________________ ________________________________________________________________________ ¿En que consiste el paso de parámetros?: ________________________________________________________________________ ________________________________________________________________________ ________________________________________________________________________ ¿Cuál es la diferencia entre parámetros formales y actuales?: ________________________________________________________________________ ________________________________________________________________________ ________________________________________________________________________ ¿En qué se diferencian las variables locales a las globales? ________________________________________________________________________ ________________________________________________________________________ ________________________________________________________________________ Ejercicios

1. Realice una pequeña calculadora, utilizando funciones 2. Diseñe un programa que permita calcular la serie ½ + 1/3 + ¼+ ... 1/n. 3. Diseñe un programa, que muestre el mayor y el menor de tres introducidos por el

usuario. 4. Se desea conocer el logaritmo natural y el logaritmo base 10 de una serie de

números. Así como la suma de dichos valores 5. Se desea conocer la permutación de dos números distintos. Usando funciones.

Diseñe un programa que resuelva dicho problema. (NOTA: 5P3=5!/(5-3)!) 6. Se desea conocer la equivalencia de dólares a colones (un dólar = 8.75 de colón),

la equivalencia de un kilogramos a libras (1kg=2.2lb) y la conversión de kilómetros a millas (1km=0.62millas). realice esta solución mediante un menú.

7. Calcule lo que debe pagar cada cliente en un almacén; si por cada compra el cliente tiene derecho a sacar un papelito, y dependiendo del color, se efectúan



74

diferentes descuentos. Si el color es blanco, se realiza un descuento del 2.63% sobre la cuenta, si es verde, un descuento de 4.85% y si es rojo, un descuento de 5.02%. se sabe además que si es día lunes o viernes, el porcentaje de descuento es el doble.

8. El seno de un ángulo, puede aproximarse, de la siguiente manera: sin(x) = x - x^3/3! + x^5/5! - x^7/7! + ..., determine este valor, y usando la función sin(d), luego muestre la diferencia entre estos valores.

9. En una empresa de electricidad, se cobrar las facturas correspondientes al consumo de kwh, de la siguiente manera: los primeros 100 kwh, se cobran $2.5, lo siguientes 200 kwh, son a $5.00, los 300kwh, siguientes, son cobrados a razón de $7.5, los kwh siguientes se cobran a $7.00. diseñe un programa que permita determinar lo que debe pagar un grupo de clientes al final del mes.

10. En una empresa de repuestos de automóvil, poseen 10 tipos de repuestos identificados con los números de 1 al 10. durante la semana se realizan diferentes ventas de los repuestos. Se desea saber la cantidad de repuestos que se deben comprar, para actualizar el inventario. El cual se realiza cada cinco días, y se procede de la siguiente manera: cada día se contabilizan el total de facturas, en las cuales se muestran la cantidad de artículos vendidos así como el total de la venta. Con esos datos, indique al usuario cuantos y de que tipo, son los repuestos que se deben comprar así como la ganancia.

EEESSSTTTRRRUUUCCCTTTUUURRRAAASSS DDDEEE DDDAAATTTOOOSSS (((AAARRRRRREEEGGGLLLOOOSSS)))

Un array es un identificador que referencia un conjunto de datos del mismo tipo. Imagina un tipo de dato int; podremos crear un conjunto de datos de ese tipo y utilizar uno u otro con solo cambiar el índice que lo referencia. El índice será un valor entero y positivo. En 'C' los arrays comienzan por la posición 0.

VVVEEECCCTTTOOORRREEESSS

Un vector es un array unidimensional, es decir, solo usa un índice para referenciar a cada uno de los elementos.

Su declaración será: tipo nombre [tamaño]; El tipo puede ser cualquiera de los ya conocidos y el tamaño indica el número de elementos del vector (se debe indicar entre corchetes [ ]). En el ejemplo puedes observar que la variable i es utilizada como índice, el primer for sirve para rellenar el vector y el segundo para visualizarlo. Como ves, las posiciones van de 0 a 9 (total 10 elementos). (Tomado de “Introducción al lenguaje de programación de C/C++”. Sergio Pacho)



75

Ejemplo:

nt num[100]; /*Arreglo de tipo entero compuesto de 100 posiciones*/ char nom[80]; /*Texto de 80 caracteres*/ float x[12]; /*arreglo de 12 elementos punto flotantes */

Constante Simbólica Hace más sencillo o más fácil modificar un programa que utiliza arreglos. Ya que todas las referencias al tamaño del arreglo pueden ser alteradas, cambiando el valor de la constante simbólica. Ejemplo:

Diseñe un programa que lea un vector de 10 posiciones, luego determine si la quinta posición es positiva, si la primera posición es negativa y si la ultima posición es cero. #include <stdio.h> #include <conio.h> #define N 10 main() { float x[N]; int i; for(i=0; i<N; i++) { printf("Ingrese el valor %d:\n", i); scanf("%f", &x[i]); } if(x[4]>0) { printf("La quinta Posici¢n es Positiva\n\n"); } if(x[0]<0) { printf("La 1ø Posici¢n es Negativo\n\n"); } if(x[N-1]==0) { printf("La Ultima Posici¢n es cero\n\n"); } getch(); return 0; }



76

Explicación En este ejemplo estamos haciendo uso de la constante simbólica, de cuyos beneficios ya se habló. La definimos con 10 posiciones, recordando que C, empieza a contar desde cero. Luego definimos el vector llamado x, como punto flotante, y ojo, que éste va acompañado de su dimensión. Luego haciendo uso de un for, empezamos a llenar el vector. Luego preguntamos si la posición cuatro es positiva. El lector se preguntará el por que, la instrucción es x[4] y no x[5], ya que; lo que queremos es averiguar, si la posición cinco es la positiva. Pues bien, la posición identificada con el número cuatro, es en efecto la que contiene el quinto número. Así:

Esta es una versión gráfica, de lo que sucedería al llenar nuestro vector con los valores indicados. Como podemos ver, C empieza a enumerar las casillas desde el cero, hasta el 9. totalizando de esa manera 10 posiciones. Así que, x[4]=8. Es por ello, que el for, lo inicializamos con cero, hasta un valor menor que el de la constante, ya que de lo contrario nos daría un error. Una particularidad con los vectores de tipo char (cadena de caracteres), es que deberemos indicar en que elemento se encuentra el fin de la cadena mediante el carácter nulo (\0). Esto no lo controla el compilador, y tendremos que ser nosotros los que insertemos este carácter al final de la cadena. Por tanto, en un vector de 10 elementos de tipo char podremos rellenar un máximo de 9, es decir, hasta vector[8].Si solo rellenamos los 5 primeros, hasta vector[4], debemos asignar el carácter nulo a vector[5]. Es muy sencillo: vector[5]='\0'; Ahora veremos un ejemplo de como se rellena un vector de tipo char. Podemos ver que en el for se encuentran dos condiciones:

1. Que no se hayan rellenado todos los elementos (i<19). 2. Que el usuario no haya pulsado la tecla ENTER, cuyo código ASCII es 13.

(cadena[x-i]!=13).

UUUSSSOOO DDDEEE VVVEEECCCTTTOOORRREEESSS DDDEEENNNTTTRRROOO DDDEEE LLLAAASSS FFFUUUNNNCCCIIIOOONNNEEESSS

Un vector, solo puede ser argumento formal, es decir; por el momento, no podemos enviarlo como valor de retorno., digo por el momento por que cuando hablemos de punteros, veremos que si se pueden enviar.



77

Y dicho proceso se realiza de la siguiente manera: Declaración o Prototipo:

Tipo_de_dato nombre de la funcion (tipo_de_dato[]); Llamado de la Función

Nombre_de_la_funcion(nombre del vector); Definición de la función

Tipo_de_dato nombre de la funcion (tipo_de_dato nombre[]) Ejemplo:

Diseñe un programa en C, que lea un vector de un máximo de 20 posiciones, y luego determine: • La suma de todos los valores • El mayor de los valores, así como la posición del mismo. Se sabe que dichos datos son de tipo entero #include <stdio.h> #include <conio.h> #define N 20 int suma (int [N]); /*Declaración de la función*/ void mayor (int [N]); /*Ojo, los argumentos que son vectores solo necesitan el tipo de dato y la dirección*/ main() { int numeros[N], i; printf("Ingrese la Cantidad de Valores:\n"); scanf("%d", &limite); while(limite<0 || limite >N) for(i=0; i<N; i++) { printf("Ingrese el elemento %d del vector:\n", i); scanf("%d", &numeros[i]); } printf("La suma de todos los elementos del vector es: %d\n", suma(numeros)); mayor(numeros); /*Llamado de la función */ getch(); return 0; } int suma (int numeros [N]) /*Definición de la función */ { int sum=0, i;



78

for(i=0; i<N; i++) sum=sum+numeros[i]; return (sum); } void mayor (int numeros [N]) { int pos=0, mayor=numeros[0], i; for(i=1; i<N; i++) { if(numeros[i]>mayor) { mayor=numeros[i]; pos=i; } } printf("El valor mayor es %d y esta en la posici¢n %d\n\n", mayor, pos); }

El lector, debe preguntarse, que pasaría si existen dos valores exactamente iguales que sean los valores máximos y que por ende, estén en diferentes posiciones, que solución le darías como programador?... este tipo de preguntas debe hacerse siempre que ha finalizado un programa, y nunca dejar nada sin resolver, por que recordemos que los programas que diseñamos son para que otras personas los usen.

MMMAAATTTRRRIIICCCEEESSS

Las matrices se declaran de forma análoga, con corchetes independientes para cada subíndice. La forma general de la declaración es:

tipo nombre[numero_filas][numero_columnas]; Donde tanto las filas como las columnas se numeran también a partir de 0. La forma de acceder a los elementos de la matriz es utilizando su nombre, seguido de las expresiones enteras correspondientes a los dos subíndices, entre corchetes. En C tanto los vectores como las matrices admiten los tipos de las variables escalares (char, int, long, float, double, etc.), Las matrices en C se almacenan por filas, en posiciones consecutivas de memoria. En cierta forma, una matriz se puede ver como un vector de vectores-fila. Si una matriz tiene N filas (numeradas de 0 a N-1) y M columnas (numeradas de 0 a la M-1), el elemento (i, j) ocupa el lugar:

posición_elemento(0, 0) + i * M + j



79

A esta fórmula se le llama fórmula de direccionamiento de la matriz. (Tomado de “Aprenda Lenguaje ANSI C como si estuviera en Primero”. Universidad de Navarra). Ejemplo:

Diseñe un programa que lea un matriz de 6*6 y luego determine la suma de cada una de las filas y la almacene en un vector llamado suma. #include <stdio.h> #include <conio.h> #define F 6 #define C 6 main() { int matriz[F][C], i,j, vector [F]={0,0,0,0,0,0}; for(i=0; i<F; i++) for(j=0; j<C; j++) { printf("Ingrese el elemento F=%d y Columna=%d de la matriz:\n", i,j); scanf("%d", &matriz[i][j]); vector[i]=vector[i]+matriz[i][j]; } printf("La Matriz generada es:\n\n"); for(i=0; i<F; i++) { for(j=0; j<C; j++) { printf("*%d*", matriz[i][j]); } printf("\n"); } printf("Y el vector suma de las filas es:\n\n"); for(i=0; i<F; i++) printf("%d\t", vector[i]); getch(); return 0; }

Creo que no hay mucho por explicar, el uso de una matriz en C, es bastante parecido al de un vector, pero con las diferencias que en un vector tenemos únicamente una dimensión y en las matrices tenemos dos. Ejemplo: Escriba un programa que visualice un cuadro mágico de orden impar N, comprendido entre 3 y 11; el usuario debe elegir el valor de N. Un cuadro mágico se compone de números enteros entre 1 y N, la suma de los números que figuran en cada fila, columna y diagonal son iguales.



80

Ejemplo:

8 1 6 3 5 7 4 9 2

Un método de generación consiste en situar en el centro de la primera fila, el número siguiente en la casilla situada por encima y a la derecha, y así sucesivamente... el cuadro es cíclico, la línea encima de la primera, es de hecho, la última y la columna a la derecha de la última es la primera. En caso de que el número generado caiga en una casilla ocupada, se elige la casilla situada de bajo del número que acaba de ser situado.

#include <stdio.h> #include <conio.h> #define N 11 #define M 11 int comprueba (int [N][M], int dim); void impresion (int [N][M], int dim); main() { int cuadrado[N][M]; int dim, f, c, i; clrscr(); printf("Introduzca la dimenci¢n por favor:\n"); scanf("%d", &dim); while(dim<3 || dim>11) { printf("ERROR, el valor de la dimenci¢n debe estar entre 3 y 11:\n"); scanf("%d", &dim); } while((dim%2)!=1) { printf("ERROR el valor de la dimenci¢n debe ser Impar:\n"); scanf("%d", &dim); } for(f=0; f<dim; f++) for(c=0; c<dim; c++) cuadrado[f][c]=0; f=0; c=dim/2; cuadrado[f][c]=1; for(i=2; i<=dim*dim; i++) { f--; c++; if(f<0 && c==dim) { f=1; c=dim-1;



81

} if(f<0) f=dim-1; if(c==dim) c=0; if(cuadrado[f][c]!=0) { c--; f=f+2; } cuadrado[f][c]=i; } printf("La constante m gica es: %d\n\n", comprueba (cuadrado, dim)); impresion(cuadrado, dim); getch(); return 0; } int comprueba (int cuadrado [N][M], int dim) { int magic=1, f,c, consmagic, sum=0, i, j=-1; consmagic=((dim*dim*dim)+dim)/2; for(f=0; f<dim; f++) { sum=0; for(c=0; c<dim; c++) sum=sum+cuadrado[f][c]; if(sum!=consmagic) magic=0; } for(c=0; c<dim; c++) { sum=0; for(f=0; f<dim; f++) sum=sum+cuadrado[f][c]; if(sum!=consmagic) magic=0; } sum=0; for(i=0; i<dim; i++) sum=sum+cuadrado[i][i]; if(sum!=consmagic) magic=0; sum=0; for((i=dim-1); i>=0; i--) { j=j+1;



82

sum=sum+cuadrado[i][j]; } if(sum!=consmagic) magic=0; if(magic==0) consmagic=0; return (consmagic); } void impresion (int cuadrado[N][M], int dim) { int f, c; printf("\tEL CUADRO GENERADO ES:\n\n"); for(f=0; f<dim; f++) { for(c=0; c<dim; c++) printf("*%d*", cuadrado[f][c]); printf("\n"); } }


¿Qué es una array o arreglo? ________________________________________________________________________ ________________________________________________________________________ ________________________________________________________________________ ¿Cuál es la diferencia entre un vector y una matriz? ________________________________________________________________________ ________________________________________________________________________ ________________________________________________________________________ ¿Cómo se define y se declara una función cuyos parámetros son vectores o matrices? ________________________________________________________________________ ________________________________________________________________________ ________________________________________________________________________ ¿Cuáles son los tipos de datos admitidos para los arreglos? ________________________________________________________________________ ________________________________________________________________________ ________________________________________________________________________ ¿Cuáles son las diferencias fundamentales entre un arreglo y una variable simple? ________________________________________________________________________ ________________________________________________________________________ ________________________________________________________________________



83

Ejercicios

1. En una escuela se tiene el listado de 30 alumnos con sus respectivas notas, diseñe un programa que muestre las notas de los alumnos que tuvieron una nota mayor que el promedio.

2. Diseñe un programa que dado un vector de magnitud X, busque y muestre la posición en la que se encuentra un valor N, dentro del vector

3. Se tiene dos vectores A y B, diseñe una solución, en la cual, en un tercer vector se guarde la multiplicación de los vectores A y B, y luego se impriman los tres vectores, uno a la par del otro, en forma vertical

4. Diseñe un programa en C, en el cual guarde un vector de 100 posiciones, determine la media y la desviación estándar.

5. Almacenar 50 números en un vector, elevar al cuadrado cada valor almacenado en el vector, almacenar el resultado en otro vector. Imprimir el vector original y el vector resultante

6. Diseñe un algoritmo y programa que lea dos vectores A y B de 20 elementos cada uno y sume el primer elemento de A con el ultimo elemento de B y luego el segundo elemento de A por el diecinueveavo elemento de B y así sucesivamente hasta llegar al veinteavo elemento de A por el primer elemento de B. El resultado de la suma almacenarlo en un vector C.

7. Se desea conocer la suma de la diagonal mayor y la diagonal menor de una matriz de F*C, e indique la diferencia matemática entre ambos resultados.

8. En una tiemda, hay 8 departamentos y se tiene el registro de las ventas del año pasado de cada departamento por mes. Se desea conocer: el departamento que tuvo mayores ventas a lo largo de año. El departamento que tuvo menores ventas en el año. El mes en que se vendió más en el departamento número 3 y los meses y el departamento que superó las ventas promedios así como el total de lo vendido a lo largo de año.

9. Se tienen dos Matrices de tamaño 4x4, se pide escriba un programa en el cual, mediante un menú, se puedan sumar, multiplicar o dividir las matrices.

10. El departamento de transito de la ciudad de Medellín ha acumulado información referente a las infracciones de los límites de velocidad durante un determinado periodo de tiempo. El departamento ha dividido la ciudad en cuatro cuadrantes y desea realizar una estadística de las infracciones a los límites de velocidad en cada uno de ellos. Para cada infracción se ha preparado una tarjeta que contiene la siguiente información:

• Número de registro del vehículo; • Cuadrante en el que se produjo la infracción • Límite de velocidad en kilometros por hora

Diseñe un programa para producir 2 informes; el primero eue contiene una lista de las multas de velocidad recolectadas, donde la multa se calcula como la suma del costo de la corte ($20,000) mas $ 1,250 por cada kph que exceda la velocidad límite. Prepare una tabla con los siguientes resultados:



84

INFRACCIONES A LOS LIMITES DE VELOCIDAD

Registro del

vehículo Velocidad

registrada (MPH) Velocidad limite Multa

Este informe debe ser seguido de un segundo en el cual se proporcione un análisis de las infracciones por cuadrante. Para cada uno de los 4 cuadrantes mencionados, debe darse el número de infracciones y la multa promedio.



85

MANEJO DE ARCHIVOS


Esta unidad busca que el estudiante aprenda a trabajar con memoria secunadaria, es decir, el amenjo de archivos.


El manejo de información a través de archivos es de gran utilidad en la programación, ya que permite la captura de información almacenada en ellos para su posterior utilización en diversos programas, evitando tener que entrar en forma manual la información que se quiere procesar; almacenar gran cantidad de información en espacios reducidos y con una alta precisión en el manejo de datos.


Proporcionar los conocimientos que permitan al estudiante conocer y aplicar los conceptos de archivos.


1. Conocer la forma de trabajar con archivos



86


1. Archivos de Texto 2. Archivos binarios 3. Archivos especiales 1: la impresora 4. Archivos especiales 2: salida de errores

AAARRRCCCHHHIIIVVVOOOSSS DDDEEE TTTEEEXXXTTTOOO

Escritura en un archivo de texto Para manejar archivos, siempre deberemos realizar tres operaciones básicas:

1. Abrir el archivo. 2. Leer datos de él o escribir datos en él. 3. Cerrar el archivo.

Eso sí, no siempre podremos realizar esas operaciones, así que además tendremos que comprobar los posibles errores. Por ejemplo, puede ocurrir que intentemos abrir un archivo que realmente no exista, o que queramos escribir en un dispositivo que sea sólo de lectura. Ejemplo:

#include <stdio.h> main() { FILE* archivo; archivo = fopen("prueba.txt", "wt"); fputs("Esto es una línea\n", archivo); fputs("Esto es otra", archivo); fputs(" y esto es continuación de la anterior\n", archivo); fclose(archivo); }

Hay varias cosas que comentar sobre este programa: • FILE es el tipo de datos asociado a un archivo. Siempre aparecerá el asterisco a su

derecha, por motivos que veremos más adelante (cuando hablemos de “punteros”). • Para abrir el archivo usamos “fopen”, que necesita dos datos: el nombre del archivo y

el modo de lectura. El modo de lectura estará formado por varias letras, de las cuales por ahora nos interesan dos: “w” indicaría que queremos escribir ( write) del archivo, y



87

“t” avisa de que se trata de un archivo de texto ( text). Como abrimos el archivo para escribir en él, se creará el archivo si no existía, y se borrará su contenido si ya existía (más adelante veremos cómo añadir a un archivo sin borrar su contenido).

• Para escribir en el archivo y para leer de él, tendremos órdenes muy parecidas a las que usábamos en pantalla. Por ejemplo, para escribir una cadena de texto usaremos “fputs”, que recuerda mucho a “puts” pero con la diferencia de que no avanza de línea después de cada texto (por eso hemos añadido \n al final de cada frase).

• Finalmente, cerramos el archivo con "fclose".

Lectura de un archivo de texto Si queremos leer de un archivo, los pasos son muy parecidos, sólo que lo abriremos para lectura (el modo de escritura tendrá una “r”, de “read”, en lugar de “w”), y leeremos con “fgets”: Ejemplo:

#include <stdio.h> main() { FILE* archivo; char nombre[80] = "c:\\autoexec.bat"; char linea[81]; archivo = fopen(nombre, "rt"); if (archivo == NULL) { printf("No existe el archivo!\n"); exit(1); } fgets(linea, 80, archivo); puts(linea); fclose(archivo); }

En este ejemplo hay algunos cambios: • En el nombre del archivo, hemos indicado un nombre algo más complejo. En estos

casos, hay que recordar que si aparece alguna barra invertida (\), deberemos duplicarla, porque la barra invertida se usa para indicar ciertos códigos de control. Por ejemplo, \n es el código de avance de línea y \a es un pitido. El modo de lectura en este caso es “r” para indicar que queremos leer ( read) del archivo, y “t” avisa de que es un archivo de texto.

• Para leer del archivo y usaremos “fgets”, que se parece mucho a “gets”, pero podemos limitar la longitud del texto que leemos (en este ejemplo, a 80 caracteres) desde el archivo. Esta cadena de texto conservará los caracteres de avance de línea.

• Si no se consigue abrir el archivo, se nos devolverá un valor especial llamado NULL. • La orden “exit” es la que nos permite abandonar el programa en un punto. La veremos

con más detalle un poco más adelante.



88

Lectura hasta el final del archivo Normalmente no querremos leer sólo una frase del archivo, sino procesar todo su contenido. Para ayudarnos, tenemos una orden que nos permite saber si ya hemos llegado al final del archivo. Es “feof” (EOF es la abreviatura de End Of File, fin de archivo). Por tanto, nuestro programa deberá repetirse mientras que no se acabe el archivo, así:

#include <stdio.h> main() { FILE* archivo; char nombre[80] = "c:\\autoexec.bat"; char linea[81]; archivo = fopen(nombre, "rt"); if (archivo == NULL) { printf("No existe el archivo!\n"); exit(1); } while (! feof(archivo)) { fgets(linea, 80, archivo); puts(linea); } fclose(archivo); }

Esa será la estructura básica de casi cualquier programa que deba leer un archivo completo, de principio a fin: abrir, comprobar que se ha podido acceder correctamente, leer con “while !(feof(…))” y cerrar.


Realizar los siguientes programas:

1. Un programa que pida al usuario que teclee frases, y las almacene en el archivo “frases.txt”. Acabará cuando el usuario pulse Enter sin teclear nada.

2. Un programa que pregunte un nombre de archivo y muestre en pantalla el contenido de ese archivo, haciendo una pausa después de cada 25 líneas, para que dé tiempo a leerlo. Cuando el usuario pulse Enter, se mostrarán las siguientes 25 líneas, y así hasta que termine el archivo.



89

Archivos con tipo Es frecuente que los archivos que queramos manejar no sean de texto, pero que aun así tengan un formato bastante definido. Por ejemplo, podemos querer crear una agenda, en la que los datos de cada persona estén guardados en un “struct”. En este caso, podríamos guardar los datos usando “fprintf” y “fscanf”, análogos a “printf” y “scanf” que ya conocemos.

fprintf( archivo, "%40s%5d\n", persona.nombre, persona.numero); fscanf( archivo, "%40s%5d\n", &persona.nombre, &persona.numero);

Como se puede ver en este ejemplo, suele ser recomendable indicar la anchura que debe tener cada dato cuando guardamos con “fprintf”, para que se pueda recuperar después de la misma forma con “fscanf”. Aun así, “fscanf” tiene el mismo problema que “scanf”: si leemos una cadena de texto, la considera terminada después del primer espacio en blanco, y lo que haya a continuación lo asignará a la siguiente cadena. Por eso, cuando manejemos textos con espacios, será preferible usar “fgets” o bien otras dos órdenes para manejo de archivos que veremos un poco más adelante.



1. Una agenda que maneje los siguientes datos: nombre, dirección, tlf móvil, email, y día, mes y año de nacimiento (estos tres últimos datos deberán ser números enteros cortos). Deberá tener capacidad para 100 fichas. Se deberá poder añadir un dato nuevo, visualizar los nombres de las fichas existentes, o mostrar todos los datos de una persona (se preguntará al usuario cual es el nombre de esa persona que quiere visualizar). Al empezar el programa, leerá los datos de un archivo llamado “agenda.dat” (si existe). Al terminar, guardará todos los datos en ese archivo.

Leer y escribir letra a letra Si queremos leer o escribir sólo una letra, tenemos las órdenes "fgetc" y "fputc", que se usan:

letra = fgetc( archivo ); fputc (letra, archivo);

Modos de apertura Antes de seguir, vamos a ver las letras que pueden aparecer en el modo de apertura del archivo, para poder añadir datos a un archivo ya existente:



90

TIPO SIGNIFICADO r Abrir sólo para lectura. w Crear para escribir. Sobreescribe el archivo si existiera ya (borrando el

original). a Añade al final del archivo si existe, o lo crea si no existe. + Se escribe a continuación de los modos anteriores para indicar que también

queremos modificar. Por ejemplo: r+ permite leer y modificar el archivo t Abrir en modo de texto. b Abrir en modo binario.

AAARRRCCCHHHIIIVVVOOOSSS BBBIIINNNAAARRRIIIOOOSSS

Hasta ahora nos hemos centrado en los archivos de texto, que son sencillos de crear y de leer. Pero también podemos manejar archivos que contengan información de cualquier tipo. En este caso, utilizamos “fread” para leer un bloque de datos y “fwrite” para guardar un bloque de datos. Estos datos que leamos se guardan en un buffer (una zona intermedia de memoria). En el momento en que se lean menos bytes de los que hemos pedido, quiere decir que hemos llegado al final del archivo. En general, el manejo de “fread” es el siguiente:

cantidadLeida = fread(donde, tamañoDeCadaDato, cuantosDatos, archivo); Por ejemplo, para leer 10 números enteros de un archivo (cada uno de los cuales ocuparía 4 bytes, si estamos en un sistema operativo de 32 bits), haríamos

int datos[10]; resultado = fread(&datos, 4, 10, archivo); if (resultado < 10) printf("Había menos de 10 datos!");

Al igual que ocurría con “scanf”, la variable en la que guardemos los datos se deberá indicar precedida del símbolo &. También al igual que pasaba con “scanf”, si se trata de una cadena de caracteres (bien porque vayamos a leer una cadena de texto, o bien porque queramos leer datos de cualquier tipo pero con la intención de manejarlos byte a byte), como char dato[500] no será necesario indicar ese símbolo &, como en este ejemplo:

char cabecera [40]; resultado = fread(cabecera, 1, 40, archivo); if (resultado < 40)



91

printf("Formato de archivo incorrecto, no está toda la cabecera!"); else printf("El byte en la posición 5 es un %d”, cabecera[4]);

Ejemplo: copiador de archivos

Duplicar un archivo de cualquier tipo (no necesariamente de texto) #include <stdio.h> FILE *fichOrg, *fichDest; /* Los dos archivos */ char buffer[2048]; /* El buffer para guardar lo que leo */ char nombreOrg[80], /* Los nombres de los archivos */ nombreDest[80]; int cantidad; /* El número de bytes leídos */ main() { /* Accedo al archivo de origen */ printf("Introduzca el nombre del archivo Origen: "); scanf("%s",nombreOrg); if ((fichOrg = fopen(nombreOrg, "rb")) == NULL) { printf("No existe el archivo origen!\n"); exit(1); } /* Y ahora al de destino */ printf("Introduzca el nombre del archivo Destino: "); scanf("%s",nombreDest); if ((fichDest = fopen(nombreDest, "wb")) == NULL) { printf("No se ha podido crear el archivo destino!\n"); exit(1); } /* Mientras quede algo que leer */ while (! feof(fichOrg) ) { /* Leo datos: cada uno de 1 byte, todos los que me caben */ cantidad = fread( buffer, 1, sizeof(buffer), fichOrg); /* Escribo tantos como haya leído */ fwrite(buffer, 1, cantidad, fichDest); } /* Cierro los archivos */ fclose(fichOrg); fclose(fichDest); }

Los cambios con relación a lo que conocíamos de archivos de texto son los siguientes:



92

• Los archivos pueden no ser de texto, de modo que leemos uno como archivo binario (con “rb”) y escribimos el otro también como archivo binario (con “wb”).

• Definimos un buffer de 2048 bytes (2 K), para ir leyendo la información por bloques (y guardando después cada bloque en el otro archivo).

• En la misma línea intento abrir el archivo y compruebo si todo ha sido correcto, con if ((fichOrg = fopen(nombreOrg, "rb")) == NULL)

Esto puede resultar menos legible que hacerlo en dos líneas separadas, como hemos hecho hasta ahora, pero es más compacto, y, sobre todo, muy frecuente encontrarlo en “fuentes ajenos” más avanzados, como los que se puedan encontrar en Internet o cuando se programe en grupo con otras personas, de modo que he considerado adecuado incluirlo.

• A “fread” le digo que queremos leer 2048 datos de 1 byte cada uno, y él nos devuelve

la cantidad de bytes que ha leído realmente. Para que el fuente sea más fácil de aplicar a otros casos en los que no sean bloques de 2048 bytes exactamente, suele ser preferible indicar que queremos leer el tamaño del bloque, usando “sizeof”:

cantidad = fread( buffer, 1, sizeof(buffer), fichOrg);

Cuando la cantidad leida sea menos de 2048 bytes, es que el archivo se ha acabado (lo podemos comprobar mirando esta cantidad o con “feof”).

• “fwrite” se maneja igual que fread: se le indica dónde están los datos, el tamaño de

cada dato, cuantos datos hay que escribir y en qué archivo almacenarlos. En nuestro ejemplo, el número de bytes que debe escribir será el que haya leido:

fwrite(buffer, 1, cantidad, fichDest);



1. Mejorar la agenda anterior, para guardar y leer cada “ficha” (struct) de una vez, usando fwrite/fread y sizeof, como en el último ejemplo.

Acceder a cualquier posición de un archivo Cuando trabajamos con un archivo, es posible que necesitemos acceder directamente a una cierta posición del mismo. Para ello usamos “fseek”, que tiene el formato:

int fseek(FILE *archivo, long posicion, int desde);



93

Veamos con detalle la anterior instrucción: • Es de tipo “int”, lo que quiere decir que nos va a devolver un valor, para que

comprobemos si realmente se ha podido saltar a la dirección que nosotros le hemos pedido: si el valor es 0, todo ha ido bien; si es otro, indicará un error (normalmente, que no hemos abierto el archivo).

• “archivo” indica el archivo dentro de el que queremos saltar. Este archivo debe estar abierto previamente (con fopen).

• “posición” nos permite decir a qué posición queremos saltar (por ejemplo, a la 5010). • “desde” es para poder afinar más: la dirección que hemos indicado con posic puede

estar referida al comienzo del archivo, a la posición en la que nos encontramos actualmente, o al final del archivo (entonces posic deberá ser negativo). Para no tener que recordar que un 0 quiere decir que nos referimos al principio, un 1 a la posición actual y un 2 a la final, tenemos definidas las constantes:

SEEK_SET (0): Principio SEEK_CUR (1): Actual SEEK_END (2): Final

Ejemplo: • Ir a la posición 10 del archivo: fseek(miArchivo, 10, SEEK_SET); • Avanzar 5 posiciones a partir de la actual: fseek(miArchivo, 5, SEEK_CUR); • Ir a la posición 8 antes del final del archivo: fseek(miArchivo, -8, SEEK_END);

Finalmente, si queremos saber en qué posición de un archivo nos encontramos, podemos usar “ftell(archivo)”.

Esta orden nos permite saber también la longitud de un archivo: nos posicionamos primero al final con “fseek” y luego comprobamos con “ftell” en qué posición estamos: fseek(archivo, 0, SEEK_END); longitud = ftell(archivo);

Ejemplo:

Leer información de un archivo BMP Vamos a abrir un archivo que sea una imagen en formato BMP y a mostrar en pantalla si está comprimido o no. Para eso necesitamos antes saber cómo se guarda la información en un archivo BMP, pero esto es algo fácil de localizar:

ARCHIVOS .BMP Un archivo BMP está compuesto por las siguientes partes: una cabecera de archivo, una cabecera del bitmap, una tabla de colores y los bytes que definirán la imagen. En concreto, los datos que forman la cabecera de archivo y la cabecera de bitmap son los siguientes:



94

TIPO DE INFORMACIÓN POSICIÓN EN EL ARCHIVO

Tipo de archivo (letras BM) 0-1 Tamaño del archivo 2-5 Reservado 6-7 Reservado 8-9 Inicio de los datos de la imagen 10-13 Tamaño de la cabecera de bitmap 14-17 Anchura (píxeles) 18-21 Altura (píxeles) 22-25 Número de planos 26-27 Tamaño de cada punto 28-29 Compresión (0=no comprimido) 30-33 Tamaño de la imagen 34-37 Resolución horizontal 38-41 Resolución vertical 42-45 Tamaño de la tabla de color 46-49 Contador de colores importantes 50-53

Con esta información nos basta para nuestro propósito: la compresión se indica en la posición 30 del archivo, ocupa 4 bytes (lo mismo que un “int” en los sistemas operativos de 32 bits), y si es un 0 querrá decir que la imagen no está comprimida.

#include <stdio.h> main(){ char nombre[60]; FILE* archivo; int compresion; puts("Comprobador de imágenes BMP\n"); printf("Dime el nombre del archivo: "); gets(nombre); archivo = fopen(nombre, "rb"); if (archivo==NULL) puts("No encontrado\n"); else { fseek(archivo, 30, SEEK_SET); fread(&compresion, 1, 4, archivo); fclose(archivo); if (compression == 0) puts("Sin compresión"); else puts ("BMP Comprimido "); } }



95

Ya que estamos, podemos mejorarlo un poco para que además nos muestre el ancho y el alto de la imagen, y que compruebe antes si realmente se trata de un archivo BMP:

#include <stdio.h> main() { char nombre[60]; FILE* archivo; int compresion, ancho, alto; char marca1, marca2; puts("Comprobador de imágenes BMP\n"); printf("Dime el nombre del archivo: "); gets(nombre); archivo = fopen(nombre, "rb"); if (archivo==NULL) puts("No encontrado\n"); else { marca1 = fgetc(archivo); /* Leo los dos primeros bytes */ marca2 = fgetc(archivo); if ((marca1 =='B') && (marca2 =='M')) { /* Si son BM */ printf("Marca del archivo: %c%c\n", marca1, marca2); fseek(archivo, 18, SEEK_SET); /* Posición 18: ancho */ fread(&ancho, 1, 4, archivo); printf("Ancho: %d\n", ancho); fread(&alto, 1, 4, archivo); /* Siguiente dato: alto */ printf("Alto: %d\n", alto); fseek(archivo, 4, SEEK_CUR); /* 4 bytes después: compresión */ fread(&compresion, 1, 4, archivo); fclose(archivo); switch (compresion) { case 0: puts("Sin compresión"); break; case 1: puts("Compresión RLE 8 bits"); break; case 2: puts("Compresión RLE 4 bits"); break; } } else printf("No parece un archivo BMP\n"); /* Si la marca no es BM */ } }



96



1. Mejorar la última versión de la agenda anterior (la que usa fwrite, fread y sizeof) para que no lea todas las fichas a la vez, sino que lea una única ficha del disco cada vez que lo necesite, saltando a la posición en que se encuentra dicha ficha con “fseek”.

2. Hacer un programa que muestre información sobre una imagen en formato GIF (se deberá localizar en Internet los detalles sobre dicho formato): versión, ancho de la imagen (en píxeles), alto de la imagen y cantidad de colores.

AAARRRCCCHHHIIIVVVOOOSSS EEESSSPPPEEECCCIIIAAALLLEEESSS 111::: LLLAAA IIIMMMPPPRRREEESSSOOORRRAAA

Mandar algo a impresora desde C no es difícil (al menos en principio): en muchos sistemas operativos, la impresora es un dispositivo al que se puede acceder a través como si se tratara de un archivo. Por ejemplo, en MsDos, se puede mostrar un archivo de texto en pantalla usando TYPE DATOS.TXT y lo mandaríamos a impresora si redirigimos la salida hacia el dispositivo llamado PRN: TYPE DATOS.TXT > PRN: De igual manera, desde C podríamos crear un programa que mandara información al archivo ficticio PRN: para escribir en impresora, así:

#include <stdio.h> main() { FILE* impresora; impresora = fopen("prn:", "wt"); fputs("Esto va a la impresora\n", impresora;); fclose(impresora); }

(Este mismo ejemplo debería funcionar desde muchas versiones de Windows, con bastante independencia de la impresora que tengamos instalada).



97

AAARRRCCCHHHIIIVVVOOOSSS EEESSSPPPEEECCCIIIAAALLLEEESSS 222::: SSSAAALLLIIIDDDAAA DDDEEE EEERRRRRROOORRREEESSS

Hemos comentado que en muchos sistemas operativos se puede usar el símbolo “>” para redirigir hacia “otro sitio” (la impresora o un archivo de texto, por ejemplo) la información que iba destinada originalmente a la pantalla. Esto funciona, entre otros, en Windows, MsDos y toda la familia de sistemas operativos Unix (incluido Linux). Pero en el caso de Linux (y los Unix en general) podemos redirigir además los mensajes de error hacia otro sitio distinto del resto de mensajes (que iban destinados a pantalla). Esto se consigue con el símbolo “2>” :

calculaResultados > valores.txt 2> errores.txt Esta orden pone en marcha un programa llamado “calculaResultados”, guarda en el archivo “valores.txt” los mensajes que normalmente aparecerían en pantalla, y guarda en el archivo “errores.txt” los mensajes de error. Esta política de separar los mensajes de información y los mensajes de error es fácil de llevar a nuestros programas. Basta con que los mensajes de error no los mandemos a pantalla con órdenes como “printf”, sino que los mandemos a un archivo especial llamado “stderr” (salida estándar de errores). Por ejemplo, a la hora de intentar abrir un archivo podríamos hacer:

archivo = fopen("ejemplo.txt", "rt"); if (archivo == NULL) fprintf(stderr, "Archivo no encontrado!\n"); else printf("Accediendo al archivo...\n");

Si el usuario de nuestro programa no usa “2>”, los mensajes de error le aparecerían en pantalla junto con cualquier otro mensaje, pero si se trata de un usuario avanzado, le estamos dando la posibilidad de analizar los errores cómodamente.

Un ejemplo de lectura y escritura: TAG de un MP3 Los archivos de sonido en formato MP3 pueden contener información sobre el autor, el título, etc. Si la contienen, se encontraría a 128 bytes del final del archivo. Los primeros 3 bytes de esos 128 deberían ser las letras TAG. A continuación, tendríamos otros 30 bytes que serían el título de la canción, y otros 30 bytes que serían el nombre del autor. Con esto ya podríamos crear un programa que lea esa información de un archivo MP3 (si la contiene) e incluso que la modifique. Estos textos (título, autor y otros) deberían estar rellenos con caracteres nulos al final, pero es algo de lo que no tenemos la certeza, porque algunas aplicaciones lo rellenan con espacios (es el caso de alguna versión de WinAmp). Por eso, leeremos los datos con “fread” y añadiremos un carácter nulo al final de cada uno.



98

Además, haremos que el programa nos muestre la información de varios archivos: nos pedirá un nombre, y luego otro, y así sucesivamente hasta que pulsemos Enter sin teclear nada más. #include <stdio.h> #include <string.h> main() { FILE* fich; char temp[31]; int i; do { /* Pido el nombre del archivo */ printf("\nEscribe el nombre del archivo MP3 a comprobar: "); gets(temp); /* Si no teclea nada, terminaré */ if (strcmp(temp,"")==0) puts("\nAplicacion finalizada."); /* Si existe nombre, intento abrir */ else

if ( (fich=fopen(temp,"r+b"))!=NULL ) { /* Si he podido abrir, muestro el nombre */ printf("Nombre del archivo: %s\n",temp); /* Miro el tamaño del archivo */ fseek(fich,0,SEEK_END); printf("Tamaño: %d\n",ftell(fich)); /* A 128 bytes está la marca "TAG" */ fseek(fich,-128,SEEK_END); fread(temp,3,1,fich); /* Son 3 letras, añado caracter nulo al final */ temp[3]='\0'; if (strcmp(temp,"TAG")!=0) puts("No se encontró información válida."); else { /* Si existe la marca, leo los datos */ /* Primero, 30 letras de titulo */ fread(temp,30,1,fich); temp[strlen(temp)]='\0'; printf("Titulo: %s\n",temp); /* Luego 30 letras de autor */ fread(temp,30,1,fich); temp[strlen(temp)]='\0'; printf("Artista: %s\n",temp); /* Ahora vamos a modificar el titulo */ printf("\nIntroduce el nuevo titulo: "); gets(temp);



99

/* Lo rellenamos con ceros, para seguir el estándar */ for (i=strlen(temp); i<=29; i++) temp[i]='\0'; /* Y lo guardamos en su posición */ fseek(fich,-125,SEEK_END); fwrite(&temp, 30, 1, fich); printf("Titulo actualizado.\n"); fclose(fich); } /* Fin del "else" de MP3 con informacion */ } /* Fin del "else" de archivo existente */

else puts("No se pudo abrir el archivo\n"); } /* Fin del "do..while" que repite hasta que no se escriba nombre */ while (strcmp(temp,"")!=0); }



100

COMO DEPURAR LOS PROGRAMAS


Esta unidad busca que el estudiante conozca la forma de depurar los programas elaborados.


La depuración es el análisis de un programa para descubrir fallos. Para eliminar esos fallos que hacen que un programa no se comporte como debería, se usan unas herramientas llamadas “depuradores”. Estos nos permiten avanzar paso a paso para ver cómo avanza realmente nuestro programa, y también nos dejan ver los valores de las variables, permitiendonos corregirlos y tener un código relmente efectivo.


Proporcionar los conocimientos que permitan al estudiante depurar y corregir los posibles errores que se le presentan en la elaboración de un programa.


• Aprender a depurar un programa en C++ • Reconocer diferentes ambientes de trabajo



101


1. Conceptos básicos sobre depuración 2. Ejemplos de algunos entornos

CCCOOONNNCCCEEEPPPTTTOOOSSS BBBÁÁÁSSSIIICCCOOOSSS SSSOOOBBBRRREEE DDDEEEPPPUUURRRAAACCCIIIÓÓÓNNN

La depuración es el análisis de un programa para descubrir fallos. El nombre en inglés es “debug”, porque esos fallos de programación reciben el nombres de “bugs” (bichos). Para eliminar esos fallos que hacen que un programa no se comporte como debería, se usan unas herramientas llamadas “depuradores”. Estos nos permiten avanzar paso a paso para ver cómo avanza realmente nuestro programa, y también nos dejan ver los valores de las variables. Como nuestros conocimientos ya nos permiten hacer programas de una cierta complejidad, es el momento de ver formas de descubrir dónde están los posibles errores. Lo haremos desde varios entornos distintos.

EEEJJJEEEMMMPPPLLLOOOSSS DDDEEE AAALLLGGGUUUNNNOOOSSS EEENNNTTTOOORRRNNNOOOSSS

Turbo C es un compilador antiguo, pero sencillo de manejar, y la depuración también es sencilla con él:



102

El menú “Run” es el que nos permite poner nuestro programa en marcha normalmente (“Run”), pero también el que nos permite avanzar paso a paso por las órdenes que lo forman. Hay dos maneras de hacerlo: • “Trace into” va paso a paso por todas las órdenes del programa. Si hay una llamada a

una función, también sigue paso a paso por las órdenes que forma esa función. • “Step over” es similar, salvo que cuando haya una llamada a una función, ésta se

tomará como una única orden, sin ver los detalles de dicha función. En cualquiera de ambos casos, se nos muestra con una línea azul por dónde va avanzando la depuración. Si queremos observar cómo evoluciona el valor de alguna variable, podemos añadir un “vigía” (en inglés “match”) desde el menu “Break/Watch. Este vigía quedará en la parte inferior de la pantalla.

Si trabajamos con DevC++ para Windows, la situación no es muy diferente. Primero debemos indicar dónde queremos que se interrumpa el programa (añadir un “breakpoint”), haciendo clic con el ratón en el margen izquierdo de nuestro programa. Esa línea quedará resaltada en color rojo.



103

Ahora ponemos en marcha el programa desde el menú “Depurar”. En la parte inferior de la pantalla aparecerán botones que nos permiten avanzar paso a paso, saltar las funciones o añadir un “watch” para comprobar el valor de unas variables. La línea que estamos depurando se marcará en azul (y destacada con una flecha). Los “watches” estarán visibles en la parte izquierda de la pantalla. Si usamos otra herramienta de desarrollo, como Anjuta, la depuración puede ser mucho más sencilla, similar al caso de Turbo C y al de DevC++.



104

En este caso, podemos depurar fácilmente desde el propio entorno de desarrollo. Aun así, el primer paso es el mismo que si fuéramos a usar gdb: debemos compilar con la opción -g. La forma más sencilla de hacerlo es indicar que queremos “activar la depuración”, desde el menú “Opciones”. Entonces ya podemos construir nuestro ejecutable normalmente, e iniciar la depuración desde el menú “Depurador”. Podremos avanzar paso a paso (desde el propio menú o pulsando la tecla F5), y añadir “watches” para observar cómo evoluciona el valor de las variables. Estos “watches” no estarán visibles hasta que no escojamos la pestaña correspondiente en la parte inferior de la pantalla. La línea que estamos depurando se indicará mediante una flecha en su margen izquierdo.



105

EJERCICIOS


Esta unidad busca que el estudiante perfeccione el conocimiento del lenguaje mediante la elaboración de difrentes ejercicios


La única forma de llegar al dominio de un lenguaje es mediante su práctica constante, por ello en la presente unidad se plantean una serie de ejercicios para que el estudiante afiance los conocimientos adquiridos. De igual manera se busca que plantee nuevos problemas que pueda solucionar mediante la utilización de la herramienta.


Proporcionar una serie de ejercicios que permitan al estudiante afianzar sus conocimientos.


• Resolver los ejercicios propuestos



106


1. Ejercicios varios

EEEJJJEEERRRCCCIIICCCIIIOOOSSS VVVAAARRRIIIOOOSSS

1. Si utilizará la siguiente instrucción en un programa C++, haría que se escribiera algo en la pantalla. ¿qué sería?

Cout << “C++ es fácil de entender Y APRENDER.”;

2. Qué significado tienen los símbolos \n empleados en la siguiente instrucción .

Cout << “teclee el número de \alumnos del curso\n”;

3. ¿Qué significa la siguiente instrucción?

cin >> numero_de_estudiantes;

4. ¿Qué significa la siguiente instrucción?

total_estudiantes = total_estudiantes*grupo;

5. ¿Qué significa esta directiva?

#include <iostream.h>

6. ¿Qué defecto, si lo hay, tienen las siguientes directivas include?

a. #include <iostream.h> b. #include < iostream.h> c. #include <iostream>

7. ¿Cuáles son las tres clases principales de errores de programación?

8. ¿Qué tipós de errores descubre el compilador?

9. Si en un programa omite el símbolo de puntuación (como un punto y coma), se

produce un error. ¿De qué tipo?

10. Si omite la llave final } de un programa, se produce un error. ¿De qué tipo?



107

11. Suponga que escribe un programa que debe calcualr los intereses de una cuenta bancaria de un banco que calcula los intereses diariamente, y suponga que lo escribe mal, de modo que calcula los intereses anualmente. ¿Qué tipo de error de programación es este?

12. Escriba una instrucción de salida que depliegue en la pantalla el siguiente mensaje:

La respuesta a la pregunta de la Vida, el Universo y Todo es 42

13. Escriba una instrucción de entrada que coloque la variable la_cifra (de tipo int) un

número que se introduzca mediante el teclado. Anteponga a la instrucción de entreada una instrucción de solicitud que pida al usuario teclear el número entero.

14. ¿Qué instrucciones debe incluir en un programa para asegurar que, cuando se

envíe su a la salida un número de tipo double, aparezca en la notación ordinaria 3 dígitos después del punto decimal?

15. Escriba un programa completo en C++ que escriba la frase:CREO QUE ESTOY

APRENDIENDO. El programa no hará nada más.

16. Escriba una instrucción de salida que produzca el carácter de nueva línea y el de tabulación.

17. Escriba un programa corto que declare e inicialice las variables double, uno, dos,

tres, cuatro y cinco con los valores 1.000, 1.414, 1.732, 2.000 y 2.236, respectivamente. Luego escriba instrucciones de salida para generar la siguiente leyenda y tabla. Utilice la secuencia de escape de tabulación \t para alinear las columnas. Si no esta familiarizado con el carácter de tabulación, experimente con él al efectuar este ejercicio. Una tabulación funciona como un tope mecánico en una máquina de escribir: hace que las salidas se inicien en la siguiente columna, que generalmente esta a una distancia igual a un múltiplo de 8 espacios. Muchos editores y la mayoria de los procesadores de texto tienen tabulaciones ajustables. Nuestra salida no.

La salida deberá ser:

N Raíz cuadrada 1 1.000 2 1.414 3 1.732 4 2.000 5 2.236

18. Convierta cada una de las siguientes fórmulas matemáticas en expresiones de C++:



108

3x 3x + y x + y 3x + y 7 z + 2 ___

x2y/2/c √x/y x ≠ y 2!r

19. ¿Qué salida producen las siguientes líneas de programa incorporadas en un programa correcto que declara todas las variables como de tipo char?

a = ´b´; b = ´c´; c = a; Cout << a << b << c << ´c´

20. ¿Qué salida producen las siguientes líneas de programa (incorporadas en un

programa correcto que declara cifra como de tipo int)?

cifra = (1/3) * 3; Cout << “(1/3) * 3 es igual a “ << cifra;

21. Escriba un programa completo en C++ que lea dos números enteros y los coloque

en dos variables de tipo int, y luego despliegue tanto la parte entera como el residuo cuando el primer número se divida entre el segundo. Esto puede hacerse usando los operadores / y %.

22. Dado el siguiente fragmento que supuestamente convierte temperaturas de grados

celsius a grados Fahrenheit, conteste las siguientes preguntas

double c = 20; double f; f = (9/5) * c + 32.0;

a. ¿Qué valor se asigna a f? b. Explique qué está sucediendo realmente, y qué es lo que el programador

probablemente quería. c. Reescriba el código para que haga lo que el programador quería.

23. Escriba un algoritmo que escriba la palabra Alto si el valor de la variable puntaje

es mayor que 100, y Bajo si el valor de puntaje es 100 o menos. La variable puntaje es de tipo int.

Programar en C++.

24. Suponga que ahorros y gastos son variables de tipo double a las que se les ha

dado valores. Escriba una instrucción if_else que despliegue la palabra Solvente, reste al valor de ahorros el valor de gastos, y asigne cero a gastos, siempre que ahorros sea mayor o igual que gastos. En cambio, si ahorros es menor que



109

gastos, la instrucción if_else debe desplegar las palabras En quiebra, y no deberá modificar el valor de ninguna variable.

25. Escriba un algoritmo que despliegue la palabra Aprobado si el valor de la variable

examen es mayor o igual que 3.0 y además el valor de la palabra programas_hechos es mayor o igual que 10. De lo contrario, el algoritmo deberá desplegar la palabra Reprobado. Las variables examen y programas_hechos son de tipo int. Programar en C++.

26. Escriba un algoritmo que despliegue la palabra Advertencia si el valor de la

variable temperatura es mayor o igual que 100, o bien si el valor de la variable presion es mayor o igual que 200, o ambas cosas. De lo contrario, el algoritmo deberá desplegar la palabra Normal. La variable temperatura y presion son de tipo int. Programar en C++.

27. Considere una expresion cuadrática, como

X2 – X – 2 Para describir dónde es positiva esta expresión (es decir, mayor que 0), hay que describir un cojunto de números que sean menores que la raiz más pequeña (que es –1), o bien, mayores que la raíz más grande (que es +2). Escriba una expresión booleana en C++ que sea verdadera cuando esta fórmula tenga valores positivos. Programar en C++.

28. Considere la expresion cuadrática

X2 – 4X + 3

Para describir dónde es negativa está expresión, hay que describir un cojunto de números que sean simultáneamente mayores que la raiz más pequeña (+1) y menores que la raiz más grande (+3). Escriba una expresion booleana en C++ que sea verdadera cuando el valor de esta expresión sea negativo.

29. ¿Qué despliegan las siguientes instrucciones cout incrustadas en instrucciones

if_else? Explique la respuesta.

if(0) cout<<” 0 es verdadero”; else cout<<”0 es Falso”; cout<<endl;

if(1) cout<<” 1 es verdadero”; else cout<<”1 es falso”; cout<<endl;



110

if(-1) cout<<”-1 es verdadera”; else cout<<”-1 es falso”; cout<<endl;

30. ¿Que salida produce el siguiente código (incrustado en un programa correcto en el

que x se declara como de tipo int)

X = 10; while (X > 0) { cout<< X <<endl; X = X – 3; }

31. ¿Qué salida se produciría en el ejercicio anterior si el signo > se sustituyera por <

32. ¿ Que salida produce el siguiente código (incrustado en un programa correcto en el que X se declara como de tipo int)

X = 10; do { cout<< X<<endl; X= X-3; } while(X> 0);

33. ¿Qué salida produce el siguiente código(incrustado en un programa correcto en el

que X se declara como de tipo int

X=-42; do { cout<< X<<endl; X=X-3; }while(X>0);

34. ¿Cúal es la diferencia más importante entre una instrucción while y una do-while

35. ¿Qué salida produce el siguiente código (incrustado en un programa correcto en el

que X se declara como de tipo int)

X= 10; while (X >0) { cout<< X <<endl; X = X + 3; }



111

36. Haga un programa en C** que lea tres nombres completos(apellidos nombres) y

los muestre en orden alfabético. 37. Haga un programa que encuentre el seno, coseno, arco seno, tangente y

cotangente de un conjunto de ángulos.

38. Hacer un programa que lea un conjunto de letras: si la letra es minúscula la debe convertir a mayúscula y si es minúscula la debe convertir a mayúscula.

39. Elabore un programa que lea un conjunto de caracteres y diga si el carácter es:

una letra, un número u otro símbolo. 40. Pase el siguiente algoritmo a C++.

INICIO

LEA: N MITAD=N/2 I=2 SW=”SI” MIENTAS (I <=MITAD) ∧ (SW=”SI”) HAGA

SI ( N%I=0) SW=”NO” SINO I=I+1 FIN_SI

FIN_SI SI (SW=”SI”)

ESCRIBA: N,”SI ES” SINO

ESCRIBA:N,”NO ES” FIN_INICIO

41. ¿Qué hacen los siguientes programas?

#include <iostream.h> //Reconoce el procedimiento de entrada (flujo) cin #include <conio.h> //Reconoce el comando getch main() { float r; /*Se define el tipo de dato_entrada*/ float ac,lc; /*Se define el tipo de dato_salida*/ cout<<"Ingrese el valor del radio (r): ";cin>>r; ac=3.141592*r*r; lc=2*3.141592*r; cout<<at<<” ”<<lc; getch(); } /* otra forma:



112

cout<<"El area del circulo de radio "<<r<" es: "<<ac; cout<<"La longitud de la circunferencia de radio "<<r<" es: "<<lc; getch(); */

#include <iostream.h> #include <conio.h> #include <math.h> //Reconoce la raíz mediante la función "sqrt" main() { float a,b,c; /*Se define el tipo de dato_entrada*/ float p,at; /*Se define el tipo de dato_salida*/ cout<<"Ingrese el valor del lado a: ";cin>>a; cout<<"Ingrese el valor del lado b: ";cin>>b; cout<<"Ingrese el valor del lado c: ";cin>>c; p=(a+b+c)/2.0; at=sqrt(p*(p-a)*(p-b)*(p-c)); cout<<at; getch(); } /* otra forma: cout<<"El area del triangulo de lados "<<a<<", "<<b<<", "<<c<<" es: "<<at; getch(); */

#include <iostream.h> #include <conio.h> #include <math.h> //Reconoce exp(X), se refiere a "e a la X" main() { float t; double x,y,z; cout<<"Ingrese el valor de t: ";cin>>t; x=pow(t,3)-8*t+4; y=sin(t)+cos(2*t); z=exp(3*t+7); cout<<"El valor de x es: "<<x; cout<<"\nEl valor de y es: "<<y; /*"\n" se utiliza para saltar a otra linea*/ cout<<"\nEL valor de z es: "<<z; getch(); }



113

# include <iostream.h> # include <conio.h> void main() { clrscr(); int S; float R; const float pi=3.141592; cout<<"Ingrese cantidad en grados sexagesimales: "; cin>>S; R=S*pi/180; cout<<"\nSu medida en radianes es: "<<R; getch(); } # include <iostream.h> # include <conio.h> void main() {

clrscr(); int C; float F; cout<<"Ingrese cantidad en grados centigrados: "; cin>>C; F=9*C/5.0+32; cout<<"\nSu medida en grados Farenheit es: "<<F; getch();

} # include <iostream.h> # include <math.h> # include <conio.h> void main() {

clrscr(); int x,y; float radio,theta; cout<<"Ingrese coordenadas rectangulares del punto: "; cin>>x>>y; radio=sqrt(x*x+pow(y,2)); theta=atan(y/x); cout<<"\nSus coordenadas polares son: "<<"\tRadio = "<<radio; cout<<"\tAngulo = "<<theta; getch();

}



114

#include <iostream.h> #include <conio.h> #include <math.h> //Reconoce la raiz "sqrt" main() {

float a,b,c; /*Se define el tipo de dato_entrada*/ float p,at,r; /*Se define el tipo de dato_salida*/ cout<<"Ingrese el valor del lado a: ";cin>>a; cout<<"Ingrese el valor del lado b: ";cin>>b; cout<<"Ingrese el valor del lado c: ";cin>>c; p=(a+b+c)/2.0; r=p*(p-a)*(p-b)*(p-c); if (r>=0) {at=sqrt(r); cout<<at;} else {cout<<"No existe tal triangulo...!";} getch();

} #include <iostream.h> #include <conio.h> main() {

int a,b,temp; cout<<"Ingrese un numero: ";cin>>a; cout<<"Ingrese un segundo numero: ";cin>>b; if (a>b) {temp=a; a=b; b=temp;} cout<<"Ordenando "<<a<<" y "<<b<<" de menor a mayor seria: "<<a<<" , "<<b<<""; getch();

} #include <iostream.h> #include <conio.h> main() {

int a,b,c,max,min,temp; cout<<"Ingrese un numero: ";cin>>a; cout<<"Ingrese un segundo numero: ";cin>>b; cout<<"Ingrese un tercer numero: ";cin>>c; max=a; min=a; if max<b max=b: if max<c max=c; if min>b min=c;



115

if min>c min=c; temp=(a+b+c)-(max+min); cout<<"Ordenando "<<a<<" , "<<b<<" y "<<c<<" de menor a mayor seria:"; cout<<"\n"<<min<<" , "<<temp<<" , "<<max<<""; getch();

} #include <iostream.h> #include <conio.h> #include <ctype.h> void main() {

int i; long x,y,suma=0; clrscr(); i=0; cout<<"Los elementos de la serie son: \n"; while (i<=143) {

x=3+2*i; y=-2+3*i; i=i+1; if (i%7==0) { cout<<"\n"<<x<<", "<<y<<", "; } else { cout<<x<<", "<<y<<", "; suma=suma+x+y; }

} cout<<"\nLa suma de todos sus elementos es: "<<suma; getch();

} # include <iostream.h> # include <conio.h> # include <ctype.h> void main() { int n2,n3,n5; long N,M; char Rpta; clrscr(); do {

cout<<"Ingrese numero: "; cin>>N; M=N; n2=0; n3=0; n5=0; while (M%2==0) {n2=n2+1; M=M/2;} while (M%3==0) {n3=n3+1; M=M/3;} while (M%5==0) {n5=n5+1; M=M/5;}



116

cout<<"\nLas potencias del numero para los factores 2, 3 y 5 son: "; cout<<"\n"<<n2<<", "<<n3<<" y "<<n5<<" respectivamente"; cout<<"\n\nDesea continuar (S/N)? "; cin>>Rpta;

} while (toupper(Rpta)!='N'); getch(); } # include <iostream.h> # include <conio.h> # include <ctype.h> # include <math.h> void main() { int R,k,max,min; long int N,M,suma,suma1,inv; float prom,desv;

char Rpta; clrscr(); max=0; min=9; do { cout<<"Ingrese numero: "; cin>>N; M=N; inv=0; k=0; suma=0; while (M>0) { R=M%10; inv=inv*10+R; M=M/10; if (R>max) max=R; if (R<min) min=R; suma=suma+R; suma1=suma1+R*R; k++; }

prom=suma*1.0/k; desv=sqrt(suma1*1.0/k-pow(prom,2));

cout<<"\nEl mayor numero es :"<<max; cout<<"\nEl menor numero es :"<<min; cout<<"\nEl numero tiene "<<k<<" cifras"; cout<<"\nEl promedio de las cifras del numero es "<<prom<<"\n"; cout<<"\nLa desviacion estandar de las cifras del numero es <<desv<<"\n";

cout<<"\n\nDesea continuar (S/N)? "; cin>>Rpta; } while (toupper(Rpta)!='N'); getch();

}



117

# include <iostream.h> # include <conio.h> # include <ctype.h> void main() { int R,k; long N,M,inv; char Rpta; clrscr(); do { cout<<"Ingrese numero: "; cin>>N; M=N; inv=0; k=0; while (M>0) { R=M%10; M=M/10; if (R%2!=0) R=R-1; inv=inv*10+R; k++; } M=inv; inv=0; while (M>0) { R=M%10; M=M/10; inv=inv*10+R; } cout<<"\nEl nuevo numero formado es :"<<inv; cout<<"\nEl numero tiene "<<k<<" cifras"; cout<<"\n\nDesea continuar (S/N)? "; cin>>Rpta; } while (toupper(Rpta)!='N'); getch(); } # include <iostream.h> # include <conio.h> # include <ctype.h> void main() { int i,n1,n2,n3,n4,N,Dato; long suma; float prom; char Rpta; clrscr(); do { cout<<"Ingrese numero de datos: "; cin>>N; i=1; n1=0; n2=0; n3=0; n4=0; suma=0; while (i<=N)



118

{ cin>>Dato; suma=suma+Dato; if (Dato<=8) n1=n1+1; if (Dato<=13 && Dato>8) n2=n2+1; if (Dato<=17 && Dato>13) n3=n3+1; if (Dato>17) n4=n4+1; i=i+1; } prom=suma/(i-1); cout<<"\nLa Tabla de frecuencias para los datos es: "; cout<<"\n[00 - 08] "<<n1; cout<<"\n<08 - 13] "<<n2; cout<<"\n<13 - 17] "<<n3; cout<<"\n<17 - 20] "<<n4; cout<<"\n\nDesea continuar (S/N)? "; cin>>Rpta; } while (toupper(Rpta)!='N'); getch(); } #include <iostream.h> #include <conio.h> void main() { int anno, i; clrscr(); i=3; while(anno!=0) { gotoxy(3,i); cout<<"Ingrese el año (0 para terminar): "; cin>>anno; gotoxy(3,i+1); if (((anno%4)==0 && (anno%100!=0)) || (anno%400==0)) cout<<"El año dado es Bisiesto\n"; else cout<<"El año dado No es Bisiesto\n"<<"\n"; i=i+2; } getch(); }



119

#include <iostream.h> #include <conio.h> #include <math.h> #include <ctype.h> void main() { int N,i; double Dato,Suma=0,Suma1=0,Media,Varianza,Rango; char Rpta; clrscr(); do { cout<<"Ingrese cantidad de datos: "; cin>>N; cout<<"\nIngreso de datos\n"; cout<<"Dato 1: "; cin>>Dato; Suma=Suma+Dato; Suma1=Suma1+pow(Dato,2); float Mayor, Menor; Mayor=Dato; Menor=Dato; for (i=2; i<=N; i++) { cout<<"\nDato "<<i<<": "; cin>>Dato; Suma=Suma+Dato; Suma1=Suma1+pow(Dato,2); if (Dato<Menor) Menor=Dato; if (Dato>Mayor) Mayor=Dato; } Media=(Suma/N); Varianza=Suma1-pow(Media,2); Rango=Mayor-Menor; cout<<"\n\nLas estadisticas para el conjunto de valores dado son:"; cout<<"\nMedia = "<<Media<<" Varianza = "<<Varianza<<" Rango = "<<Rango; cout<<"\n\nDesea continuar (S/N): "; cin>>Rpta; } while (Rpta != 'N' && Rpta != 'n' ); getch(); } #include <iostream.h> #include <conio.h> #include <math.h> void main() { long int Num,n,Inv; int digmenor,digmayor,digito,K; char Rpta;

do { digmenor=9; digmayor=0; cout<<"Ingrese un numero entero: ";cin>>Num; n=Num; Inv=0; K=0;



120

cout<<"\nLos digitos del numero dado son: "; do { digito=fmod(n,10); cout<<digito<<" "; if (digito<digmenor) { digmenor=digito; } if (digito>digmayor) { digmayor=digito; } n=(n-digito)/10; //N=N/10; Inv=Inv*10+digito; K=K+1; } while (n>0); cout<<"\nEl digito menor es "<<digmenor<<" y el mayor es "<<digmayor<<""; if (Num==Inv) cout<<"\nEl numero dado ES CAPICUA"; else cout<<"\nEl numero dado NO ES CAPICUA"; cout<<"\nEl numero tiene "<<K<<" digitos"; cout<<"\n\nDesea continuar (S/N): "; cin>>Rpta;} while (Rpta != 'N' && Rpta != 'n' ); getch();

}

#include <iostream.h> #include <conio.h> #include <math.h> #include <ctype.h> void main() { int N,i; float x0,y0,a,b,c,d,dx,x,y,fx,fy,U,L; char Rpta; clrscr(); do { cout<<"Ingrese Numero de particiones: "; cin>>N; cout<<"\nIngrese limites de la integral: "; cin>>x0>>y0; cout<<"\nIngrese coeficientes del polinomio: "; cin>>a>>b>>c>>d; dx=(y0-x0)/N; U=0; L=0; for (i=0; i<=N; i++) { x=x0+i*dx; y=x0+(i+1)*dx; fx=a*pow(x,3)+b*pow(x,2)+c*x+d; fy=a*pow(y,3)+b*pow(y,2)+c*y+d; if (fx<=fy) {U=U+fy; L=L+fx;}



121

else {U=U+fx; L=L+fy;} } float Integral=(U+L)/2; cout<<"\nEl valor aproximado de la integral es: "<<Integral; cout<<"\n\nDesea continuar (S/N): "; cin>>Rpta; } while (Rpta != 'N' && Rpta != 'n' ); getch();

}

#include <iostream.h> #include <conio.h> void main() {

int N, i; long int factorial; clrscr(); gotoxy(1,2); cout<<"Ingrese número entero (0 para terminar) "; cin>>N; while(N!=0) {factorial=1; for (i=1; i<=N; i++) factorial=factorial*i; cout<<"El factorial de "<<N<<" es "<<factorial; cout<<"\nIngrese número entero (0 para terminar) "; cin>>N; }; getch();

} #include <iostream.h> #include <conio.h> void main() {

int N, i; long int pen, ult, suma,aux; clrscr(); gotoxy(2,2); cout<<"Ingrese número de términos para la Serie de Fibonacci (menor que 35) "; cin>>N; pen=0; ult=1; //Condiciones iniciales i=2; suma=pen+ult; cout<<"\n\nLos primeros "<<N<<" términos de la serie de Fibonacci son:\n";



122

cout<<pen<<" "<<ult<<" "; for (i=3; i<=N; i++) { aux=pen+ult; pen=ult; ult=aux; suma=suma+ult; cout<<ult<<" "; } cout<<"\n\nLa suma de los primeros "<<N<<" términos de la Serie de Fibonacci es:\n"; cout<<suma; getch();

} #include <iostream.h> #include <conio.h> void main() {

int N,i, j; clrscr(); gotoxy(3,2); cout<<"Ingrese número de estudiantes: "; cin>>N; cout<<"\n"; int nota[100], temp; for (i=1;i<=N;i++) { gotoxy(3,i+3); cout<<"Ingrese nota del estudiante "<<i<<" "; cin>>nota[i]; } //Ordenamiento de las notas for (i=1;i<=N-1;i++) for (j=i+1;j<=N;j++) if (nota[i]>nota[j]) {

temp=nota[i]; nota[i]=nota[j]; nota[j]=temp;

} clrscr(); gotoxy(3,2); int k=4; cout<<"Las notas ordenadas en forma ascendente son:"; for (i=1;i<=N;i++)

if (i<=18) {

gotoxy(4*i,k); cout<<nota[i]; } else if (i<=36) {



123

gotoxy(4*(i-18),k+1); cout<<nota[i]; } else if (i<=54) { gotoxy(4*(i-36),k+2); cout<<nota[i]; }

cout<<"\n"; cout<<"\n"; if (N%2==0) { j=N/2; cout<<" La mediana de las notas es: "<<nota[j]; } else { j=(N+1)/2; cout<<" La mediana de las notas es: "<<nota[j]; } getch();

} #include <iostream.h> #include <conio.h> void main() { int M, N, i, j, k; clrscr(); //Ingreso de datos gotoxy(2,2); cout<<"Ingrese número de elementos del primer vector: "; cin>>M; cout<<"\nIngrese número de elementos del segundo vector: "; cin>>N; double A[100], B[100], C[100]; for (i=1; i<=M; i++) { gotoxy(3,i+4); cout<<"Ingrese elemento "<<i<<" del primer vector: "; cin>>A[i]; cout<<"\n"; } clrscr(); for (j=1; j<=N; j++) { gotoxy(3,j+2); cout<<"Ingrese elemento "<<j<<" del segundo vector: "; cin>>B[j]; cout<<"\n"; } k=0; for (i=1; i<=M; i++) for (j=1; j<=N; j++)



124

if (A[i]==B[j]) { k++; C[k]=A[i]; } clrscr(); if (k>0) { cout<<"El vector intersección de los vectores A y B es:\n"; for (i=1; i<=k; i++) { gotoxy(4*i+1,3); cout<<C[i]; } } getch(); } #include <iostream.h> #include <conio.h> main() { int N, i, nota[100], A, B, C, D; clrscr(); cout<<"Ingrese cantidad de notas N="; cin>>N; A=0; B=0; C=0; D=0; cout<<"\nIngrese las notas\n"; for (i=1; i<=N; i++) { cin>>nota[i]; if (nota[i]<=7) A++; else if (nota[i]<=11) B++; else if (nota[i]<=16) C++; else D++; } cout<<"\n\Histograma de frecuencias\n"; cout<<"A=[01,07] "<<A<<" "; for (i=1; i<=A; i++) cout<<"*"; cout<<"\n"; cout<<"B=[08,11] "<<B<<" "; for (i=1; i<=B; i++) cout<<"*"; cout<<"\n"; cout<<"C=[12,16] "<<C<<" "; for (i=1; i<=C; i++) cout<<"*"; cout<<"\n"; cout<<"D=[17,20] "<<D<<" "; for (i=1; i<=D; i++) cout<<"*"; cout<<"\n"; cout<<"\n"; getch(); }



125

#include <iostream.h> #include <conio.h> main() { int M, N, i, j, Fmax, Cmax, Fmin, Cmin; float A[100][100], Mayor, Menor; clrscr(); cout<<"Ingrese orden de la matriz (M,N) "; cin>>M>>N; cout<<"\nElementos de la matriz"; for (i=1; i<=M; i++) //Proceso de ingreso de elementos de la Matriz { cout<<"\nIngrese elementos de la fila "<<i<<"\n"; for (j=1; j<=N; j++) cin>>A[i][j]; } Mayor=A[1][1]; Menor=A[1][1]; for (i=1; i<=M; i++) for (j=1; j<=N; j++) { if (A[i][j]>Mayor) { Mayor=A[i][j]; Fmax=i; Cmax=j; } if (A[i][j]<Menor) { Menor=A[i][j]; Fmin=i; Cmin=j; } } cout<<"\n\nEl mayor elemento de la matriz es: "<<Mayor; cout<<"\nubicado en la fila "<<Fmax<<" y columna "<<Cmax; cout<<"\n\nEl menor elemento de la matriz es: "<<Menor; cout<<"\nubicado en la fila "<<Fmin<<" y columna "<<Cmin; getch(); }

EEESSSTTTRRRAAATTTEEEGGGIIIAAASSS MMMEEETTTOOODDDOOOLLLÓÓÓGGGIIICCCAAASSS

� Presentación de la unidad a cargo del profesor. � Actividades desarrolladas en sala.



126

RRREEECCCUUURRRSSSOOOSSS

� Humanos: Profesor y alumnos � Institucionales: Sala de computo � Materiales: Texto guía

IIINNNDDDIIICCCAAADDDOOORRREEESSS DDDEEE EEEVVVAAALLLUUUAAACCCIIIÓÓÓNNN

� Evaluación de las actividades desarrollas en sala.

CCCRRRIIITTTEEERRRIIIOOOSSS DDDEEE EEEVVVAAALLLUUUAAACCCIIIÓÓÓNNN

� ¿Qúe es el lenguaje C++? � ¿Cúal es la estructura básica de un programa en C++? � ¿Cúales son los tipos de datos manejados en el lenguaje C++? �

Modulo C++

Documents

Transcript of Modulo C++