Este documento presenta los conceptos básicos de los sistemas de procesamiento de datos y la programación. Explica conceptos como programa, programador, lenguajes de programación, hardware y software. Describe la ejecución de un programa, incluyendo la entrada, proceso y salida. También introduce los pasos para la solución de problemas computacionales, como la definición del problema, análisis de la solución, diseño, codificación, pruebas y documentación. Finalmente, explica los tipos de errores como sintácticos, lógicos

1. Capítulo 1
Sistemas de Procesamiento
de Datos
1.1 Conceptos de la programación
1.1.1 Programa
1.1.2 Programación
1.1.3 Programador/Desarrollador
1.1.4 Sistema
1.1.5 Sistema de Información
1.1.6 Dato
1.1.7 Información
1.1.8 Software
1.1.9 Hardware
1.2 Ejecución de un programa
1.2.1 Representación sencilla de la ejecución de un programa
1.3 Lenguajes de Programación
1.4 Evolución los lenguajes de Programación
1.4.1 Lenguajes de Alto nivel
1.4.2 Lenguajes de bajo nivel
1.5 Tipos de lenguajes de programación
1.5.1 En función de la forma de programar
1.5.2 Orientados al problema
1.5.3 Según su campo de aplicación

2. 1 Sistemas de Procesamiento de Datos
Introducción
Es el conjunto de métodos y procedimientos que permiten obtener información.
A continuación se mencionan conceptos que será fundamental que el lector conozca:
1.1 Conceptos de los sistemas de computación
1.1.1 Programa
Es el conjunto de instrucciones que una computadora ha de seguir. Estas instrucciones son escritas en
un lenguaje de programación que la computadora es capaz de interpretar.
1.1.2 Programación
Es aquella actividad por la cual se crean programas para computadoras.
1.1.3 Programador/Desarrollador
Individuo que ejerce la programación, es decir escribe programas para computadoras.
1.1.4 Sistema
Es un conjunto de elementos interrelacionados entre sí, interactuando con un objetivo en común.
1.1.5 Sistema de Información
Es el conjunto de procedimientos ordenados que al ser ejecutados proporcionan información para
apoyar la Toma de Decisiones y el control de una organización.

3. 1.1.6 Dato
Representa observaciones o hechos fuera de contexto y sin significado inmediato (Es materia prima de
la información).
1.1.7 Información
Es el significado que una persona asigna a un dato (conjunto de datos).En otras palabras es el
resultado o salida que emite un programa o sistema de información.
1.1.8 Software
Serie de programas que la computadora utiliza con un fin en especial.
1.1.9 Hardware
Son las maquinas físicas reales que constituyen una instalación de cómputo.
1.2 Ejecución de un programa
En la ejecución de un programa intervienen elementos de entrada y de salida que interactúan en la
computadora. Se necesita de datos de entrada ingresados desde teclado usualmente, un programa
escrito en un lenguaje de programación, una computadora que mostrara los resultados y/o salida
usualmente por pantalla.
1.2.1 Representación sencilla de la ejecución de un programa
Entrada (INPUT) Proceso Salida (OUTPUT)
Programa
-------------
-------------
Salida
-------------
--------------
---- Computadora
--------------
Datos --------------
-------------
-------------
-------------

4. 1.3 Lenguajes de Programación
Definición
Es un conjunto de reglas semánticas así como sintácticas que los programadores usan para la
codificación de instrucciones de un programa o algoritmo de programación.
1.4 Evolución los lenguajes de Programación
Es el desarrollo y mejoramiento de los lenguajes de programación a través de la historia, se
categorizan en:
1.4.1 Lenguajes de Alto nivel
4to nivel: Llamados también generador de aplicaciones Son en esencia programas para crear
programas, por ejemplo herramientas CASE, GENEXUS Tool, PowerDesigner, etc.
3er nivel: Es el nivel de lenguaje más parecido al lenguaje del ser humano, con más signos y reglas
para expresar con facilidad las cosas más complicadas, entre ellos existen C++, BASIC, PASCAL, C#,
JAVA, Php, ETC
Ejm: Z=X+Y
1.4.2 Lenguajes de Bajo Nivel
2do nivel: Es el tipo de lenguaje que cualquier computadora puede entender, por ejemplo
Ensamblador.
Ejm: ADD X Y Z
1er nivel: Llamado también Lenguaje de Maquina. Son los programas escritos en forma de ceros y
unos.
Ejm
0110 1001 1010 1011

5. 1.5 Tipos de lenguajes de programación
Son las distintas formas y categorías de los lenguajes de programación, se categorizan en:
1.5.1 En función a la forma de programar
Lenguajes procedurales: FORTRAN, BASIC, PASCAL, ADA, MODULA-2
Lenguajes declarativos: LIPS, PROLOG
Orientados a objetos: C++, Java, C#
1.5.2 Orientados al problema:
Generadores de aplicaciones: GENEXUS Tool, PowerDesigner, etc.
1.5.3 Según su campo de aplicación.
Aplicaciones científicas: FORTRAN y PASCAL
Aplicaciones en procesamiento de datos: COBOL y SQL.
Aplicaciones de tratamiento de textos: C
Aplicaciones en inteligencia artificial: LISP y PROLOG
Aplicaciones de programación de sistemas: ADA, MODULA-2 y C.
Lenguajes de Internet: HTML, JAVA, Perl, PHP, ASP.NET

6. Capítulo 2
Metodología para solución
de problemas
computacionales
2.1 Pasos para la solución de problemas computacionales
2.1.1 Definición del problema
2.1.2 Análisis de la solución
2.1.3 Diseño de la solución
2.1.4 Codificación
2.1.5 Prueba y Depuración
2.1.6 Documentación
2.1.7 Mantenimiento
2.2 Tipos de errores
2.2.1 Error sintáctico de software
2.2.2 Error de lógica de programador
2.2.3 Error fatal en tiempo de ejecución
2.2.4 Error interno de software

7. 2 Metodología para solución de problemas computacionales
Introducción
Es la serie de pasos adecuados que se ha de seguir para obtener una solución completa de un
problema computacional.
2.1 Pasos para la solución de problemas computacionales
A continuación se mencionan los puntos a seguir:
2.1.1 Definición del problema
Conocer y delimitar por completo el problema, saber que es lo se desea realice la computadora.
2.1.2 Análisis de la solución
Establecer una serie de preguntas acerca de lo que establece el problema:
¿Con qué cuento? , ¿Qué hago con esos datos? , ¿Qué se espera obtener?
2.1.3 Diseño de la solución
Es la creación del algoritmo (Diagrama de flujo y/o pseudocódigo),

8. 2.1.4 Codificación
Escribir la solución del problema (de acuerdo al pseudocódigo), en una serie de instrucciones
detalladas en un código reconocible por la computadora (PROGRAMA).
En la actualidad y con algo de práctica se es posible pasar del análisis de la solución a la codificación,
en muchos casos es más rápido y permite detectar errores mediante la depuración o debug, asunto
que se haría manualmente en el pseudocódigo y/o diagrama de flujo.
2.1.5 Prueba y Depuración
La Prueba es el proceso de identificar los errores que se presenten durante la ejecución del programa.
La Depuración consiste en eliminar los errores que se hayan detectado durante la prueba.
2.1.6 Documentación
Es la guía o comunicación escrita que sirve como ayuda para usar un programa, o facilitar futuras
modificaciones.
La documentación que va a sustentar en términos legales la creación y/o modificación del programa.
Existen 3 tipos:
Documentación Interna
Consiste en los comentarios o mensajes que se agregan en el código del programa (Es la más usada),
mientras más detallado se encuentre el programa será más fácil la modificación en el futuro, además
es utilizado para controles internos dentro del área de TI.
Consta de: Nombre de modulo, Descripción del módulo, Nombre del Autor, fecha creación, fecha
modificación
Documentación Externa

9. Es el Manual Técnico (A menudo obviada), está integrada por los siguientes elementos: Descripción
del Problema, Nombre del Autor, Diagrama del Flujo, Pseudocódigo, Lista de variables y constantes, y
Codificación del Programa.
Manual del Usuario
Es la documentación (Generalmente diapositivas) que se le proporciona al usuario final, presentando
todas las pantallas y menús que se va a encontrar y una explicación de los mismos.
Es de uso indispensable cuando se va a entregar el programa al usuario final puesto que facilitara el
manejo en gran medida del programa.
2.1.7 Mantenimiento
Se realiza después de determinado el programa cuando se detecta que es necesario hacer un cambio,
ajuste y/o complementación al programa para que siga trabajando de manera correcta.
Nota: En la actualidad para un performance adecuado en el desarrollo de sistemas algunas empresas
disponen de usar un software manejador de versiones de fuentes esto favorece en gran medida el
control y feedback de los desarrollos.
2.2 Tipos de Errores
A continuación se detallan los distintos tipos y formas en que aparecen los errores, además las
recomendaciones para disminuir su aparición.
2.2.1 Error sintáctico de software

