Modulo C++

Área de programación - Grado 10 Lenguaje C++
______________________________________________________________________________
Politécnico Colombiano Jaime Isaza Cadavid – Facultad de Ingenierías 1

______________________________________________________________________________
PLAN DE TRABAJO
IINNTTRROODDUUCCCCIIÓÓNN
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.
O
OBBJJEETTIIVVOO G
GEENNEERRAALL
Conocer la sintaxis básica del lenguaje C++,

______________________________________________________________________________
O
OBBJJEETTIIVVOOSS E
ESSPPEECCÍÍFFIICCOOSS
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++
IINNTTEEGGRRAACCIIÓÓNN DDEELL M
MÓÓD
DUULLO
O PPO
ORRU
UNNIIDDAADDEESS
• 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).

______________________________________________________________________________
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++

______________________________________________________________________________
LENGUAJE C++
Esta unidad busca que el estudiante distinga los conceptos básicos involucrados en el
lenguaje de programación C++
JJUUSSTTIIFFIICCAACCIIÓÓNN
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.
O
OBBJJEETTIIVVOO G
GEENNEERRAALL
Proporcionar los conocimientos que permitan al estudiante reconocer los conceptos

básicos en el manejo del lenguaje C++.

______________________________________________________________________________
O
OBBJJEETTIIVVOOSS E
• 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
C
COONNTTEENNIIDDOO
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

______________________________________________________________________________
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
E
ESSTTRRUUCCTTUURRAA DDEE UUNN PPRROOGGRRAAM
MA NC
A EEN C++++
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

______________________________________________________________________________
(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

______________________________________________________________________________
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

______________________________________________________________________________
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).
A
ACCTTIIVVIIDDAADD…
…
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:
LLEENNGGUUAAJJEE DDEE PPRROOGGRRAAM

MAAC
CIIÓ
ÓNNE
ESSTTRRUUCCTTUURRAADDOO C
C
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:

______________________________________________________________________________
S
SIINNTTAAXXIISS DDEE AALLGGUUNNOOSS EELLEEM
MEEN
NTTO
OSS D
DEE U
UNN PPR
ROOG
GRRA
AMMA NC
A EEN C
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
2c
• 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 */

______________________________________________________________________________
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
/  % ^ & * () - + {} [] \ ; : <> ¿ .

______________________________________________________________________________
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.

______________________________________________________________________________
Ejemplo:
b = c + d; d = 2*k;
TTIIPPOOSS DDEE DDAATTOOSS EENN C

C
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

______________________________________________________________________________
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;
}

______________________________________________________________________________
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.
TTIIPPOOSS DDEE V
VAARRIIAABBLLEESS
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:

______________________________________________________________________________
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

______________________________________________________________________________
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

______________________________________________________________________________
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á

______________________________________________________________________________
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 VALOR ASCII

(DECIMAL) (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.

______________________________________________________________________________
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;
C
COONNSSTTAANNTTEESS
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

______________________________________________________________________________
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
E
ENNTTRRAADDAA // S
SAALLIIDDAA
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.
S
SAALLIIDDAA H
HAACCIIAA P
PAANNTTAALLLLAA [[PPRRIINNTTFF(())]]
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.

______________________________________________________________________________
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);

______________________________________________________________________________
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
S
SEECCUUEENNCCIIAASS DDEE E
ESSCCAAPPEESS
Indica que debe ejecutar algo extraordinario.
CARÁCTER EXPLICACIÓN
DE
ESCAPE
\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);
E
ENNTTRRAADDAA D
DEESSDDEE TTEECCLLAADDOO
Se realiza mediante la función scanf(), su formato es:
scanf(“Cadena de control”, Dirección y nombre de la variable);

______________________________________________________________________________
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]).

______________________________________________________________________________
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("***********************************************\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.

______________________________________________________________________________
Ejemplo:
char cadena[15];
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);
A
…
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 f
__________________________________________________________________________________
_______________________________
Escriba algunas restricciones que deben cumplir los Identificadores:

______________________________________________________________________________
__________________________________________________________________________________
¿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 q
Explique:
__________________________________________________________________________________
Ejercicios:
1. Haciendo uso de las funciones gets y puts, diseñe un programa en C, que se lea el nombre del
2. Diseñe un programa en C, que lea y muestre en pantalla el valor de tres variables de tipo Enter
3. Diseñe un programa que muestre, los diferentes tipos de datos, usados en C. Primero, debe ind
4. Diseñe un programa, en el cual se introduzcan el nombre y el peso y de un alumno, y luego la m
5. Diseñe un programe en C, en el cual después de haber introducido, una tabla de multiplicación
2x2=4
2x3=6

______________________________________________________________________________
2x4=8
..
.
2x10=20
6. Realice el siguiente ejercicio, tal como se muestra, luego ejecútalo, nuevamente, pero quitándo
#include <stdio.h>
#include <conio.h>
main()
{
char cadena[15];
printf("\n\t LA CADENA ES LA SIGUIENTE:\n\n");
printf("***********************************************\n");
printf("***********************************************\n");
getch();
return 0;
}
O
OPPEERRAADDOORREESS,, E
EXXPPRREESSIIOONNEESS
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.
O
OPPEERRAADDOORREESS
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

______________________________________________________________________________
+ 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.

______________________________________________________________________________
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("\tAHORA OBSERVAREMOS EL RESULTADO DE --X\n\n");
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;
}

______________________________________________________________________________
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;

______________________________________________________________________________
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;

______________________________________________________________________________
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.
E
EXXPPRREESSIIOONNEESS
(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

______________________________________________________________________________
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.

______________________________________________________________________________
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.
O
OBBJJEETTIIVVOO G
GEENNEERRAALL
Proporcionar los conocimientos que permitan al estudiante reconocer y aplicar las

diferentes estructuras algorítmicas implementadas en el lenguaje C++.
O
OBBJJEETTIIVVOOSS E
1. Conocer las estructuras de selección

2. Conocer las estructuras cíclicas

______________________________________________________________________________
C
COONNTTEENNIIDDOO
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
E
ESSTTRRCCTTUURRAASS S
SEECCUUEENNCCIIAALLEESS
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;

______________________________________________________________________________
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:

______________________________________________________________________________
#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;
}
E
ESSTTRRCCTTUURRAA S
SEELLEECCTTIIVVAA SSIIM
MPPLLEE
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;

______________________________________________________________________________
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;
}
E
ESSTTRRCCTTUURRAA S
SEELLEECCTTIIVVAA D
DOOBBLLEE
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:

______________________________________________________________________________
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");

______________________________________________________________________________
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;

______________________________________________________________________________
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
{
printf("La dosis de este alumno sera %.2f gramos\n\n", dosis);
}
}
else
{
if(estatura>1.50 && peso >=130)
{
printf("La dosis de esta alumna debe ser de %.2f gramos\n\n", dosis);
}
else
{
printf("La dosis de esta alumna debe ser de %.2f gramos\n\n", dosis);
}
}
getch();
return 0;
}
S
SEELLEECCCCIIÓÓNN M
MÚÚLLTTIIPPLLEE
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:

______________________________________________________________________________
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;

______________________________________________________________________________
default: puts("Dato No valido");

break;
}
getch();
return 0;
}
A
…
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.

______________________________________________________________________________
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.

______________________________________________________________________________
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;
}
C
CÍÍCCLLOOSS
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)

______________________________________________________________________________
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.
FFUUNNCCIIOONNAAM
MIIEEN
NTTO
ODDEE U
UNN C
CIICCLLOO
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.

______________________________________________________________________________
Bandera: Las variables tipo bandera son aquellas que sólo admiten dos valores: cierto o
falso, true o false, hombre o mujer... etc.
C
CIICCLLOO DDEE E
ENNTTRRAADDAA A
ASSEEGGUURRAADDAA ((W
WHHIILLEE))
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>

______________________________________________________________________________
#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);
}

______________________________________________________________________________
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;
}
C
CIICCLLOO C
COONNTTRROOLLAADDOO PPOORR CCOONNTTAADDOORR ((FFOORR))
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();