10. Son los errores conocidos como gramaticales respecto al software de lenguaje de programación que
se utiliza. Estos errores son los que se muestran en la mayoría de los casos en el programa editor de
código en tiempo de codificación.
Pueden aparecer por no teclear correctamente alguna instrucción y/o comando del lenguaje de
programación utilizado, la buena noticia de este tipo de errores son que se pueden detectar y corregir
en tiempo de codificación, El software del lenguaje de programación en muchos casos detecta los
errores automáticamente mientras se digita el código antes de ejecutar el programa.
Por ejemplo en C++ toda instrucción termina en punto y coma < ; > si obvias ponerla seguramente el
compilador te mostrara un mensaje de error al intentar ejecutar el programa.
2.2.2 Error de lógica de programador
Son los errores del desarrollador y son errores de interpretación de los procesos funcionales (A
menudo en expresiones de cálculos).
Por ejemplo le podrían pedir calcular el promedio de 2 números y por distracción suma los dos
números y los divide sobre tres, O quizás en su fórmula emplea lo siguiente: A+B / 2 y no coloca el
paréntesis para que primero sume.
Este tipo de errores no es percibido por el software editor de código ya que estos errores son
sintácticamente correctos, en consecuencia solo pueden ser percibidos en tiempo de ejecución del
programa al intentar ver el resultado o quizás mucho después.
2.2.3 Error fatal en tiempo de ejecución
Estos tipos de errores suelen mostrar el respectivo mensaje de error, y en muchos casos consiguen
hacer terminar forzosamente al programa.
Este tipo de errores son los más comunes aun cuando se alcanza a dominar la programación.
A menudo este tipo de errores son por cálculos numéricos y reglas matemáticas que no pueden ser
pasadas por alto por ejemplo si se intenta dividir un número sobre cero,

11. Otro caso general es cuando se intenta obtener un valor ya sea por teclado o de otra ubicación, y no
se valida que haya obtenido realmente el valor y se hace una expresión con la variable como si tuviera
el valor y en ese momento seguramente tendrás un error en tiempo de ejecución.
La recomendación para este tercer tipo de error es siempre validar las entradas ya sea teclado, lectura
de archivos de texto, base de datos, etc.
2.2.4 Error interno de software
No solo el desarrollador tiene errores, el software de programación utilizado algunas veces muestra
errores. En algunos casos por modificación de algún componente interno ya sea por la instalación de
algún otro software en la PC (Personal Computer) que consigue modificar el componente.
Otros casos también suceden por no refrescar el proyecto utilizado, actualmente el software de
programación cuenta con herramientas de actualización incluido. Este es nombrado de muchas
formas: refrescar, actualizar, regenerar, etc. En cualquiera de los casos es recomendable actualizar
cada cierto tiempo el proyecto de programación.
Un caso menos usual es la infección de virus que en la actualidad se corrige con un antivirus efectivo.

12. Capítulo 3
Fases de la Programación
3.1 Elementos de un programa
3.1.1 Tipos de datos en C++
3.1.2 Identificadores
3.1.3 Conceptos básicos al nombrar variables
3.1.4 Asignación de variables
3.1.5 Operadores
3.1.6 Prioridad de Operadores
3.1.7 Entrada y Salida
3.2 Manejo de Expresiones
3.2.1 Transformación de expresiones algebraicas a computacionales
3.2.2 Declaración de Variables
3.2.3 Datos Enteros vs Datos Reales
3.2. 4 Partes de la división
3.2.5 División Entera vs división real
3.2.6 Resultados de la división
3.2.7 Análisis de almacenamiento de la división con resultados numéricos
3.2.8 Residuo (Modulo)

13. 3 Fases de la Programación
Introducción
En este capítulo comenzaremos a revisar los elementos de un programa, los conceptos necesarios
para realizar un programa sencillo.
3.1 Elementos de un programa
3.1.1 Tipos de datos en C++
Son clasificadores de variables ya sea en el dato que contendrá u operaciones que se realizara sobre
ellas. A continuación se muestra una tabla con los rangos y algunas otras características de los tipos
de datos:
Tipo de datos
Rango Mínimo (*) Precisión
Descripción C++
short 32,767
int 32,767
Enteros long 2‟147,483,467
Entero sin signo unsigned long 4‟294,967,295
float 10^37 6 dígitos
double 10^37 6 dígitos
Reales long double 10^37 6 dígitos
Carácter char 127
Cadena string
Booleano bool

14. (*) EL limite considera límite inferior el mismo número con signo negativo hasta el límite superior que
es el numero mostrado, con excepción de los que llevan la palabra reservada unsigned(sin signo) en
esos casos el límite inferior es cero y el límite superior es el doble del numero mostrado.
Estos son los mínimos rangos sin embargo esto puede variar de acuerdo a la versión del compilador, a
continuación se muestra los típicos rangos para un ambiente de 32 bits:
Tipo de datos
Bytes utilizados Típico Rango(*)
Descripción C++
short 2 bytes 32,767
int 4 bytes 2‟147,483,467
Enteros long 4 bytes 2‟147,483,467
Entero sin signo unsigned long 4 bytes 2‟147,483,467
float 4 bytes 1.8^-38 a 3.4^38
double 4 bytes 2.2^-308 a 1.8^308
Reales long double 8 bytes 2.2^-308 a 1.8^308
unsigned double
Real sin signo unsigned long double
1 Byte: guarda un
char
Carácter carácter
Bytes Dinámicos, su
string
Cadena tamaño es ilimitado
Booleano bool 1 bit
Nota: Para los iniciantes los tipos de datos definidos bajo pseudocódigo se puede utilizar la descripción
de la tabla. Sin embargo para este libro se utilizara los términos de C++.
3.1.2 Identificadores
Es el nombre de una variable. Las variables se dividen en 2 tipos:
Variable: Son ubicaciones de memoria en las cuales guarda un valor, además dicho valor puede ser
cambiado a lo largo del programa.

15. Constante: Son un tipo de variable que mantiene su valor desde el principio hasta el final del
programa.
3.1.3 Conceptos básicos al nombrar variables
Se consideran las siguientes recomendaciones al nombrar variables:
 Use un nombre de variable que le dé significado al valor que va a contener.
 Es factible usar abreviaturas, parte de la palabra o concepto que va a almacenar, mnemónico
(palabra técnica) o palabra completa separada por guion bajo “_” ya sea por la complejidad de la
rutina o del problema.
 Respecto a las terminaciones con numeración pueden usarse en caso de tener variables con el
mismo nombre pero con diferentes valores de una lista.
 Se debe tener en cuenta que C++ distingue letras mayúsculas de minúsculas por lo tanto la
variable (A) es distinta de la variable (a).
 No se puede nombrar variables que tengan como nombre algún comando, palabra
reservada, tipo de dato, etc. del lenguaje de programación utilizado. Por ejemplo en c++
existe el tipo de dato double si nombramos una variable con el nombre double
seguramente nos dirá que hay un error.
 Una forma recomendada de nombrar variables es:
<ámbito (local, global, parámetro, etc.)><Tipo de dato>_<nombre variable>.
Imagine una variable local de tipo entero que va a contener una edad, el nombre de la variable podría
ser: li_edad.
Variable global para guardar el sexo de maría („M‟,‟F‟), podemos declarar: gc_sexo_maria.
A continuación listamos más ejemplos:
CAR
CAR y Car son variables distintas
Car

16. a_50
b35a
pepito
Promedio_ventasC
31p => no valido
Luis Sánchez => no valido
Usuario-1 => no valido
lc_nombre =>local de tipo carácter (recomendado)
gl_cantidad => global de tipo long (recomendado)
afl_promedio =>argumento de tipo float (recomendado)
En este libro usaremos la forma recomendada de nombrar variables cuando veamos problemas
algorítmicos de sobremanera complejos.
3.1.4 Asignación de variables
Se asigna valores del mismo tipo que el que se declaró previamente a la variable/constante
(aritmética, lógica, textos y caracteres).
Pseudocódigo C++ Observación
Variable = variable/valor Variable = variable/valor;
A=10 A=10;
B=20 B=20;
C = A + B C = A + B;
Se utiliza una función predefinida de
D="Arriba Peru" strcpy(D,"Arriba Peru");
C++ (Véase capítulo 6)

17. E='A' E='A';
F = 10 + 50 F = 10 + 50;
No valido(10 es un numero entero y
G = 10 + "50" G = 10 + "50"; “50” es cadena por estar entre
comillas)
No valido(D es cadena y B es un
H = D + B H = D + B;
entero)
3.1.5 Operadores
Tipo Operadores Descripción Pseudocódigo C++
Suma + +
Resta - -
Multiplicación * *
Aritméticos
División real /
(*) /
División entera Div
Residuo(división entera) Mod %
Mayor que > >
Mayor o igual que > >=
Menor < <
Relacionales
Menor o igual que < <=
Igualdad = ==
Diferente <> !=

18. Y And &&
Lógicos O Or ||
Negación Not !
(*) Notar que para C++ se colocó el mismo símbolo en división real y entera, para saber en qué
momento funciona como división real y en qué momento como división entera (Véase los apartados
3.2.5, 3.2.6, 3.2.7)
3.1.6 Prioridad de Operadores
A continuación se detalla el orden de prioridad al momento de operar, se respeta de manera similar al
orden que se usa en el álgebra de las matemáticas. Al igual que en el álgebra es posible alterar el
orden de operación haciendo uso de paréntesis. Para agrupaciones más complejas solo está permitido
el uso del paréntesis “()”.
1. () (*)
2. /
3. *
4. +
5. –
(*) Las operaciones que están dentro de paréntesis se evalúan primero. Cuando existe múltiples
paréntesis (anidado: internos unos a otros), se evalúan primero las expresiones más internas.
Ejemplos
Considere si: A=3, B=4, C=5:
a) b)
X = A-B+C Y = A*B + C
X=3-4+5 Y = 3*4 + 5
X= 3-9 Y = 12 + 5
X= -6 Y = 17

19. c) d)
Z = C*B + A / A W = ((A + B) - (C - A)) / C
Z = 5*4 + 3 / 3 W = ( (3 + 4) - (5 - 3) ) / 5
Z = 5*4 + 1 W = ( (7) - (2) ) / 5
Z = 20 + 1 W = (5) / 5 = 1
Z = 21
3.1.7 Entrada y Salida
Entrada
Es el flujo de datos que el programa utilizará para realizar sus procesos. Vale decir que la entrada
puede originarse de distintas ubicaciones (Teclado, un archivo, etc.).
En c++ utilizaremos el comando:
scanf(<formato>, &<variable>);
Ejemplo:
int nro;
scanf("%d”,&nro");
Salida
Es generalmente la información y/o resultado del programa. Además se puede utilizar como mensajes
para solicitud de entradas.
En c++ utilizaremos el comando:
printf(<formato>, <lista de variables>);
Ejemplos:
printf("nnr Ingrese un numero entero: ");
printf("n El Entero ingresado: %d", nro);
printf("nEl real ingresado: %f y la cadena ingresada: %s", nro_float, cadena); (*)

20. printf("nEl real ingresado: %8.4lf", nro_double); (**)
(*) Notar el texto en negrita %f y %s, dichos valores serán reemplazados por las variables listadas
después de la coma en orden de ocurrencia.
(**) Notar el número 8.4 del formato %8.4lf, representa el formato de impresión del número en pantalla
en este caso longitud 8 a 2 decimales.
Formatos de entrada y salida
Formato Tipo de dato
%d int
%ld long
%f float
%lf double
%c char
%s char(cadena)
%u Entero sin signo
Notar que %c y %s tienen el mismo tipo de dato, no obstante %c imprime solo un carácter y %s
imprime una cadena de caracteres.
Secuencias de escape
Como señalamos en los ejemplos de Salida en la impresión con printf, mostramos unos ejemplos de
uso de las secuencias de escape, a continuación listamos más secuencias de escape:
Descripción Símbolo
Nueva Línea n
Tabulación Horizontal t
Retorno de carro r
Alerta a
Diagonal invertida
Comillas dobles "

21. Ejemplos:
printf("nt Promedio: %8.2lf nn", prom);
printf("nn la cadena "%s" tiene una longitud: %d nn", cadena, longitud);

22. 3.2 Manejo de Expresiones
3.2.1 Transformación de expresiones algebraicas a computacionales
Como ya se mencionó en el apartado Prioridad de operadores, solo están permitidos los paréntesis “()”
a continuación veremos cómo transformar las expresiones algebraicas hacia expresiones
computacionales:
Expresión algebraica Expresión computacional
4+5 4+5
A - 10
2x4 2*4
1/2
1 + 2 / 8 - ( 10 * 2 )
7(a + b) 7*(a+b)
8*x + 9y + 3*z
(p+q) / (x+m/n)
( )
(a / b)*c*d
(a+b)*(c-d)*(e-f)
(a+b)*(c-d) * ((e-f) / (g-h))
(A + 5 – b – 4 + 2) / D
[ ]
(a * b * (-c * d) + 5) / 10
1 / (a * b * c + c * d - 10)
((a-b)/(c-d) / ((e-f)/(g-h))

23. 3.2.2 Declaración de Variables
Es el acto de definir un Tipo de dato válido a una variable que se utilizará en el programa.
Ejemplos:
Pseudocódigo C++
Entero: A,B int A,B; long k,b;
Real: P,Q float P,Q; double R, s;
Carácter: Sexo, Condición char Sexo, Condición;
Constante Entero: P=10 const int P = 10;
3.2.3 Datos Enteros vs Datos Reales
En c++ hay que tener claro la diferencia entre los datos enteros y reales, para eso dividimos el
concepto en 2 partes: números y variables:
 Para los números digitados en expresiones, son enteros siempre y cuando no se digita el punto
decimal y números posteriores, en caso contrario son reales.
Números Enteros
Son aquellos números que no cuentan con parte decimal.
Ejemplo: 0, 1, 15, 540, 1500, etc.
Números Reales
Son aquellos números que poseen parte real o decimal.
Ejemplo: 0.00001, 1.633, 20.3598, 1.3333333, 1.0, etc.
 No obstante en la programación en C++, las variables que contendrán números son del tipo en el
que son declarados ya sea real (double o float) o entero (int, long).
Variables Enteras
Son aquellas variables que son declaradas como enteras.

24. Ejemplo: int P; long Q, R;
Variables Reales
Son aquellas variables que son declaradas como tipo de dato reales.
Ejemplo: float A; double B, C;
3.2.4 Partes de la división
3.2.5 División Entera vs división real
En los problemas computacionales no solo es usada la división real sino también es a menudo
necesario el uso del operador de divisiones enteras.
3.2.6 Resultados de la división
Los resultados de la división van a depender del tipo de dato del dividendo y/o divisor. A continuación
mostraremos los resultados teniendo en cuenta el tipo de dato del dividendo y divisor:
División de Números
a) 10 ÷ 5 = 2 (Símbolo de división no utilizado en C++)
b) 12 / 5 = 2
c) 15 / 4.0 = 3.75
d) 15 / 4 = 3
e) 10 / 3 = 3

25. f) 10.0 / 3 = 3.333333…
La representación c) muestra el resultado real pues la división cuenta con un dividendo entero y un
divisor real (por estar con punto decimal .0) y además tiene residuo inicial 3 (> 0)
Dónde:
15: Dividendo
4.0: Divisor
3.75: Cociente (es el resultado de la operación)
3: Residuo
La representación e) muestra el resultado entero pues se está usando operadores enteros.
Dónde:
10: Dividendo
3: Divisor
3: Cociente (es el resultado de la operación)
1: Residuo

26. División de Variables
Supongamos que contamos con las siguientes variables:
int P, Q;
double R,S;
Ahora supongamos que tienen los siguientes valores:
P=10; Q=20;
R=1.5; S=2.5;
 División variables enteras
a) B / A = 2
b) A / B = 0
 División variables Reales
c) S / R = 1.66666…
d) R / S = 0.6
 División variables Enteros y Reales
e) Q / S = 8.0
f) R / P = 0.15

27. División de variables y números
Supongamos que contamos con las variables P, Q, R, S mencionados anteriormente:
a) P / 5 = 2
b) Q / 4.0 = 5.0
c) P / 6 = 1
d) Q / 20.0 =1.000000 (*)
e) P / 0 = (Error en tiempo de ejecución)
f) R / 10 = 0.15
g) 5.0 / S = 2.0
h) 2.5 / R = 1.666666… (**)
(*): El resultado es real, en el ejemplo se muestra 1.000000 como resultado no obstante la cantidad de
dígitos decimales va a depender del tipo de dato definido en C++ ya sea float o double. (Véase el
apartado 3.1.1)
(**): Existen divisiones en las cuales el resultado de la división es un número con parte decimal muy
extenso como .33333..., la longitud de los dígitos va a depender del tamaño del tipo de dato de la
variable en la cual se va a almacenar o el formato redondeando el ultimo digito de ser necesario
(Véase el apartado 3.1.1)
En general para obtener los resultados esperados de acuerdo al dividendo y divisor ya sea variables o
números se puede aplicar la siguiente regla:
Dividendo Divisor Resultado
Entero Entero Entero
Entero Real Real
Real Entero Real
Real Real Real