______________________________________________________________________________
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);
while(compra<0)
{
printf("ERROR, la compra debe ser mayor que cero, vuelva a
intentarlo:\n");
}
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.

______________________________________________________________________________
#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",&preciob2);
while(preciob2<0)
{
printf("ERROR\n");
}
scanf("%f",&preciob3);
while(preciob3<0)
{
printf("ERROR\n");
}
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;

______________________________________________________________________________
sum2+=boletos2;
break;
sum3+=boletos3;
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");
printf("Los Boletos que se vendieron menos fueron los boletos numero DOS\n\n");
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;
}
C
CIICCLLOO D
DOO...... W
WHHIILLEE
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.

______________________________________________________________________________
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.
A
…
¿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?

________________________________________________________________________
________________________________________________________________________
________________________________________________________________________

______________________________________________________________________________
¿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.

______________________________________________________________________________
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.

______________________________________________________________________________
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.
O
OBBJJEETTIIVVOO G
GEENNEERRAALL
Proporcionar los conocimientos que permitan al estudiante conocer y aplicar los

conceptos de funciones (subprogramas) y arreglos (Vectores y Matrices)

______________________________________________________________________________
O
OBBJJEETTIIVVOOSS E
1. Conocer la forma de implementar subprogramas o módulos

2. Conocer la forma de implementar arreglos
C
COONNTTEENNIIDDOO
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
S
SUUBBPPRROOGGRRAAM
MA OM
ASS O MÓÓDDUULLOOSS
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.

______________________________________________________________________________
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.
P
PAASSOO DDEE PPAARRÁÁM
MEETTR
ROOSS
Existen dos formas de pasar parámetros, las cuales son:

______________________________________________________________________________
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.
FFUUNNCCIIOONNEESS D
DEEFFIINNIIDDAASS P
POORR E
ELL U
USSUUAARRIIOO EENN C
C
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.

______________________________________________________________________________
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ú.
FFUUNNCCIIOONNEESS QQUUEE NNOO DDEEVVUUEELLVVEENN NNIINNGGÚÚNN VVAALLOORR..
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);

______________________________________________________________________________
} /*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)
{

______________________________________________________________________________
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("Ötro 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);
}
FFUUNNCCIIOONNEESS QQUUEE DDEEVVUUEELLVVEENN UUNN VVAALLOORR EENNTTEERROO..
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:

______________________________________________________________________________
• 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)

______________________________________________________________________________
{
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)
{

______________________________________________________________________________
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.
FFUUNNCCIIOONNEESS QQUUEE D
DEEVVUUEELLVVEENN UUNN V
VAALLOORR R
REEAALL..
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 TIPO DE PROPÓSITO

(SINTAXIS) DATO
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

______________________________________________________________________________
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/ Devuelve el cociente y el resto de la división
int
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>

______________________________________________________________________________
#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.

______________________________________________________________________________
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.;

______________________________________________________________________________
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.
FFUUNNCCIIOONNEESS EENN LLAASS QQUUEE UUSSAAM

MOOSS M
MEENNÚÚ..
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)
{

______________________________________________________________________________
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();

______________________________________________________________________________
A
…
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

______________________________________________________________________________
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.
E
ESSTTRRUUCCTTUURRAASS DDEE DDAATTOOSS ((A
ARRRREEGGLLOOSS))
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.
V
VEECCTTOORREESS
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)

______________________________________________________________________________
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;
}

______________________________________________________________________________
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).
U
USSOO DDEE V
VEECCTTOORREESS DDEENNTTRROO DDEE LLAASS FFUUNNCCIIOONNEESS
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.

______________________________________________________________________________
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;

______________________________________________________________________________
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.
M
MAATTRRIICCEESS
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

______________________________________________________________________________
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.

______________________________________________________________________________
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;

______________________________________________________________________________
}
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;
{
sum=0;
sum=sum+cuadrado[f][c];
if(sum!=consmagic)
magic=0;
}
{
sum=0;
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;

______________________________________________________________________________
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");
{
printf("*%d*", cuadrado[f][c]);
printf("\n");
}
}
A
…
¿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?
________________________________________________________________________
________________________________________________________________________
________________________________________________________________________

______________________________________________________________________________
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:

______________________________________________________________________________
INFRACCIONES A LOS LIMITES DE VELOCIDAD
Registro del Velocidad Velocidad limite Multa

vehículo registrada (MPH)
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.

______________________________________________________________________________
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.
O
OBBJJEETTIIVVOO G
GEENNEERRAALL
Proporcionar los conocimientos que permitan al estudiante conocer y aplicar los

conceptos de archivos.
O
OBBJJEETTIIVVOOSS E
1. Conocer la forma de trabajar con archivos

______________________________________________________________________________
C
COONNTTEENNIIDDOO
1. Archivos de Texto
2. Archivos binarios
3. Archivos especiales 1: la impresora
4. Archivos especiales 2: salida de errores
A
ARRCCHHIIVVOOSS DDEE TTEEXXTTOO
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

______________________________________________________________________________
“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.

______________________________________________________________________________
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");
{
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.
A
…
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.

______________________________________________________________________________
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.
A
…
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:

______________________________________________________________________________
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.
A
ARRCCHHIIVVOOSS B
BIINNAARRIIOOSS
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)

______________________________________________________________________________
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:

______________________________________________________________________________
• 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);
A
…
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);

______________________________________________________________________________
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:

______________________________________________________________________________
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 ");
}
}

______________________________________________________________________________
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 */
}
}