28. 3.2.7 Análisis de almacenamiento de la división con resultados numéricos
Considere que las variables A, B, C y P son de tipo entero int, variables C, D E y Q de tipo double:
//Declaración de variables enteras
int A, B, C, P;
//Declaración de variables reales
double D, E, F, Q;
//Asignación a variables
A=10;
B=5;
C=0.5; // C almacena 1 ya que la variable C es de tipo int
D=0.5;
E=1.24;
F=1; // F almacena 1.000000, ya que la variable F es de tipo double
A continuación se muestran típicas operaciones en la que se almacena valores erróneos por los tipos
de datos:
P=A / E;
Cuidado con este tipo de operaciones. El resultado de la división es 8.06 pero P=8, por la causa de
que la variable P es de tipo entero.
Q=(A+B) / 2;
El resultado de la división es un entero 7 y como Q es doublé Q=7.000000.
Q=(A+B) / 2.0;
El resultado de la división es real 7.5 por lo tanto Q=7.500000.

29. 3.2.8 Residuo (Modulo)
En C++ el operador modulo es representado por < % >, y se utiliza para obtener el residuo o resto de
una división entera, vale decir que para obtener el resto el dividendo y divisor deben ser
necesariamente enteros.
Ejemplos
Si A=15, B=14, C=3, D=2 entonces:
a) A % 6 = 3
b) B % 2 = 0
c) 19 % C = 1
d) 7%9=7
e) C%3=0
f) D%5=2
g) B%0=0

30. Capítulo 4
FLUJOS DE CONTROL
4.1 Estructuras condicionales
4.1.1 Expresiones booleanas
4.1.2 Estructura condicional < if >
4.1.3 Estructura condicional < if - else >
4.1.4 Estructura condicional anidada < if - else - if >
4.1.5 Estructura de selectiva múltiple < switch >
4.1.6 8 Recomendaciones para el uso de estructuras condicionales.
4.2 Estructuras repetitivas
4.2.1 Conceptos acerca de estructuras repetitivas
4.2.2 Operadores de incremento
4.2.3 inicialización de variables
4.2.4 Contadores y Acumuladores y Banderas (flag)
4.2.5 Estructura repetitiva < for >
4.2.6 Estructura repetitiva < while >
4.2.7 Estructura repetitiva < do - while >
4.2.8 Anidamiento de bucles
4.2.9 8 Recomendaciones para el uso de estructuras repetitivas

31. 4.3 Introducción a C++
4.3.1 Reseña histórica
4.3.2 Librerías y palabras reservadas básicas
4.3.3 Estructura de un programa en C++
4.3.4 Creación, ejecución y depuración de un programa mediante Visual Studio .Net

32. 4 Flujos de Control
4.1 Estructuras Condicionales
Usualmente en los programas va a ser necesario que se ejecuten ciertas instrucciones bajo ciertas
condiciones, es en estos casos cuando resultan sumamente útiles las estructuras de control, las cuales
mediante expresiones booleanas en una estructura condicional van a determinar que bloque del
código se va a ejecutar.
4.1.1 Expresiones Booleanas
Se denomina expresión booleana a aquella expresión en la cual se va a realizar una evaluación y
como resultado de dicha evaluación solo puede devolver dos posibles valores true (Verdad) o false
(falso). Está compuesta generalmente por variables/valores, operadores de comparación y operadores
lógicos.
Expresiones con operadores de comparación
Son el tipo de expresiones más sencillas en las cuales se van a evaluar dos valores mediante un
operador de comparación.
Ejemplos:
Si A=50, B=70, C=‟A‟, D=1 entonces:
char
A == 50 => true
B = 70 => No es una expresión booleana, es una asignación a la variable B con 70
A>B => false
C==”A” => Error en tiempo de codificación, las comillas dobles indica cadena
C==‟A‟ => true
B>C => true, „A‟ representa el número 65 en la tabla de los códigos ASCII Véase capitulo X

33. A+B < B+D => false
D != D => false
D => true
!D => false (*)
(*) Nótese que < !D > retorna false, puesto que en C++ el numero 1 representa true y 0 false, aunque
esto es posible no se recomienda usar los números para este propósito, en su lugar C++ cuenta con
un tipo de dato especial bool.
Ejemplo:
bool sw;
sw = false;
sw=true;
Expresiones con operadores lógicos
Para este propósito utilizaremos los operadores lógicos, pero antes debemos mostrar las tablas de
verdad de los principales operadores:
Tabla de verdad && (Disyunción lógica “Y”)
Operando 1 Operador Y Operando 2 Resultado
true && true true
true && false false
false && true false
false && false false

34. Una receta para recordar la tabla del Y: “Los operadores deben ser todos verdaderos para que el
resultado sea verdadero, caso contrario es falso”
Ejemplos:
Considere que:
A = 10, B = 20, C = 30 entonces:
A > 0 && B > 0 => true && true = true
A < C && B==C => true && false = false
A==10 && B==20 => true && true = true
B==20 && C==40 => true && false = false
A!=15 && B==20 => true && true = true
C==20 && A!=10 => false && false = false
Tabla de verdad || (Conjunción lógica “O”)
Operando 1 Operador O Operando 2 Resultado
true || true true
true || false true
false || true true
false || false false
Una receta para recordar la tabla del O: “Los operadores deben ser todos falsos para que el resultado
sea falso, caso contrario es verdadero”
Ejemplos:
Considere que:
A = 10, B = 20, C = 30 entonces:

35. A > 0 || B > 0 => true || true = true
A < C || B==C => true || false = true
A==10 || B==20 => true || true = true
B==20 || C==40 => true || false = true
A!=15 || B==20 => true || true = true
C==20 || A!=10 => false || false = false
Tabla de verdad ! (Negación lógica “No”)
Operando 1 Operador NO Resultado
true ! false
false ! true
Ejemplos:
Considere que:
A = 10, B = 20, C = 30 entonces:
A>0 => true
! (A > 0) => ! true = false
A > 0 && ! (B > 0) => true && ! true = true && false = false
A < C || ! (B==C) => true || ! false = true || true = true
!(A==10 || B==20) => !(true || true) = ! true = false
!(!(B==20) || !(C==40))=> !(! true || ! false) = ! (false || true) = ! true = false
!!(A!=15) || !(B==20) => !! true || ! true = ! false || false = true || false = true

36. 4.1.2 Estructura Condicional < if >
Es una estructura que bifurca el flujo de ejecución del código del programa en función del resultado de
una expresión booleana.
Sintaxis
if(<Expresión booleana>)
{<Inicio de bloque>
<Bloque de Código>
}<Fin de bloque>
<Continuación del programa>
dónde:
Expresión booleana: Debe siempre retornar true o false.
Inicio de bloque: La llave abierta que indica el inicio del cuerpo de código a ejecutarse si la expresión
booleana retorna true.
Bloque de Código: El compilador va a ejecutarlo siempre que la expresión booleana retorne true.
Fin de bloque: La llave cerrada indica el fin del cuerpo de código a ejecutarse si la expresión
booleana retorna true.
Continuación del programa: Si la expresión booleana dentro de la instrucción < if > retorna false el
compilador salta hacia continuación del programa.
Ejemplos:
Promedio = 10.5;
if( Promedio < 10.5 ){
flag_desaprobado = true;
Salta printf("Condicion Alumno: Repitente");
}
scanf("Ingrese Nota1: %d", %n1);
…..
…..

37. Para este ejemplo no se ejecuta las instrucciones:
flag_desaprobado = true;
printf("Condicion Alumno: Repitente");
Cuando el compilador llegue hasta la evaluación dentro de la instrucción < if > como el promedio no es
menor sino igual a 10.5 saltará hasta la instrucción:
scanf("Ingrese Nota1: %d", %n1);
En otro caso si el promedio hubiese sido: Promedio=10 se hubiese ejecutado:
flag_desaprobado = true;
printf("Condicion Alumno: Repitente");
y aun también:
scanf("Ingrese Nota1: %d", %n1);
4.1.3 Estructura Condicional < if – else >
Es la estructura que bifurca el flujo de ejecución del código del programa con una estructura alternativa
en función del resultado de una expresión booleana.

38. Sintaxis
if(<Expresión booleana>)
{<Inicio de bloque if>
<Bloque de Código if>
}<Fin de bloque if>
else
{<Inicio de bloque else>
<Bloque de Código else>
}<Fin de bloque else>
<Continuación del programa>
dónde:
Expresión booleana: Debe siempre retornar true o false.
Inicio de bloque if: La llave abierta que indica el inicio del cuerpo de código a ejecutarse si la
expresión booleana retorna true.
Bloque de Código if: El compilador va a ejecutarlo siempre que la expresión booleana retorne true.
Fin de bloque if: La llave cerrada indica el fin del cuerpo de código a ejecutarse si la expresión
booleana retorna true.
Inicio de bloque else: La llave abierta que indica el inicio del cuerpo de código a ejecutarse si la
expresión booleana retorna false.
Bloque de Código else: El compilador va a ejecutarlo siempre que la expresión booleana retorne
false.
Fin de bloque else: La llave cerrada indica el fin del cuerpo de código a ejecutarse si la expresión
booleana retorna false.
Continuación del programa: En este caso de estructura condicional como tiene parte alternativa
<else> este debe ejecutarse primero antes de la continuación del programa.
En este tipo de estructuras solo un bloque se ejecuta: el bloque de código if o el bloque de código else,
más no los dos bloques.

39. Ejemplos:
Promedio = 15;
if( Promedio > 10.5 )
{
printf("Alumno Aprobado");
}
else
{
printf("Alumno Desaprobado");
}
…..
…..
Para este ejemplo solo se ejecutara el bloque < if >, lo que no ocurriría si el Promedio=10 en ese caso
se ejecutaría el bloque < else >.
La instrucción <if> del ejemplo anterior se puede escribir de la siguiente forma:
if(Promedio > 10.5)
printf("Alumno Aprobado");
else
printf("Alumno Desaprobado");
O también:

40. if(Promedio > 10.5) printf("Alumno Aprobado");
else printf("Alumno Desaprobado");
La razón es que en C++ son necesarias las llaves solo si un bloque tiene 2 a más instrucciones.
En C++ existe una forma adicional de condicional que simula la instrucción <if>, que no es
recomendada, pero que quizás observen en algunos códigos externos, y aquí se muestra para que sea
de conocimiento:
int A=11;
(A==10) ? printf("A es 10") : printf("A No es 10");
Estas sentencias devolverán por pantalla: "A No es 10".
4.1.4 Estructura Condicional anidada < if – else – if >
Es la estructura con n alternativas de bifurcación del flujo de ejecución del código del programa, en
función del resultado de múltiples expresiones booleanas.
Sintaxis
if(<Expresión booleana 1>){
<Bloque de Código 1>
}else
if(<Expresión booleana 2>){
<Bloque de Código 2>

41. }else
…..
if(<Expresión booleana n>){
<Bloque de Código n>
}
<Continuación del programa>
dónde:
Expresión booleana 1,2,…n: Debe siempre retornar true o false en la respectiva expresión booleana.
Bloque de Código 1,2,…n: El compilador va a ejecutarlo siempre que la expresión booleana
respectiva retorne true.
Continuación del programa: Si la estructura anidada tiene al final un bloque <else> en ese caso
debe ejecutarse primero antes de la continuación del programa. Si no tuviese un bloque < else > al
final, el compilador de no encontrar ningún true en las estructuras booleana saltará a la continuación
del programa.
Ejemplos:
Numero = 15;
if(Numero < 0 )
{
printf("Numero Negativo");
}
else
if(Numero == 0 )
{
printf("Numero Neutro");
}else{
printf("Numero Positivo");
}

42. Para este ejemplo el resultado será “Numero Positivo”
La instrucción < if > del ejemplo anterior se puede escribir de la siguiente forma:
if( Numero < 0 )
printf("Numero Negativo");
else
if( Numero == 0 )
printf("Numero Neutro");
else
printf("Numero Positivo");
O también:
if( Numero < 0 ) printf("Numero Negativo");
else if( Numero == 0 ) printf("Numero Neutro");
else printf("Numero Positivo");
Cabe decir que para este ejemplo, la última forma mostrada es la más fácil de entender e interpretar.
Este tipo de estructura es solo una variación ampliada de la estructura <if-else>. Realmente esta
estructura es flexible y se va a acomodar muy bien a cualquier tipo de problemas en las cuales se
evalúe varias condiciones.
4.1.5 Estructura selectiva múltiple < switch >
A diferencia de la instrucción < if - else > en C++ esta estructura puede evaluar solo una variable y solo
puede comparar igualdad además no permite la combinación con operadores lógicos como && (Y
lógico por ejemplo), en su lugar puede combinar el || (O lógico) de forma homologa.
Sintaxis

43. switch (<variable a comparar>)
{
case <valor a comparar 1> : <Bloque de instrucción 1> break;
case <valor a comparar 2> : <Bloque de instrucción 2> break;
…..
case <valor a comparar i> : <Bloque de instrucción i> break;
…..
case <valor a comparar n> : <Bloque de instrucción n> break;
default: <Bloque de instrucción default> break;
}
Dónde:
<variable a comparar>: Variable a ser evaluada.
<valor a comparar i>: Constante con la cual la <variable a comparar >va a evaluar igualdad, si es
que no coincide pasa al siguiente <valor a comparar i>.
<Bloque de instrucción i>: Conjunto de instrucciones a ejecutarse si es que el <valor a comparar i>
respectivo retorna true.
<Bloque de instrucción default>: Conjunto de instrucciones a ejecutarse si es que la variable a
comparar no coincide con ninguno de los <valor a comparar i>.
break: Instrucción C++ para bifurcar o saltar al final de la estructura switch. De no invocar a la
instrucción break si es que encuentra coincidencia seguirá evaluando los siguientes “case” de la
instrucción.
Ejemplos:
char sexo;
printf("Ingrese sexo de persona (M, F):"); sexo=getchar();
switch(sexo){
case 'M':
printf("Masculino"); break;
case 'F':

44. printf("Femenino"); break;
default:
printf("Error: Dato de ingreso No valido"); break;
}
La función getchar() permite el ingreso por teclado de un carácter.
Para el ejemplo anterior mostrado supongamos que se ingresó por teclado el carácter M, entonces se
imprime por pantalla: Masculino.
Supongamos que se ha ingresado por teclado la letra m, entonces por pantalla se mostrara: Error:
Dato de ingreso No valido. La siguiente estructura switch muestra el mensaje correcto sin distinguir
mayúsculas o minúsculas.
switch(sexo){
case 'M': case 'm': printf("Masculino"); break;
case 'F': case 'f': printf("Femenino"); break;
default: printf("Error: Dato de ingreso No valido"); break;
}
4.1.6 8 Recomendaciones para el uso de estructuras condicionales.
Sin lugar a dudas es posible usar las estructuras condicionales de muchas formas, a continuación
mencionamos unos consejos para la elección de estructura:
1) Elija < if > cuando va a evaluar varias variables.
2) Elija < switch > cuando va a evaluar una sola variable y en casos de igualdad.
3) Evite en lo posible hacer anidamientos, solo realizarlo si es irremediable.
Ejemplo: Sumar 10 a un número ingresado solo si es mayor a 10 y solo si es par.
a) Solución anidada
if( A <= 10 )
printf("Error número no es mayor a 10.nn");
else
if( A % 2!=0 )
printf("Error número no es par.nn");

45. else
{
A = A + 10;
printf("A = %dnn", A);
}
system("PAUSE");
Aunque esta solución es válida, dificulta la lectura cuando se cuenta con varios
niveles de anidamiento y con más instrucciones.
b) Solución recomendada
if(A <= 10){
printf("Error numero no es mayor a 10.nn");
system("PAUSE");
exit(0); //Función para terminar el programa
}
if(A % 2!=0){
printf("Error numero no es par.nn");
system("PAUSE");
exit(0); //Función para terminar el programa
}
A = A + 10;
printf("A = %dnn", A);
system("PAUSE");
La debilidad de esta forma es que se generan más líneas de código, no obstante en los problemas
computacionales en algún momento va a pesar más el entendimiento que las líneas de código.
4) Para evaluaciones con tipos booleanos, usar los booleanos:
Ejemplo: Decir si un numero pasa la prueba de validación. Debe ser múltiplo de 3 y la vez divisible por
18.