______________________________________________________________________________
A
…
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.
A
ARRCCHHIIVVOOSS EESSPPEECCIIAALLEESS 11:: LLAA IIM
MPPR
REESSO
ORRA
A
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).

______________________________________________________________________________
A
ARRCCHHIIVVOOSS EESSPPEECCIIAALLEESS 22:: SSAALLIIDDAA DDEE EERRRROORREESS
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");

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.

______________________________________________________________________________
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 */
temp[strlen(temp)]='\0';
printf("Titulo: %s\n",temp);
/* Luego 30 letras de autor */
temp[strlen(temp)]='\0';
printf("Artista: %s\n",temp);
/* Ahora vamos a modificar el titulo */
printf("\nIntroduce el nuevo titulo: ");
gets(temp);

______________________________________________________________________________
/* 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);
}

______________________________________________________________________________
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.
O
OBBJJEETTIIVVOO G
GEENNEERRAALL
Proporcionar los conocimientos que permitan al estudiante depurar y corregir los

posibles errores que se le presentan en la elaboración de un programa.
O
OBBJJEETTIIVVOOSS E
• Aprender a depurar un programa en C++

• Reconocer diferentes ambientes de trabajo

______________________________________________________________________________
C
COONNTTEENNIIDDOO
1. Conceptos básicos sobre depuración

2. Ejemplos de algunos entornos
C
COONNCCEEPPTTOOSS BBÁÁSSIICCOOSS SSOOBBRREE DDEEPPUURRAACCIIÓÓNN
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.
E
EJJEEM
MPPLLO
OSS D
DEE A
ALLG
GUUN
NOOSS EEN
NTTO
ORRN
NOOSS
Turbo C es un compilador antiguo, pero sencillo de manejar, y la depuración también es

sencilla con él:

______________________________________________________________________________
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.

______________________________________________________________________________
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++.

______________________________________________________________________________
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.

______________________________________________________________________________
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.
O
OBBJJEETTIIVVOO G
GEENNEERRAALL
Proporcionar una serie de ejercicios que permitan al estudiante afianzar sus

conocimientos.
O
OBBJJEETTIIVVOOSS E
• Resolver los ejercicios propuestos

______________________________________________________________________________
C
COONNTTEENNIIDDOO
1. Ejercicios varios
E
EJJEERRCCIICCIIOOSS VVAARRIIOOSS
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?

______________________________________________________________________________
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++:

______________________________________________________________________________
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 = a;
Cout << a << b << 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

______________________________________________________________________________
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;

______________________________________________________________________________
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;
}

______________________________________________________________________________
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:

______________________________________________________________________________
cout<<"El area del circulo de radio "<<r<" es: "<<ac;

cout<<"La longitud de la circunferencia de radio "<<r<" es: "<<lc;
getch();
*/
#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 <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();
}

______________________________________________________________________________
# 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 <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 <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();
}

______________________________________________________________________________
#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 <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 <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;

______________________________________________________________________________
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 <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 <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;}

______________________________________________________________________________
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 <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 {
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";
}
getch();
}