46. a) Solución pésima
bool pasa_prueba;
if( A % 3 == 0 && 18 % A == 0 )
pasa_prueba=true;
else
pasa_prueba=false;
if( pasa_prueba == true )
printf("Si pasa la prueba");
else
printf("No pasa la prueba");
system("PAUSE");
No se recomienda este tipo de soluciones se sobrescribe las alternativas de los booleanos, ya que
sabemos que los booleanos solo tienen dos posibles valores (true o false)
b) Solución buena
bool pasa_prueba=false;
if( A % 3 == 0 && 18 % A == 0 )
pasa_prueba=true;
if( pasa_prueba == true )
printf("Si pasa la prueba");
else
printf("No pasa la prueba");
system("PAUSE");

47. Esta solución es a menudo utilizada, inicializar como false y luego preguntar si pasa la prueba y
asignar a true.
c) Solución recomendada:
bool pasa_prueba;
pasa_prueba = ( A % 3 == 0 && 18 % A == 0 );
if( pasa_prueba )
printf("Si pasa la prueba");
else
printf("No pasa la prueba");
system("PAUSE");
Con más conocimiento técnico sabemos que una expresión booleana retorna dos valores (true o
false) entonces, no es necesario preguntar con < if > por lo tanto es válido < pasa_prueba = ( A
% 3 == 0 && 18 % A == 0 ); >. Además tampoco es necesario if( pasa_prueba == true )
puesto que el código del < if > se va a ejecutar si la expresión retorna true, pero
la variable pasa_prueba solo tiene (true o false) como valor por lo tanto es válido
if( pasa_prueba )
Como consejo practico use if ( < true >) para booleanos.
5 ) Use switch para estructuras grandes, para demarcar algo importante y diferenciarlo de estructuras
< if >, además de lo explicado anteriormente.
6) Evite en lo posible utilizar switch para comparar muchos valores:
Ejemplo
Mostrar un mensaje si un carácter ingresado por teclado es una vocal minúscula.
a) Solución no recomendada

48. char op;
op=getchar();
switch(op){
case 'a': case 'e':case 'i': case 'o':case 'u':
printf("Es vocal minúscula"); break;
}
b) Solución recomendada
char op;
op=getchar();
if(op=='a' || op=='e' || op=='i' || op=='o' || op=='u')
printf("Es vocal minúscula ");
7) Utilice sangrías. Hasta ahora no habíamos resaltado la importancia de estas, sin embargo son
esenciales para la lectura del código.
Tenemos fortuna de utilizar C++, pues antiguamente no contábamos con estas, asi que a sangrar
código.
Para hacer un sangrado es usualmente utilizada la tecla < Tab >.
Ejemplo
a) Sin sangría
if( A > 0 ){
if( A == 5 )
printf("Es cinco positivo");
else
printf("No es cinco positivo");
}
else if ( A < 0 ){
if( A == -5 )
printf("Es cinco negativo");
else
printf("No es cinco negativo");
}

49. b) Con sangría
if( A > 0 ){
if( A == 5 )
printf("Es cinco positivo");
else
printf("No es cinco positivo");
}
else if ( A < 0 ){
if( A == -5 )
printf("Es cinco negativo");
else
printf("No es cinco negativo");
}
8) Fíjese y utilice las ayudas del editor de código de fuente como el color (azul, rojo, verde, etc.). En
nuestro caso utilizamos Visual Studio .Net el cual tiene varias ayudas.
Al inicio no se tome mucho tiempo pensando con coraje en una solución cuando es difícil el problema y
no muestra los resultados esperados.
Use marcadores y validaciones de usuario, es decir asegúrese de que la variable contiene el deseado
o supuesto valor, imprimiendo la variable por pantalla antes de entrar a una estructura. Este
concepto nos puede ahorrar horas de análisis después de todo “Un vistazo no está de más“.
4.2 Estructuras repetitivas
Son estructuras en las cuales un bloque de código puede ser ejecutado un número de veces, ya sea
por un número que represente la cantidad de veces o por una expresión booleana.
4.2.1 Conceptos acerca de estructuras repetitivas
Bucle: Es el funcionamiento o el proceso de dar vueltas (repetir) de la estructura repetitiva.

50. INICIO ESTRUCTURA REPETITIVA
Bucle
FIN ESTRUCTURA REPETITIVA
Iteración: Es cada repetición del bucle. Por ejemplo si una estructura repetitiva
tiene 3 repeticiones, tendrá iteración 1, Iteración 2 e Iteración 3.
4.2.2 Operadores de incremento
A menudo las variables son utilizadas como controladores de bucles, para tal caso mostraremos como
incrementar o decrementar una variable:
Modo ampliado Modo Reducido Explicación
A = A + 1; A++; La variable incrementa su valor en 1
A = A - 1; A--; La variable decrementa su valor en 1
A = A + 3; A+=3; La variable incrementa su valor en 3
A = A - 4; A-=4; La variable decrementa su valor en 4
A = A + n; A+=n; La variable incrementa su valor en n
A = A - n; A-=n; La variable decrementa su valor en n
A = A * 5; A*=5; La variable multiplica su valor en 5
A = A / 6; A/=6; La variable divide su valor en 6
4.2.3 inicialización de variables
Antes de utilizar una variable es necesario que esta tenga un valor contenido, ya sea por teclado o
asignación. En estructuras repetitivas su uso muy amplio, y en aplicaciones reales son utilizadas de
muchas formas. En un sentido es una asignación simple. Para tal caso mostraremos un ejemplo:

51. //Declaracion de variables
int A;
bool bandera;
//inicialización de variables
A=0;
bandera=false;
Existe un riesgo que ocurre al no inicializar variables, estas variables pueden ser utilizadas y el
compilador no mostrara error sino hasta el tiempo de ejecución y si el programa es complejo puede no
detectarse rápidamente
Para el caso de estructuras repetitivas (Punto a ver a continuación) es general inicializar las variables a
cero.
En términos prácticos una variable que no es ingresada por teclado y que va a usarse en una
estructura repetitiva siempre debe ser inicializada.
4.2.4 Contadores y Acumuladores y Banderas (flag)
Son variables que serán utilizadas en la estructura repetitiva, Algunas de ellas son inicializadas antes
de la estructura repetitiva, otras dentro de ellas.
Contadores
Son variables que controlan mediante conteo un aspecto del bucle, pueden se controlador de
iteraciones del bucle, o contar algunos aspectos del problema a resolver por el programa.
Generalmente el conteo es de a 1.
Ejemplo
Contador = Contador + 1
Acumuladores

52. Son variables que van a funcionar como recolectoras de resultados individuales, es decir de cada
iteración. Su uso es para obtener un resultado general de todo el bucle y generalmente son
sumatorias.
Ejemplo
Acumulador = Acumulador + promedio
Banderas (Flag)
Son variables que trabajan como indicadores o marcadores. Son para resolver algún aspecto de
identificación dentro del programa. Su uso se extiende en las estructuras repetitivas para determinar la
continuación de iteraciones. Generalmente son de tipo booleano sin embargo su uso se puede ampliar
hasta el grado de usar enteros o caracteres para representar sus múltiples estados.
Ejemplo
bool flag_casado=false;
……….
if(estado_civil=='C') flag_casado = true;
4.2.5 Estructura repetitiva < for >
Es la estructura repetitiva de C++ para ejecutar código teniendo como datos el inicio , el fin e
iteraciones a procesar.
Aunque en C++ la estructura < for > es muy flexible, no es muy utilizado en sus formas complejas,
para esos casos veremos más adelante estructuras que nos ayudaran en esos casos.
Sintaxis
for ( <valor inicial> ; <expresión booleana para continuar> ; <incremento / decremento> )
{//opcional, si hay más de 1 instrucción
<bloque de código>
}//opcional, si hay más de 1 instrucción

53. <valor inicial> :variable con dato o punto de inicio del bucle.
<expresión booleana para continuar>: si retorna true continúa el bucle, caso contrario termina.
<incremento / decremento>: incremento o paso de variable dentro del bucle
<bloque de código>: Instrucciones a repetirse dentro del bucle
Orden de evaluación del compilador a la estructura < for >
La primera vez:
for( 1 ; 2; 4 )
{
3, solo si la expresión booleana retorna true
}
Las veces restantes:
for( <omitido> ; 1; 3 )
{
2, solo si la expresión booleana retorna true
}
Ejemplo:
Mostrar los 7 primeros números naturales positivos:
final=7;
for( indice = 1 ; indice <= final ; indice = indice + 1 )
printf("n Numero: %d", indice);

54. Explicación del código:
estado
Iteración índice expresión booleana ejecución código
bucle
1 1 1 <= 7 = true printf("n Numero: %d", 1); Continua
2 2 2 <= 7 = true printf("n Numero: %d", 2); Continua
3 3 3 <= 7 = true printf("n Numero: %d", 3); Continua
4 4 4 <= 7 = true printf("n Numero: %d", 4); Continua
5 5 5 <= 7 = true printf("n Numero: %d", 5); Continua
6 6 6 <= 7 = true printf("n Numero: %d", 6); Continua
7 7 7 <= 7 = true printf("n Numero: %d", 7); Continua
8 8 <= 7 = true <No ejecuta código> Termina
Notar que al final del bucle la variable índice queda con el valor final del bucle más el incremento, es
decir: índice = final + incremento.
La expresión booleana debe estar bien planteada de lo contrario ocurre 2 posibles eventos:
-El bucle no se ejecuta ni una vez
-El bucle se ejecuta indefinidamente hasta acabar los recursos o “bloquear” la computadora por
completo.
El bloque de código anterior da como resultado:
Numero: 1
Numero: 2
Numero: 3
Numero: 4
Numero: 5
Numero: 6
Numero: 7
Forma alternativa de estructura repetitiva < for >
Una forma adicional de la estructura < for > es utilizarla como instrucción en los problemas
algorítmicos y es a menudo para abreviar conteos o para marcar posiciones.

55. for (<valor inicial> ; <expresión booleana para continuar> ; <incremento / decremento>) ;
Notar que la instrucción < for > termina en < ; >
Puede ser utilizada para obtener precisamente el valor final del <valor inicial> al finalizar el bucle.
Esta no es la forma más fácil de usar < for > pues puede crear confusiones, sin embargo en
aplicaciones prácticas veremos su uso.
Ejemplo:
final=7;
for ( indice = 1; indice <= final ; indice = indice + 1 );
printf("n Numero: %d", indice);
El bloque de código anterior da como resultado:
Numero: 8
Trabajo con múltiples variables en la estructura repetitiva < for >
La estructura < for > puede admitir el trabajo con muchas variables, para separarlas se debe usar
coma < , > diferenciando claramente el < ; > que distingue la parte funcional del < for >.
Ejemplo:

56. final =10;
for( A = 1, B = - A ; A <= final ; A++, B-- )
{
printf("n Positivo: %d", A);
printf("t Negativo: %d", B);
}
Resultado:
Positivo: 1 Negativo: -1
Positivo: 2 Negativo: -2
Positivo: 3 Negativo: -3
Positivo: 4 Negativo: -4
Positivo: 5 Negativo: -5
Positivo: 6 Negativo: -6
Positivo: 7 Negativo: -7
Nota: Como último recurso también es posible declarar variables dentro de la estructura < for >.
for ( int indice = 1; indice <= final ; indice = indice + 1 )
Este tipo de declaraciones aunque no es tan usado solo permite usar la variable (en este caso indice)
dentro de la estructura, es decir la variable no será tomada en cuenta como declarada en otros lugares
del código del programa.

57. 4.2.6 Estructura repetitiva < while >
Es la estructura repetitiva para evaluar una expresión booleana y entonces ejecutar un bloque de
código. A diferencia del < for > no siempre cuenta con los límites de las iteraciones (Valor inicial y valor
final).
Sintaxis
while (<expresión booleana>)
{
<bloque de código>
}
<expresión booleana>: Retorna true o false.
<bloque de código>: Se ejecuta siempre que la expresión booleana retorne true.
Ejemplo:
int C, S, final;
C=1; S=0; final=15
while( C <= final ){
S+=C;
printf("n%d",C);
C+=2;
}
printf("nnSuma: %d",S);
El ejemplo mostrado anteriormente muestra por pantalla los 15 primeros números impares positivos y
además al final muestra la suma de ellos.
Notar las inicializaciones S=0 porque va a acumular, C=1 porque es el primer número impar, final=15
es el límite superior.
Para este ejemplo S es el acumulador <S+=C> en cada iteración acumula a la variable C.

58. C trabaja como el número impar de la iteración y el contador. Notar que se incrementa a la variable C
de dos en dos: < C+=2; >.
Notar que dentro del < while > se cuenta con una instrucción printf que imprime por pantalla a la
variable C (número impar de cada iteración) con un salto de línea, y al finalizar el bucle imprime la
suma con dos saltos de línea
< printf("nnSuma: %d",S); >.
Detalle Trabajo de la Estructura Repetitiva:
Iteración final S C C <= final Estado Bucle
<Inicialización> 15 0 1
1 15 1 3 3 <= 15 = true Continua
2 15 4 5 5 <= 15 = true Continua
3 15 9 7 7 <= 15 = true Continua
4 15 16 9 9 <= 15 = true Continua
5 15 25 11 11 <= 15 = true Continua
6 15 36 13 13 <= 15 = true Continua
7 15 49 15 15 < = 15 = true Continua
8 15 64 17 17 < = 15 = false Termina
El resultado es:
1
3
5
7
9
11
13
15
Suma: 64

59. 4.2.7 Estructura repetitiva < do - while >
Es la estructura repetitiva para ejecutar un bloque de código por lo menos una vez, y evaluar una
expresión booleana.
Sintaxis
do{
<bloque de código>
} while (<expresión booleana>);
(<expresión booleana>): Retorna true o false.
<bloque de código>: Se ejecuta al menos una vez antes de que se evalué la expresión booleana,
para que se repita dicha expresión debe retornar true.
Ejemplo:
Ingresar una secuencia de números, mostrar por pantalla los números ingresados y su suma, hasta
que el usuario decida no ingresar más números.
char op;
int N, S;
S=0;
do{
printf("nIngrese numero: "); scanf("%d", &N); fflush(stdin);
S+=N;
printf("nnNumero ingresado: %d", N);
printf("nnnDesea seguir ingresando numeros?(S/N): ");
op=getchar();
} while( op!='N' && op!='n' );
printf("nnSuma: %d",S);

60. Notar las inicializaciones < S=0; > porque va a acumular, N es el número ingresado en la iteración
respectiva, < op > es la variable con la opción de seguir ingresando más números.
En este ejemplo se ingresa N mediante < scanf("%d", &N); >, se acumula < S+=N; > y se muestra
dicho valor ingresado.
Se imprime por pantalla el mensaje de solicitud para seguir ingresando números.
Luego se ingresa el carácter por teclado mediante getchar() y se guarda en la variable op
Entonces llega a la expresión booleana de la estructura repetitiva, la cual va a repetir siempre que el
usuario no digite la tecla N o n.
Al final se muestra la suma de los números ingresados < printf("nnSuma: %d",S);
>.
Detalle Trabajo de la Estructura Repetitiva:
Estado
Iteración N S op op!='N' && op!='n'
Bucle
<Inicialización> 0
1 5 5 S 'S'!='N' && 'S'!='n' = true Continua
2 1 6 S 'S'!='N' && 'S'!='n' = true Continua
3 9 15 S 'S'!='N' && 'S'!='n' = true Continua
4 7 22 S 'S'!='N' && 'S'!='n' = true Continua
5 50 72 N 'N'!='N' && 'N'!='n' = false Termina
< N > es un valor ingresado por teclado, es decir pueden ser cualquier número.
< op > es un carácter ingresado por teclado, para el ejemplo el usuario afirmo ingresar 4 números
pero, como se usa la estructura < do- while > se ejecuta la primera vez sin evaluar.

61. El resultado es:
Ingrese numero: 5
Numero ingresado: 5
Desea seguir ingresando numeros?(S/N): S
Ingrese numero: 1
Numero ingresado: 1
Desea seguir ingresando numeros?(S/N): N
Ingrese numero: 9
Numero ingresado: 9
Desea seguir ingresando numeros?(S/N): N
Ingrese numero: 7
Numero ingresado: 7
Desea seguir ingresando numeros?(S/N): N
Ingrese numero: 50
Numero ingresado: 50
Desea seguir ingresando numeros?(S/N): N
Suma: 72

62. 4.2.8 Anidamiento de bucles
Del mismo modo en que se puede anidar las estructuras condicionales, también es posible anidar
estructuras repetitivas, ya que en realidad no hay regla que lo impida. Por tanto veremos el
anidamiento mediante este un ejemplo.
Ejemplo: Se pide generar la tabla de multiplicar de un número ingresado por teclado. Se debe solicitar
la finalización del programa.
char op;
int N;
do{
printf("nIngrese numero: "); scanf("%d", &N); fflush(stdin);
for(int i=0;i<=12;i++)
printf("n %d * %d = %d", N, i, N * i );
printf("nnnDesea continuar?(S/N): ");
op=getchar();
} while( op!='N' && op!='n' );
system("PAUSE");
Como se muestra en este ejemplo existe una estructura repetitiva < do – while > y dentro de ella una
estructura repetitiva < for >. Sin embargo puede haber varios niveles de anidamiento de acuerdo a la
complejidad del problema.
4.2.9 8 Recomendaciones para el uso de estructuras repetitivas
1) Cuando se conozcan los límites a iterar use la estructura < for >.