______________________________________________________________________________
# include <conio.h>
# include <ctype.h>
void main()
{
int R,k; long N,M,inv;
char Rpta;
clrscr();
do
{
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";
}
getch();
}
# 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)

______________________________________________________________________________
{
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;
}
getch();
}
#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();
}

______________________________________________________________________________
#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 <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;

______________________________________________________________________________
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;}
getch();
}
#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;}

______________________________________________________________________________
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;
}
getch();
}
#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 <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";

______________________________________________________________________________
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 <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)
{

______________________________________________________________________________
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 <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++)

______________________________________________________________________________
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 <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();
}

______________________________________________________________________________
#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();
}
E
ESSTTRRAATTEEGGIIAASS M
MEETTOODDOOLLÓÓGGIICCAASS
Presentación de la unidad a cargo del profesor.

Actividades desarrolladas en sala.

______________________________________________________________________________
R
REECCUURRSSOOSS
Humanos: Profesor y alumnos

Institucionales: Sala de computo
Materiales: Texto guía
IINNDDIICCAADDOORREESS DDEE E
EVVAALLUUAACCIIÓÓNN
Evaluación de las actividades desarrollas en sala.
C
CRRIITTEERRIIOOSS DDEE E
EVVAALLUUAACCIIÓÓNN
¿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++

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Modulo C++

Uploaded by

Copyright:

Available Formats

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

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

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

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

1. Identificar las estructura básica de un programa en C++

• Unidad 1: Concepto Básicos

• Unidad 2: Estructuras (secuenciales, selectivas, múltiples) y Ciclos

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

o Ciclo Do... while

• Unidad 3: Subprogramas o Módulos, Estructuras de Datos (Arreglos)

• Unidad 4: Manejo de archivos

• Unidad 5: Cómo depurar los programas

• Unidad 6: Ejercicios de C++

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

Es común leer que se lo caracteriza como un lenguaje de "bajo nivel". No debe

Esta particularidad, junto con el hecho de no poseer operaciones de entrada-salida,

Proporcionar los conocimientos que permitan al estudiante reconocer los conceptos

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

• Identificar las estructura básica de un programa en C++

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

Es común leer que se lo caracteriza como un lenguaje de "bajo nivel". No debe

Esta particularidad, junto con el hecho de no poseer operaciones de entrada-salida,

Este lenguaje presenta varias características, entre las cuales están:

1. Lenguaje de programación de propósitos generales

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

ERRORES DE EJECUCIÓN: Estos errores se producen, cuando le indicamos a la

ERRORES DE LÓGICA: Muchas veces, cuando estamos programando, el compilador no

La estructura de un programa en C, consta de algunas partes esenciales: las cuales son

Cada función debe contener:

• Directivas de pre-procesador (instrucciones que se le dan al compilador antes de

Lo que se le esta indicando, es que de las librerías, “Incluya” en nuestro programa la

Si necesitamos las funciones de cadenas:

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

Función Principal main()

Programa que a partir del radio, calcula el área de un círculo

Luego, le indicamos a nuestro programa el inicio de nuestro programa (función main()).

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

• Utilizar una variable antes de asignarle un valor: _______________________

• Asignarle un valor real a una variable declarada como entero: ____________

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

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

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

LLEENNGGUUAAJJEE DDEE PPRROOGGRRAAM

Si el lector recuerda, en el apartado anterior, se hablaba de las características del

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

• Pueden tener de 1 hasta un máximo de 31 caracteres

float char while

Estas palabras no pueden ser utilizadas para identificar variables, constantes,

El formato de los comentarios en C, es el siguiente:

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

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

En C existen diferentes tipos de variables, entre ellas tenemos:

• Constates Numéricas: Son valores numéricos, enteros o de reales (de punto

Esta directiva (#define) va, inmediatamente después de los #include. Se escribe la

Signos de Puntuación y de Separación

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

Todas las Instrucciones o sentencias del programa terminan con un

NOTA: el lector no debe confundirse, las directivas: #include, #define. Main(), no

Recordemos el ejemplo anterior, y veamos que al final de cada sentencia lleva su

Todo Bloque de Instrucciones debe ir entre llaves

En una línea se pueden escribir más de una instrucción separada por

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

TTIIPPOOSS DDEE DDAATTOOSS EENN C

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