63. 2) Cuando al menos necesite ejecutar una vez la estructura repetitiva use < do – while>.
3) Cuando necesite salir de un bucle antes de ejecutar todas las iteraciones utilice la instrucción
break.
Ejemplo:
int N=5;
for(int i=1;i<=12;i++){
if (i==5)break;
printf("n %d * %d = %d", N, i, N * i );
}
Este ejemplo muestra la tabla de multiplicar del número N desde 1 hasta 4, puesto que cuando llega a
5 está la instrucción break, por lo tanto termina la instrucción < for >.
4) Evite anidamientos de estructuras condicionales. Si necesita validaciones dentro de la estructura
utilice la instrucción continue.
Ejemplo:
a) No recomendado
int N=5;
for(int i=1;i<=12;i++){
if (i==5)
printf("n %d * %d = %d", N, i, N * i );
}
b) Recomendado

64. int N=5;
for(int i=1;i<=12;i++){
if (i!=5)continue;
printf("n %d * %d = %d", N, i, N * i );
}
Este ejemplo muestra la tabla de multiplicar del número <N>, pero si el indice es distinto a 5 itera
nuevamente por la instrucción continue, solo cuando llega a 5 muestra por pantalla el resultado.
5) Minimice el uso de constantes. En los bucles como en la mayoría de casos es de usarse variables
por más estática que parezca, ya cada vez más nos damos cuenta que no existen las constantes sino
las variables muy variables y las variables que son muy lentamente variables o las variables
lejanamente variables ya que en el futuro seguramente será modificado su valor.
Ejemplo
a) No recomendado
for(i=1;i<=12;i++)
S+= precio * 0.18;
b) Recomendado
IGV=0.18; NroMeses=12;
for(i=1;i<=NroMeses;i++)

65. S+= precio * IGV;
La forma no recomendada parece correcta, pero si pensamos bien el porcentaje 0.18 representa el
IGV y aunque por años se mantiene esa tasa, en algún momento de seguro su valor cambiara a 0.19,
0.17 u otro.
Respecto a NroMeses=12, fácilmente se puede pensar que ese valor no va a cambiar, mas la lectura
puede volverse menos tediosa cuando dejamos de ver el código del programa por algún tiempo y
cuando volvamos a ver sabremos rápidamente que ese 12 que hubiesemos dejado representa los
números de meses del año.
Es solo un ejemplo de las variables que parecen constantes.
6) Analice que variables se inicializan fuera y dentro del bucle. Como consejo practico se inicializa
afuera del bucle respectivo (por que puede haber anidamientos) las variables que van a retener un
valor global acumulado respecto al bucle. Las variables que van a retener datos de la iteración se
deben inicializar dentro del bucle respectivo.
7) Use estructuras condicionales para asegurarse que las variables de la iteración son las correctas e
imprímalas.
Ejemplo
Supongamos que se desea sumar todos los múltiplos de 7 entre 7 y 100000.
int S=0;
for( int i=7;i<=100000; i+=7 ){
S+=i;
}
Ahora supongamos un caso particular, que necesitamos saber si el número 97930 también se está
sumando, entonces podríamos añadir:

66. int S=0;
for( int i=7;i<=100000; i+=7 ){
S+=i;
if (i==97930)
printf("n Si esta sumando!");
}
Si se muestra el mensaje en pantalla sabremos que ese número está siendo sumado.
No obstante este ejemplo es solo una suposición, ya que sabemos que 97930 es múltiplo de 7. Pues
también podemos averiguarlo con 97930 % 7, como el resultado del módulo es cero decimos que si
es múltiplo de 7.
8) Cuídese de los bucles sin fin. Cuando en un bucle la expresión booleana que la controla nunca
retorna false entonces habremos caído en un bucle infinito. Un poco de práctica nos será necesario
para no preocuparnos por estas.
Ejemplo
Este es una terrible forma de definir bucles:
int S=0;
while(S%2==0){
printf("n%d", S);
S+=2;
}
Este ejemplo muestra claramente que no puede ser variado la condición de la variable S dentro del
código como numero par, por lo tanto no tiene un adecuado fin el programa, porque se va a ejecutar
hasta que se acaben los recursos o porque se forzó a cerrarse.

67. 4.3 Introducción a C++
4.3.1 Reseña histórica
C++ tiene sus orígenes en la década de los 70 y en ese entonces fue creado como C y su función fue
para mantener el sistema operativo UNIX y su creador fue Bjarne Stroustrup de la compañía AT&T.
Previamente hubo lenguajes: BCPL -> B -> C -> C++, pero no fue contundente como lo es hoy C++, C
comparte muchas características de C++ pero C++ hoy es más popular por su manejo mejorado de
memoria, funcionalidades además de contar con programación orientada a objetos.
4.3.2 Directivas y palabras reservadas básicas.
El lenguaje C++ utiliza directivas o archivos de cabecera que proporciona información necesaria útil
para el programa. Para importar un archivo de cabecera se utiliza #include
iostream es el nombre de la biblioteca que contiene las definiciones de las rutinas que manejan las
entradas del teclado y el despliegue en la pantalla.
El espacio de nombres std ordena al compilador utilizar el espacio de nombres de std.
Un programa básico debe tener escrito al inicio del programa:
#include <iostream>
using namespace std;
fflush(stdin)
Es la función de C++ que va a eliminar los caracteres sobrantes en una entrada, el no utilizarla
provocará errores de entrada de múltiples variables. Se suele llamar a esta instrucción inmediatamente
luego de usar una instrucción scanf.
gets(<variable carácter>)
Funcion para ingresar una cadena de caracteres.
system("PAUSE")
Es el comando de C++ para detener la ejecución hasta que se presione la tecla < Enter >.
system("CLS")
Es el comando de C++ para borrar la pantalla de ejecución.
exit(0)
Termina inmediatamente el programa.

68. getchar()
La función que permite el ingreso por teclado de un carácter.
break
Permite salir o terminar a una estructura (Condicional o repetitiva por ejemplo).
continue
Permite continuar o iterar a una estructura repetitiva.
goto
Permite saltar o bifurcar el flujo del programa hacia una etiqueta.
Comentarios en C++
En C++ existen dos tipos de comentarios:
Para comentar una sola línea de código
//Comentario de una sola línea de código
Para comentar varias líneas de código
/*
Comentario de
varias líneas
de código
*/
4.3.3 Estructura de un programa en C++
Un programa en C++ se compone de directivas con archivos de cabecera, la función principal main,
declaración de variables e instrucciones validas de C++, a continuación se muestra un ejemplo sencillo
completo de un programa que envía por pantalla un mensaje “HOLA MUNDO”.
//Archivos de encabezado
#include <iostream>
using namespace std;
//Inicio de función principal
void main(){

69. //Instrucciones C++
printf("nHOLA MUNDOn");
system("PAUSE");
}
4.3.4 Creación, ejecución y depuración de un programa mediante Visual Studio .Net
Creación
Para crear
un
programa
en C++,
utilizaremos
Visual
Studio .Net

70. Ingresamos al
menú
Archivo –
Nuevo –
Proyecto
En el árbol de la
izquierda,
seleccionar Visual
C++
En el panel central
seleccionar Proyecto
Vacío.
En la parte inferior
escribir el nombre
del proyecto.
Finalmente Click en
Aceptar

71. Click en boton
de Nuevo y
seleccionar
Agregar Nuevo
Elemento.
En el panel
izquierdo,
seleccionar
Visual C++.
En el panel
central
seleccionar
Archivo C++.cpp).
En la parte
inferior escribir el
nombre del
archivo.
Click en Agregar.

72. Finalmente
tendremos una
pantalla con un
editor de código
fuente en el cual
introduciremos
nuestro código
C++.
Ejecución
Ahora ejecutaremos el siguiente programa con la tecla < F5 > o en el botón verde con símbolo de play
de la barra de menú:

73. Se mostrara la ventana de ejecución:
Depuración
Es el seguimiento y visualización del código de un programa mientras se ejecuta.
En el menú depurar se cuenta con algunas opciones de depuración:
Además se puede iniciar la depuración en un punto escogido por el desarrollador haciendo click, y
luego ejecutando:

74. Al pasar el mouse por encima de alguna instrucción de C++ muestra un pequeño mensaje.

75. También se puede
seleccionar variable
para una inspección
rápida.

76. Desplazarse
en el código
con los
botones de
depuración.
Detener la
ejecución o
depuración
presionamos
el botón
stop.