Cuaderno de C++

Apuntes prácticos de
programación en
C++
Estructuras secuenciales, selectivas,
repetitivas, punteros, funciones, vectores,
matrices, structs y minijuegos.
Abraham Sopla Maslucán
Lima, 2020
RESUMEN
A manera de resumen, expreso que este documento

ha sido elaborado como parte del material de
apoyo personal para el dictado de clases y presumo
que puede servir a mis colegas docentes y
estudiantes del curso de Programación I de la
Universidad Peruana de Ciencias Aplicadas y otras
universidades del país. El material guía que
proponemos, es lo suficiente práctico para la
resolución de problemas y en él se usó la metologia
PTP (Problema, Teoría, Práctica), mediante el cual se
parte encunciando un problema, se indican algunas
cuestiones teóricas puntuales que se requieren saber
para resolver el o los problemas, y finalmente se
codifica la solución en lenguaje C++. Abordaamos
todos los temas de un primer curso de programación,
en cada capítulo contiene problemas y ejercicios
resueltos detalladamente y propuestos; por ello, en
caso el tema a tratar en un capítulo epecífico le sea
familiar, recomendamos resolver los problemas
propuestos. Importa aclarar también que, en
cuando a la codificación no se ha tenido en cuenta
las reglas de lengua española. Finalmente, se
agradece por anticipado la sugerencias,
recomendaciones, propuestas de nuevos problemas
para la mejora del documento.
Este documento se terminó de escribir en febrero del 2020,
para el semestre académico 20201, y ha sido publicado
bajo la licencia Creative Commons . Reconocimiento-No
comercial-Compartir bajo la misma licencia 2.5 Perú.
Para ver una copia de dicha licencia, visite:
http://creativecommons.org/licenses/by-nc-sa/2.5/pe/
Sugerencias para la mejora del documento las

pueden hacer llegar a: [email protected]
1 Contenido
Capítulo 1: Algoritmo en diagrama de flujo de datos DFD ............................................... 5
Capítulo 2: Algoritmo en Diagrama Nassi Schneiderman (N-S) ..................................... 21
Capítulo 3: Algoritmo en pseudocódigo ............................................................................ 30
Capítulo 4: Identificadores y funciones del lenguaje ...................................................... 41
Capítulo 5: Identificadores de tipo cadena ...................................................................... 53
Capítulo 6: Operadores numéricos ..................................................................................... 71
Capítulo 7: Operadores lógicos y de relación .................................................................. 84
Capítulo 8: Funciones de programador ........................................................................... 100
Capítulo 9: Estructuras de control selectivo simple y doble ......................................... 115
Capítulo 10: Estructuras de control selectivo con anidamiento ................................... 131
Capítulo 11: Estructura de control selectiva combinada .............................................. 143
Capítulo 12: Estructura de control selectiva múltiple ..................................................... 154
Capítulo 13: Estructura de control repetitiva for .............................................................. 163
Capítulo 14: Estructura de control repetitiva while y do-while ..................................... 178
Capítulo 15: Estructura de control repetitiva while vs for ............................................... 190
Capítulo 16: Sentencias break, continue, exit ................................................................. 205
Capítulo 17: Gráficos con caracteres en la consola ..................................................... 214
Capítulo 18: Punteros y parámetros de funciones .......................................................... 236
Capítulo 19: Memoria dinámica ........................................................................................ 247
Capítulo 20: Arreglo unidimensional ................................................................................. 260
Capítulo 21: Matrices .......................................................................................................... 270
Capítulo 22: Registros con structs ...................................................................................... 282
Capítulo 23: Funciones dentro de structs ......................................................................... 296
Capítulo 24: Introducción a los minijuegos ..................................................................... 308
Anexo 1: Crear un proyecto en Visual C++ ..................................................................... 319
Anexo 2: Operaciones comunes en vectores................................................................. 324
Anexo 3: Operaciones básicas en matrices ................................................................... 328
Anexo 4: Operaciones en vectores de registros ............................................................. 334
Anexo 5: Manejar vectores y matrices mediante funciones ........................................ 337
Anexo 6: Guía rápida de PSeInt ........................................................................................ 348
Anexo 7: Juegos .................................................................................................................. 353
BIBLIOGRAFÍA........................................................................................................................ 362
Abraham Sopla Maslucán P á g i n a 4 | 362

Capítulo 1:
Algoritmo en diagrama de flujo
de datos DFD
1 PROBLEMA
1.1 Enunciado
Se requiere que un programa de computadora nos ayude a calcular el área de un
rectángulo. Además, indique los pasos que representa la solucion.
Iteraccion del usuario con la consola:
Computadora escribe : dame el valor del ancho

Usuario : 30
Computadora escribe : dame el valor del alto
Usuario : 20
Computadora escribe : 600
1.2 Cuestiones relacionadas al problema

• ¿Cuáles son las dificultades para resolver del problema? ¿Calcular el área del
rectángulo o la representación el algoritmo?
• ¿Cuál es el análisis del problema?
Idetificamos:
o Las entradas
o Los procesos y/o cálculos
o Las salidas
• ¿Cuál es la forma mas adecuada para representar el conjunto de pasos o

algoritmo que resuelve el problema? ¿Diagrama de flujo de datos, Nassi
Schneiderman, pseudocodigo, etc.?
• ¿Cuáles son las características de la herramienta que me falta conocer para
representar un algoritmo en DFD?

1.3 Análisis y propuesta de solución
Se pide representar mediante diagrama de flujo de datos los pasos a seguir para
calcular el área de un rectángulo, e implementarlo en un lenguaje.
Entradas Procesos y cálculos Salidas
largo, ancho area
1.4 Cuestiones teóricas

• ¿Cómo se construye un diagrama de flujo?
• ¿Cuáles son los elementos de un diagrama de flujo?
• ¿Qué herramienta de software se puede usar?
2 TEORÍA
2.1 Contenido
• Algoritmo y sus características
• Matriz de variables MV y matriz de entrada, proceso y salida EPS de un
algoritmo
• Formas para representar algoritmos
• Diagrama de flujo de datos de una estructura secuencial
• Diagrama de flujo de datos de una estructura selectiva
• Diagrama de flujo de datos de una estructura repetitiva
• Fases para la resolución de problemas usando la computadora.
2.2 Algoritmo y sus características

Algoritmo
Definición 1: Un algoritmo es un conjunto de pasos a seguir para resolver problema de

un mismo tipo cualitativo (proceso) o cuantitativo (cálculo numérico).
Definición 2: Un algoritmo es el proceso de descomponer una tarea en forma

secuencial y ordenada en un conjunto de acciones elementales, que manipulan y
transforman los datos de entrada, y por medio de algunas secuencias básicas de
control, los resultados que se obtienen son los objetivos de la tarea.

Partes de un algoritmo
Entrada Proceso de datos o Impresión de

de datos cálculo numérico resultados
Definición 3: Matemáticamente puede pensarse que un algoritmo es una secuencia

de pasos que nos permiten calcular los valores de una función para algún valor de
sus variable(s). Por ejemplo:
3𝑥 2 + 12𝑦
𝑓(𝑥, 𝑦) =
3−𝑥
Análisis algorítmico
Previamiente a la obtención del modelo f(x,y), el analista de sistemas interpretó un

problema de la realidad y lo plasmó en el modelo. Dado este modelo f(x,y), se
plantean casos, que son por ejemplo, hallar valores de f(35, -5), f(12, 10), f(17.85, 7),
etc., la solución pasa por implementar el modelo mediante un algoritmo, es decir que
nos permita hallar los valores de f(x, y) para valores de x y y en un rango dado.
Entonces, el algoritmo de f(x, y) tendrá como entrada un valor de x u otro para y,
3𝑥 2 +12𝑦
como operación de cálculo y como respuesta un valor de f(x, y). En otro tipo
3−𝑥
de problemas podemos considerar como operación algún procedimiento en vez de
cálculo, por ejemplo cuando se quiere ordenar datos, hallar el mayor de un conjunto
de datos, juntar datos, etc.
Características de un algoritmo
• Debe ser preciso e indicar un orden de realización de cada paso.

• Debe ser definido, es decir, si se repite varias veces, debe dar el mismo
resultado.
• Debe ser finito, es decir, debe terminar en algún momento.
2.3 Análisis del problema

MV: Matriz de variables
Al declarar las variables es importante se tenga en cuenta los nombres de las

variables, tipo y su descripción breve y precisa.
Tipo de datos Nombre de las variables con Descripción de cada una

letras de las variables
Entero Base Base de un triángulo
Real Promedio Promedio de notas
MEPS: Matriz de entrada, proceso y salidas

Es fácil crear el algoritmo después de haber completado la matriz MEPS, teniendo en
cuenta que algunas variables de la MV se usan como entradas en la MEPS:
Entradas Procesos y cálculos (instrucciones y Salidas

estructuras de control)
Q IP=Q*PU IP
PU
Valores de Operaciones o procedimientos a realizar Resultados que
entrada se deben
registrados mostrar
usando el
teclado
2.4 Formas para representar algoritmos
Algunas formas para representar la solución de problemas mediante algoritmos son:
• Diagrama de Flujo
• Diagramas N-S (Nassi-Schneirderman)
• Pseudocódigo
• Diagrama de Warnier
2.5 Diagrama de flujo de datos

Para crear y ejecutar diagrama de flujo de datos podemos usar algunas herramientas
como DFD y PseInt. Para dibujar con facilidad este tipo de diagramas podemos usar
Visio (de paga de la familia Microsoft) y Click Charts (de paga y creado por NCH).
2.5.1 Elementos de un diagrama de flujo de datos

Símbolo Nombre Descripción
Terminal Se usa para representar el inicio o fin de un
programa, puede también representar una parada
o interrupción programada que sea necesario
realizar en un programa
Entrada/Salida Usado para representar la entrada o salida de datos
Proceso Representa cualquier tipo de operación que pueda

originar cambio de valor, formato oposición de la
información almacenada en memoria,
operaciones aritméticas.
Impresora Se utiliza en lugar del símbolo de salida.
Conector Sirve para conectar partes de un diagrama en una

misma hoja.

Condición Indica operaciones lógicas o de comparación entre
datos, se evalúa y dependiendo del resultado se
tomará una decisión.
Indicador de Indica el sentido de ejecución de las operaciones.

dirección o
línea de flujo
Línea Se usa para unir dos símbolos
conectora
Conector Conexión entre dos puntos situados en páginas

diferentes.
subrutina Se puede usar para indicar la llamada a una

subrutina (proceso predeterminado) o a un módulo
independiente del programa.
Pantalla Se puede utilizar en lugar del símbolo de salida.
Teclado Se puede utilizar en lugar del símbolo de entrada.
2.6 Diagrama de flujo de datos de una estructura secuencial

Estructura secuencial Ejemplo
• Una estructura secuencial esta combinada entre acciones de: escritura, lectura
e impresión.
• En la construcción del diagrama de flujo del algoritmo se indican las acciones
secuencialmente, no hay condicionales y estructuras repetitivas en el camino.

2.7 Diagrama de flujo de datos de una estructura selectiva
Selectiva simple
Estructura selectiva simple Ejemplo
• Es importante destacar la aparición de una condición, cuyo valor es lógico, es

decir falso (false) o verdadero (true), solo uno a la vez. En este caso, si el valor
de verdad de la condición es verdad, se ejecuta una acción y en caso que sea
falsa se continúa la secuencia. En algunos lenguajes de programación, el
número 0 representa falso, y cualquier otro número diferente de 0 representa
verdad. Ejemplo, para edad = 10, la condición (edad>18) es false ó 0.
• Ya en la construcción del diagrama de flujo del algoritmo se indican las
acciones secuencialmente y en el camino hay una estructura condicional
simple que nos permite cambiar la secuencia dependiendo del valor de verdad
de la condición. Tenemos la oportunidad de elegir una sola opción (camino o
decisión) entre una opción.
Selectiva doble
Estructura selectiva doble Ejemplo
• Es importante destacar la aparición de una condición (cuyo resultado o valor es

lógico, es decir falso o verdadero). En este caso, si el valor de verdad de la
condición es verdad, se ejecuta la acción 1 y en caso que sea falsa se ejecuta
la acción 2. Recuerde, que en algunos lenguajes, el 0 representa falso, y
cualquier otro número representa verdad.
• En la construcción del diagrama de flujo del algoritmo, se indican las acciones
secuencialmente y en el camino hay una estructura condicional doble. Después
de evaluar la condición, tendremos la oportunidad de elegir una opción
(camino o decisión) de entre las dos posibles.

Selectiva múltiple
Estructura selectiva múltiple Ejemplo

secuencialmente y si en el camino hay una estructura selectiva múltiple
tendremos la oportunidad de comparar el valor del selector con cada uno de
los valores, si la comparación con algún valor es verdadera entonces se ejecuta
la acción (camino o decisión) que corresponde. La estructura tiene muchas
opciones y algoritmo seleccionará solo una de entre n opciones.
• Si num es 2, entonces solamente se ejecuta la operación des=num*0.2
• Para calquier otro valor de num diferecnte de 1, 2, y 3 se ejecuta des=num*0.4.
2.8 Diagrama de flujo de datos de estructuras repetitivas

Repetitiva para
Hay acciones que se repinten muchas veces, pero la cantidad de repeticiones es
determinada, es decir que cada que se ejecuta el algoritmo de antemano sabemos
exactamente cuantas repeticiociones se harán. Una estructura repetitiva para tiene
tres elementos idiscutibles que debemos propcurar en identificar:
• Inicio: Variable también se le llama contador, inicio es el primero valor de

Variable,
• Condición : se evalua cada que se entra al bucle
• Incremento: se indica los saltos del contador
En la primera entrada a un bucle se inicializa el contador, se valida la condicion y
se incrementa el contador. A partir del la segunta entrada, siempre debe validarse la
condicion e incrementarse el contador. Si la condicion es verdadera se ejercutan las
intrucciones.

Estructura Repetitiva para Ejemplo
• Hay acciones que se repiten muchas veces, pero la cantidad de repeticiones

es determinada, o previamente sabemos el punto inicial y el punto final de
ejecución. Tenemos la oportunidad de repetir una acción(s) un número
determinado de veces.
secuencialmente y en el camino hay una estructura repetitiva para.
• Algunos problemas que podemos resolver con para: Imprimir 30 veces el término
“Bienvenido”; sumar los 100 primeros números naturales; sumar los números de
la sucesión: 10, 11, 12, 13, …, 19.
Repetitiva mientras
Hay acciones que se repiten muchas veces, pero la cantidad de repeticiones es
indeterminada, es decir que cada que se ejecuta el algoritmo no sabemos
exactamente cuantas repeticiociones se harán. Esta estrutura tiene una condición al
inicio y dentro del bucle, una instrucción que hace que la condición inicial sea falsa,
permitiéndonos salir del bucle cuando sea necesario. Tenemos la oportunidad de
repetir una acción(s) un número indeterminado de veces, por ejemplo, leer e imprimir
valores hasta que el usuario pulse una tecla o escriba un número especial.
También se puede usar mientras en vez de para, ello es importante definir la

inicializacion del contador, la condición, y un incremento o modificacion de
contador.

Estructura repetitiva mientras Ejemplo
• En algún momento (dentro de • En el momento que leamos un 0 en la

Bloque) se le asignará a la variable el variable número, se termina las
valor X, lo que hara que la condicion repeticiones. Se imprime la suma de
sea falsa y se terminen las todos los números leídos diferentes
repeticiones de cero.
En algunos casos, podemos usar while en vez de for. La estructura while puede ser
considerada como más genérica que la estructura for.
Estructura repetitiva mientras Ejemplo
Por ejemplo se puede usar while para: sumar los numeros naturales empezando
desde 10 hasta 19 de 1 en 1, imprimir 30 veces el término “Bienvenido”, sumar los
100 primeros números naturales, para ingresar numeros hasta que se escriba un 0 y
termine el programa.

Repetitiva hacer mientras “do while”
Esta estructura ejecuta el bloque del bucle, si o si, por lo menos una vez.
Estructura repetitiva hacer-mientras Ejemplo
• Hay acciones que se repinten muchas veces, pero la cantidad de repeticiones

es indeterminada.
secuencialmente y en el camino hay una estructura repetitiva hacer mientras,
incluye la condición al final, esta condición debe ser verdadera para que se dé
una repetición.
• Algunos problemas que podemos resolver con hacer mientras: Imprimir 30 veces
el término “Bienvenido”; sumar los 100 primeros números naturales; sumar los
números de la serie: 10, 11, 12, 13, …, 19
3 PASOS PARA ESCRIBIR UN PROGRAMA

3.1 Detallado
1. Definición del problema
2. Análisis de la problema
a) Datos entrada
b) Restricciones
c) Datos de salida
3. Diseño del algoritmo
a) Representación del algoritmo
b) Diseño del juego de datos de prueba
4. Codificación

5. Ejecución, depuración y validación
6. Documentación
a) Interna
b) Externa
7. Mantenimiento
3.2 Cuando el algoritmo es pequeño

Suficiente tener en cuenta:
1. Análisis del problema: identificar la entradas, operaciones y salidas
2. Diseño o representación de la solución en un algoritmo (trasladar los datos del

análisis al algoritmo)
3. Pasar el algoritmo a un programa (codificación).
4. Ejecución y validación del programa.
4 SOLUCIÓN AL PROBLEMA
4.1 Matriz de variables
Tipo Nombre Descripción
Real largo Largo del rectángulo
Real ancho Ancho del rectángulo
Real area1 Área del rectángulo
4.2 MEPS: Matriz de entrada, proceso y salida

Entrada Proceso (instrucción y estructuras de Salida
control)
largo, ancho Área=largo*ancho area
1 No es necesario respetar las reglas ortográficas, recuerde que área lleva tilde.

4.3 Diagrama de flujo
4.4 Código
#include<iostream>
using namespace std;
void main()
{
int largo;
int ancho;
int area;
largo = 90;
ancho = 60;
area = largo * ancho;
cout << area;
}
4.5 Resultado
5400

5 EJERCICIOS RESUELTOS
Resuelto 1. Un estudiante realiza cuatro exámenes durante el semestre, los
cuales tienen la misma ponderación. Realice el diagrama de flujo que
represente el algoritmo correspondiente para obtener el promedio de las
notas obtenidas.

Real N1, N2, N3, N4 Notas obtenidas
Real S Suma de notas
Real P Promedio de notas

control)
N1, N2, N3, N4 S= N1+N2+N3+N4 P
P=S/4
Diagrama de flujo
Resuelto 2. Una tienda ha puesto en oferta la venta de un producto

ofreciendo un determinado porcentaje de descuento sobre el importe
de la compra. Realice un algoritmo y represéntelo mediante un
pseudocódigo que determine el importe de la compra, el importe del
descuento y el importe a pagar por la compra de cierta cantidad de
unidades del producto.

Matriz de variables

Entero Q Cantidad
Real PU Precio unitario
Real D Porcentaje de
descuento
Real IC Importe de la compra
Real IP Importe a pagar
MEPS: Matriz de entradas, proceso y salidas

control)
Q, PU, D IC=Q*PU IC
ID=IC*D/100 ID
IP=IC-ID IP
Diagrama de flujo
Resuelto 3. Se desea calcular la potencia eléctrica de circuito del Gráfico 1.

Realice un diagrama de flujo y el pseudocódigo que representen el algo-
ritmo para resolver el problema. Considere que: P = V*I y V = R*I.
Gráfico 1. Circuito eléctrico

Matriz de variables

Real R Resistencia en ohmios (Ω)
Real V Tensión en voltios (V)
Real I Intensidad de corriente
eléctrica en amperios (A)
Real P Potencia en vatios (W)

control)
V, R I=V/R P
P=V*I
Diagrama de flujo
6 EJERCICIOS PROPUESTOS
Propuesto 1. Construya un diagrama de flujo y pseudocódigo que
representen el algoritmo para determinar cuánto dinero ahorra una persona
en un año si considera que cada semana ahorra 15% de su sueldo (considere
cuatro semanas por mes y que no cambia el sueldo).
Propuesto 2. Una empresa desea determinar el monto de un cheque que
debe proporcionar a uno de sus empleados que tendrá que ir por equis
número de días a la ciudad de Monterrey; los gastos que cubre la empresa
son: hotel, comida y 100.00 pesos diarios para otros gastos. El monto debe
estar desglosado para cada concepto. Realice un diagrama de flujo y
pseudocódigo que representen el algoritmo que determine el monto del
cheque.

Propuesto 3. Construya el diagrama de flujo y pseudocódigo que
representen el algoritmo para determinar el promedio que obtendrá un
alumno considerando que realiza tres exámenes, de los cuales el primero y
el segundo tienen una ponderación de 25%, mientras que el tercero de 50%.
7 INVESTIGACIÓN
¿Cómo se representan los algoritmos en pseudocódigo?
8 EVALUACIÓN
Esta práctica dirigida no será evaluada
9 ANEXOS
Ejercicios matemáticos que debería conocer:
1 Hallar f (15), en 𝑓(𝑥) = 𝑥 2 − 3𝑥 + 2

2 Hallar f (7.87), en 𝑓(𝑥) = 𝑥 3 − 𝑥 2

Capítulo 2:
Algoritmo en Diagrama
Nassi Schneiderman (N-S)
1 PROBLEMA
1.1 Enunciado
Construir el diagrama N-S de un algoritmo que calcule el área de un triángulo.
Iteraccion con el usuario:
Computadora escribe : dame el valor de la base
Usuario : 30
Computadora escribe : dame el valor de la altura
Usuario : 20
Computadora escribe : 300

• ¿Cuáles son las dificultades para resolver el problema? ¿Calcular el área del
triángulo o la representación del algoritmo?
• Idetifica:
a) Las entradas
b) Los procesos y cálculos
c) Las salidas
• ¿Cuál será el algoritmo que resuelve el problema?

• ¿Cuáles son las características de alguna herramienta que me falta conocer
para representar el algoritmo en diagrama N-S?

En este caso, nos piden representar mediante diagrama N-S los pasos a seguir para
calcular el área de un triángulo.
Cuáles son las MEPS: Matriz de entradas, proceso y salidas
Entradas Cálculos Salidas

base, altura area=base*altura/2 area

• ¿Cómo se escribe un diagrama N-S?
• ¿Cuáles son los elementos de un diagrama N-S?
• ¿Qué herramienta de software se puede usar para construir un diagrama N-S?
2 TEORÍA
2.1 Contenido
• Diagrama N-S (Nassi-Schneirderman)
• Estructura de control secuencial
• Estructura de control de selección
• Estructura de control repetitiva
2.2 Diagrama N-S (Nassi-Schneirderman)

Para crear y ejecutar diagrama Nassi Schneiderman (N-S) podemos usar PseInt. Para
dibujar con facilidad este tipo de diagramas podemos usar Structorized, Visio (de
paga de la familia Microsoft) y Click Charts (de paga y desarrollado por NCH).

2.3 Estructura de control secuencial
Acción 1
Acción 2
...
Acción n
2.4 Estructura de control de selección

2.4.1 Estructura de control de selección doble
Condición
Verdad Falso
Acción1 Acción2
Ejemplo de estructura de control doble
Ejemplo de estructura de control de selección anidada

2.4.2 Estructura de control selectiva múltiple
variable
valor1 valor2 valor3 Default
Accion1 Accion2 Accion3 Accion4
2.5 Estructura de control repetitiva

2.5.1 Para
Bucle para Ejemplo
Variable:= inicio, condición,incremento
Acción
2.5.2 Mientras
Bucle mientras Ejemplo
Mientras condición
Acción

3.1 Variables

Real B Base
Real H Altura
Real A Área
MEPS: Matriz de entrada, proceso y salida
Entrada Procesos Salida

(instrucciones y estructuras de control)
B, H A=B*H/2 A
3.2 Diagrama N-S
Resuelto 1. Se requiere determinarel tiempo que tarda una persona en llegar de
una ciudad a otra en bicicleta, se sabe que lleva una velocidad constante.
Realice un algoritmo para resolver el problema representado mediante un
diagrama N-S.

Real V Velocidad de la
bicicleta
Real D Distancia entre las
ciudades
Real T Tiempo que demora el
recorrido

MEPS: Matriz de entradas, procesos y salidas

control)
D, V T=D/V T
Diagrama N-S
Resuelto 2. El cálculo del pago mensual de un empleado de una empresa se

efectúa de la siguiente manera: el sueldo básico se calcula en base al número
total de horas trabajadas basado en una tarifa horaria; al sueldo básico, se le
aplica una bonificación del 18% del mismo obteniéndose el sueldo bruto; al sueldo
bruto, se le aplica un descuento del 12% obteniéndose el sueldo neto. Realice un
algoritmo y represéntelo mediante un diagrama N-S que calcule e imprima el
sueldo básico, el sueldo bruto y el sueldo neto de un trabajador.

Entero H Total de horas
trabajadas
Real T Tarifa por hora
Real B Sueldo básico
Real Bo Bonificación de 18%
Real Sb Sueldo bruto
Real Sn Sueldo neto

control)
H, T B=H*T B, Sb, Sn
Bo=0.18*B
Sb=B+Bo
Sn=Sb-0.12*Sb

Diagrama N-S
Resuelto 3. Se requiere obtener el área de la figura de la forma A (Ver figura) para

lo cual se le solicita que realice un algoritmo y lo represente mediante un
diagrama N-S.

Real R Radio del semicírculo
Real H Hipotenusa
Real X Altura
Real As Área del semicírculo
Real At Área del triángulo
Real A Área total

control)
R, H X=SQRT(H2-R2) A
As=3.1416*R2/2
At=R*X
A=As+At

Diagrama N-S
Propuesto 1. Realice un diagrama de flujo y pseudocódigo que representen el
algoritmo para determinar cuánto dinero ahorra una persona en un año si
considera que cada semana ahorra 15% de su sueldo (considere cuatro semanas
por mes y que no cambia el sueldo).
Propuesto 2. Una empresa desea determinar el monto de un cheque que
debe proporcionar a uno de sus empleados que tendrá que ir por equis número
de días a la ciudad de Monterrey; los gastos que cubre la empresa son: hotel,
comida y 100.00 pesos diarios para otros gastos. El monto debe estar desglosado
para cada concepto. Realice un diagrama de flujo y pseudocódigo que
representen el algoritmo que determine el monto del cheque.
Propuesto 3. Realice el diagrama de flujo y pseudocódigo que representen el
algoritmo para determinar el promedio que obtendrá un alumno considerando
que realiza tres exámenes, de los cuales el primero y el segundo tienen una
ponderación de 25%, mientras que el tercero de 50%.
Propuesto 4. Realice un algoritmo y represéntelo mediante un diagrama N-S
que permita mostrar el estado del alumno, según la nota final del curso. Para ello
debe tener en cuenta los siguientes criterios:
• Si la nota es menor de 12.50 está desaprobado.
• Si la nota es mayor de 12.50 y menor de 20 está aprobado.

6 INVESTIGACIÓN
¿Cómo se representan los algoritmos en pseudocódigo?
7 EVALUACIÓN

Capítulo 3:
Algoritmo en pseudocódigo
1 PROBLEMA
1.1 Enunciado
Una empresa constructora vende terrenos con la forma A (ver figura). Realice
un algoritmo y represéntelo mediante un pseudocódigo para obtener el área
respectiva de un terreno de medidas de cualquier valor.

• ¿Cuál es la dificultad principal aquí? ¿Calcular el área de la Forma A o la
representación del algoritmo?
Idetifica:
• Las entradas del algoritmo

• Los procesos y cálculos que se requieren para solucionar el problema
• Las salidas del algoritmo
• ¿Cuál será la representación del conjunto de pasos o algoritmo que expresa
la solución al problema?
• ¿Cuáles son las características de alguna herramienta que me falta conocer
para representar un algoritmo en pseudocódigo?

En este caso, nos piden representar mediante pseudocódigo los pasos a seguir para
calcular el área de la figura.
Entradas, procesos y salidas del algoritmo:

A, B, C … Area
• ¿Cómo se escribe un pseudocódigo?
• ¿Cuáles son los elementos de un pseudocódigo?
• ¿Qué herramienta de software se puede usar?
2 TEORÍA
2.1 Contenido
• Representación de un algoritmo mediante pseudocódigo
• Pseudocódigo de las estructuras de control secuencial, de selección y
repetitiva
• Pseudocódigo de una función y un procedimiento
2.2 Pseudocódigo
Para crear y ejecutar un pseudocódigo podemos usar PseInt. Estos pseudocodigos
pueden convertirse automáticamente a un diagrama N-S o DFD.
2.2.1 Declarar variables

Definir n,u Como Entero
Dimension Prec[5], Cant[4,5]
Definir apellido Como Caracter
2.2.2 Secuencial
Proceso ejemploSecuencial
Definir amigo Como Caracter
Escribir "escriba el nombre"
Leer amigo
Escribir "Hola apreciado ", amigo
FinProceso
2.2.3 Selección simple
Proceso ejemploSeleccionSimple
Definir edad Como Entero
Escribir "dame tu edad "
Leer edad
si edad<18 Entonces
Escribir "Usted es menor de edad: "
FinSi
FinProceso

2.2.4 Selección doble
Proceso ejemploSeleccionDoble
Definir a, b Como Entero
Escribir "Dame el valor de a "
Leer a
Escribir "Dame el valor de b "
Leer b
si a>b Entonces
Escribir "El número mayor es ", a
SiNo
Escribir "El número mayor es ", b
FinSi
FinProceso
2.2.5 Selección múltiple
Proceso ejemploSeleccionMultiple
Definir numeroDia como entero
escribir "escriba un numero entre 1 y 7";
Leer numeroDia
Segun numeroDia Hacer
1:
Escribir "is Friday"
2:
Escribir "is Saturday"
3:
Escribir "is Sunday"
De Otro Modo:
Escribir "Uf no es fin de semana"
Fin Segun
FinProceso
2.2.6 Para
Proceso ejemploPara
Escribir 'dame el valor de u '
Leer u
Para n<-1 Hasta u Hacer
Escribir n
FinPara
FinProceso
2.2.7 Mientras
Proceso ejemploMientras
Definir n, u Como Entero
Escribir "dame el valor de u "
Leer u
n<-1
Mientras n<u Hacer
Escribir n
n<-n+1
Fin Mientras
FinProceso

2.2.8 Repetir
Proceso ejemploRepetir
Escribir "dame el valor de u: "
Leer u
n<-1
Repetir
Escribir n
n<-n+1
Hasta Que n>u
FinProceso
2.2.9 Función
SubProceso resultado <- hallaValor(vala,valb,vald)
Definir resultado Como Real
resultado= (-valb + vald) / (2 * vala)
FinSubProceso
Proceso ecuacionCuadratica
Definir a, b, c, discriminante, x1, x2 Como Real
Escribir "Ingrese los coeficiente a: "
Leer a
Escribir "Ingrese los coeficiente b: "
Leer b
Escribir "Ingrese los coeficiente c: "
Leer c;
discriminante = b^2-4 * a * c;
discriminante= rc(discriminante);
x1 = hallaValor(a, b, discriminante);
x2 = hallaValor(a, b, -discriminante);
Escribir "La primera raiz es: " x1

Escribir "La segunda raiz es: " x2;
FinProceso
2.2.10 Procedimiento
SubProceso hallaValor(vala,valb,vald)
Escribir resultado
FinSubProceso
Leer a
Leer b

Leer c;
discriminante= rc(discriminante)
Escribir "La primera raiz es: "
hallaValor(a, b, discriminante);
Escribir "La segunda raiz es: "
hallaValor(a, b, -discriminante);
FinProceso
3 SOLUCIÓN AL PROBLEMA PROPUESTO

Matriz de variables

Real ladoa A
Real ladob B
Real ladoc C
Real area1 Área superior
Real area2 Área inferior
Real areaTotal Área superior e inferior
juntas
Entrada Cálculos y procesos Salida

ladoa, ladob, area1=(ladob*(ladoa-ladoc))/2 areaTotal
ladoc area2=ladob*ladoc
areaTotal=area1+area2
3.2 Pseudocódigo
areaFiguraV1.psc
Proceso areaFigura
Definir ladoa, ladob, ladoc Como Real
Definir area1, area2, areaTotal Como Real
Leer ladoa
Leer ladob
Leer ladoc
area1=(ladob*(ladoa-ladoc))/2
area2=ladob*ladoc

Imprimir 'El area es: ', areaTotal
Escribir 'El area es: ', areaTotal
FinProceso
3.3 Resultado
> 15
> 20
> 12
El area es: 270
El area es: 270
areaFiguraV2.psc
Proceso areaFigura
Definir ladoa, ladob, ladoc Como Real
Definir area1, area2, areaTotal Como Real
Escribir "Valor del lado A:"
Leer ladoa
Escribir "Valor lado B: "
Leer ladob
Escribir "Valor del lado C: "
Leer ladoc
area1=(ladob*(ladoa-ladoc))/2
area2=ladob*ladoc
Escribir 'El area es: ',areaTotal
FinProceso
Resultado
Valor del lado A:

> 10
Valor lado B:
> 15
Valor del lado C:
> 20
El area es: 225

Resuelto 1. Una tienda ha puesto en oferta la venta de un producto
ofreciendo un determinado porcentaje de descuento sobre el importe
de la compra. Realice un algoritmo y represéntelo mediante un
pseudocódigo que determine el importe de la compra, el importe del
descuento y el importe a pagar por la compra de cierta cantidad de
unidades del producto.
Matriz de variables

Real V Velocidad de la bicicleta
Real D Distancia entre las ciudades
Real T Tiempo que demora el recorrido
MEPS

control)
D T=D/V T
V
Diagrama N-S
Resuelto 2. El cálculo del pago mensual de un empleado de una empresa se

efectúa de la siguiente manera: el sueldo básico se calcula en base al
número total de horas trabajadas basado en una tarifa horaria; al sueldo
básico, se le aplica una bonificación del 18% del mismo obteniéndose el
sueldo bruto; al sueldo bruto, se le aplica un descuento del 12%
obteniéndose el sueldo neto. Realice un algoritmo y represéntelo mediante
un diagrama N-S que calcule e imprima el sueldo básico, el sueldo bruto y
el sueldo neto de un trabajador.


Entero cantidadDeUnidades Cantidad de unidades a
comprar
Real descuento Porcentaje de descuento
por la compra
Real precioUnitario Precio unitario del producto
Real importe Importe a pagar
Real importeConDescuento Importe con descuento a
pagar
Real importePagar Importe total a pagar
Entrada Proceso (instrucción y estructuras de control) Salida

H importe=cantidadDeUnidades*precioUnitario importePagar
T importeConDescuento=(descuento/100)*importe
importePagar=importe-importeConDescuento
Diagrama N-S
Pseudocódigo
Algoritmo Ejercicio6
//Variables a usar en la resolución del caso
Definir cantidadDeUnidades Como entero
Definir descuento como entero
Definir precioUnitario como real
Definir importe, importeConDescuento, importePagar como real
//Entradas

Escribir "Dame la cantidad de unidades a comprar"
Leer cantidadDeUnidades
Escribir "Dame el precio unitario del producto"
Leer precioUnitario
Escribir "Dame el procentaje de descuento"
Leer descuento
//Procesos o cálculo
importe=cantidadDeUnidades*precioUnitario
importeConDescuento=(descuento/100)*importe
importePagar=importe-importeConDescuento
//Salidas
Escribir importe
Escribir importeConDescuento
Escribir importePagar
FinAlgoritmo
Resultado
Dame la cantidad de unidades a comprar

> 10
Dame el precio unitario del producto
> 15
Dame el procentaje de descuento
> 25
150
37.5
112.5
Resuelto 3. Se requiere obtener el área de la figura de la forma A (Ver figura)
para lo cual se le solicita que realice un algoritmo y lo represente mediante
un diagrama N-S.
Matriz de variables

Real R Radio del semicírculo
Real H Hipotenusa
Real X Altura
Real As Área del semicírculo
Real At Área del triángulo
Real A Área total


control)
R, H X=SQRT(H2-R2) A
As=3.1416*R2/2
At=R*X
A=As+At
Diagrama N-S
Propuesto 1. Una operadora necesita calcular el recibo de consumo, el
cual se obtiene de la siguiente manera:
• Si consume 4 GB o menos paga S/. 50 por mes.
• Si consume más de 4 GB, hasta de 8GB paga S/. 85 por mes y por cada
GB de consumo adicional pagará S/. 4.50
Realice un algoritmo para resolver el problema y represéntelo mediante un
pseudocódigo.
Propuesto 2. La universidad ofrece una beca de 30% para los estudiantes
que cumplan ciertos requisitos, luego de haber culminado el primer ciclo de
su carrera. Los requisitos son los siguientes
• Tener un promedio ponderado mayor o igual a 15.
• No tener ninguna falta.
Con esta información elabore un algoritmo y represéntelo mediante un
pseudocódigo que determine el otorgamiento de una beca. Los datos que
debe ingresar son la nota y la cantidad de faltas.
Propuesto 3. Elabore un algoritmo y represéntelo mediante un
pseudocódigo en donde se solicite ingresar un número entero de 3 cifras
únicamente y verificar si el número ingresado es correcto, si no es de tres
cifras mostrar un mensaje de error. Finalmente, mostrar el número ingresado
al revés.
Ejemplos:

• Si se ingresa un número de 4 cifras debe mostrar un mensaje de error:
“Número incorrecto”
• Si se ingresa el número 263 debe mostrar el número al revés: 362
pseudocódigo en donde se ingrese un número entero de 3 cifras
únicamente y luego se debe determinar si el número ingresado es capicúa.
Un número capicúa se lee igual de izquierda a derecha que derecha a
izquierda.
Ejemplos: 161, 343, 565.
• Si el número que se ingresa es incorrecto, esto significa no tiene 3 cifras,
se debe mostrar un mensaje: “Número incorrecto”
• Si el número que se ingresa es correcto, se debe mostrar un mensaje: “Es
número capicúa” o “No es número capicúa”
pseudocódigo en donde se solicite ingresar un número entero positivo en el
intervalo cerrado de 1 a 100. Verificar si el número ingresado es correcto, si
no es correcto mostrar un mensaje de error. Finalmente, luego de ingresar un
número correcto, mostrar cuántos dígitos tiene el número ingresado.
Ejemplos:
• Si se ingresa un número de 1 cifra debe mostrar el siguiente mensaje: “El
número tiene 1 dígito”
• Si se ingresa un número de 2 cifras debe mostrar el siguiente mensaje: “El
número tiene 2 dígitos”
• Si se ingresa un número de 3 cifras debe mostrar el siguiente mensaje: “El
número tiene 3 dígitos”.
6 INVESTIGACIÓN
Represente los algoritmos de los ejercicios propuestos en diagramas N-S y DFD
7 EVALUACIÓN

Capítulo 4:
Identificadores y funciones
del lenguaje
En este apartado aprovechamos para hacer escribir programas que requieren de

estructuras condicionales, sin embargo no se usa estructuras condicionales
del leguaje if, if-else, switch.
1 PROBLEMA
1.1 Enunciado
Michaela, Efraín y Even aportan cantidades de dinero para formar un
capital. Elabore un programa en C++ que permita determinar el capital total
formado y el porcentaje de dicho capital que aporta cada uno.

• ¿Cuál crees que es el problema principal aquí? Calcular el capital
formado y el porcentaje de aportes de cada socio, el algorirmo y
programa que nos permita realizar esos cálculos correstamente.
Identifique:
o Las entradas
o Los procesos y cálculos que se requieren para solucionar el
problema
o Las salidas
• ¿Cuál será la representación del conjunto de pasos o algoritmo que
resuelve el problema?
• ¿Cuáles serían las características del lenguaje C++ que me falta
conocer?

De aquí adelante, antes que preocuparnos por los formalismos de representar
las soluciones, interesan más las soluciones mismas de cada problema.
En este propblema, se requiere calcular el porcentaje de aportes hechos por

tres inversionistas para completar un capital.

aporteMi, ¿? total, porcentajeMi,
aporteEf, porcentajeEf,
aporteEv porcentajeEv

• ¿Cómo se escribe un programa en C++?
• ¿Cuáles son los elementos de un programa en C++?
• Qué herramienta de software se puede usar para escribir codigo en C++?
2 TEORÍA
2.1 Contenido
• Estructura general de un programa en C++
• Declarar variables
• Tipos de variables
• Definición de una constante en C++
• Constantes especiales – macros
• Funciones matemáticas del lenguaje C++
• Entrada y salida de datos
2.2 Estructura general de un programa en C++

Para crear y ejecutar diagrama en código C++ podemos usar visual C++ (de
paga), Dev-C++, Zinjal.
Partes de un programa en C++
PARTES PROGRAMA
Declaramos las librerías #include<iostream>
Indicamos los espacios de using namespace std;
trabajo que corresponde a la
librería
Podemos escribir //Por ahora no usamos variables
comentarios
El cuerpo de la función void main()
principal main {
/*Aquí se declaran variables locales*/
cout << "Hola mundo" << endl;
system("pause");
}
2.3 Las variables
Una variable es un identificador
Una variable, constante o macro es un identificador. Las variables y las
constantes se usan para separar un espacion de memoria en el que se guardará
el valor de un dato.
Estructura
<Tipo de dato> <Nombre variable>;

Por ejemplo:
int edad;
double estatura;
bool _esVerdadero_o_no;
char Mi_1_era_letra;
long long enteroLargo;
unsigned int no_Acepta_Negativos;
int x1, x2, x3, x4;
2.4 Tipo de variables

Tipo Descripción Rango Ejemplo
bool Valor binario true bool dato = false;

verdadero o falso. false dato = true;
char Valor entero que –128 a 127 char letra = ‘A’;
representa un ó letra = ‘\n’;
carácter de la tabla 0 a 255 compilado con /J letra = 65;
ASCII
short Valor entero de 2 –32,768 short x = 94;
bytes 32,767 x = -54;
int Valor entero de 4 –2,147,483,648 int x = 1598;
bytes 2,147,483,647 x = -988574;
unsigned Valor entero positivo 0 unsigned int x = 9887;
int de 4 bytes 4,294,967,295 x = 98745;
long long Valor entero de 8 –9,223,372,036,854,775,808 long long x = 684574;
bytes 9,223,372,036,854,775,807 x = -998564;
float Valor decimal de 4 3.4E +/- 38 (7 dígitos) float x = 45.6;
bytes x = -98.58;
double Valor decimal de 8 1.7E +/- 308 (15 dígitos) double x = 9878.568;
bytes x = -98745.668;
void Tipo de dato nulo.
Representa la
ausencia de valor.
2.5 Declarar constantes en C++
Un identificador constante no nos permite modificar su valor mientras se ejecute
el programa. Cuenta con un tipo de dato, su valor se asigna al momento que
se define.
Estructura
const <Tipo de dato> <Nombre constante> = <valor>;
Por ejemplo:
const int ValorMaximo = 50;
const double IGV = 18.00;
const char PrimeraLetra = 'A';

2.6 Constantes especiales – macros
Un identificador macro no modifica su valor mientras se ejecute el programa,
tampoco tiene tipo de dato. Un ejemplo de su uso es para almacenar el tamaño
de un vector estático, el mismo que no varía mientras dura el programa.
Estructura
#define <Nombre MACRO> <valor>
Por ejemplo:
#define IGV 18.00
#define PrimerMes 3
#define PalabraClave “Universidad”
2.7 Funciones matemáticas del lenguaje C++
Función Formato
Redondear un decimal a entero round(x)
Raíz cuadrada sqrt(x)

El valor entero superior a x y más cercano a él ceil(x)
El mayor valor entero que es menor que x floor(x)
Exponencial de x (e elevado a x) exp(x)
Valor absoluto fabs(x)
Resto de la división x/y fmod(x,y)
Logaritmo natural (o neperiano, en base "e") log(x)
Logaritmo en base 10 log10(x)
x elevado a y pow(x,y)
Seno sin(x)
Seno hiperbólico sinh(x)
Arco seno asin(x)
Coseno cos(x)
Arco coseno acos(x)
Coseno hiperbólico cosh(x)
Tangente tan(x)
Arco tangente atan(x)
Tangente hiperbólica tanh(x)
Arco tangente de y/x (por si x o y son 0) atan2(y,x)
2.8 Funciones matemáticas
#include<iostream>
//Aquí se declaran variables globales
void main()
{
setlocale(LC_ALL, "spanish");
float x = 2.28, y = 2;
cout << "Redondear un decimal a entero, 12.58 : " << round(12.58) << endl;

cout << "Raíz cuadrada, 5.5 : " << sqrt(5.5) << endl;
cout << "El valor entero superior a x y más cercano a él, 5.2 : " << ceil(5.2)
<< endl;
cout << "El mayor valor entero que es menor que x, 12.8 : " << floor(12.8)
<< endl;
cout << "Exponencial de x(e elevado a x), 5: " << exp(5) << endl;
cout << "Valor absoluto, -15: " << fabs(-15) << endl;
cout << "Resto de la división x / y, 15/6 : " << fmod(15, 6) << endl;
cout << "Logaritmo natural(o neperiano, en base \"e\") , 100: " << log(100)
<< endl;
cout << "Logaritmo en base 10, 100 : " << log10(100) << endl;
cout << "x elevado a y, 2, 5 : " << pow(2, 5) << endl;
cout << "Seno, 30: " << sin(x) << endl;
cout << "Seno hiperbólico, 30: " << sinh(30) << endl;
cout << "Arco seno, 0.5: " << asin(0.5) << endl;
cout << "Coseno, 60 :" << cos(60) << endl;
cout << "Arco coseno, 0.6 :" << acos(0.6) << endl;
cout << "Coseno hiperbólico, 60 : " << cosh(60) << endl;
cout << "Tangente, 45 : " << tan(45) << endl;
cout << "Arco tangente, 1 : " << atan(1)*180/3.1416 << endl;
cout << "Tangente hiperbólica, 45 : " << tanh(45) << endl;
cout << "Arco tangente de y / x(por si x o y son 0), 10, 0 : " <<
atan2(10, 0) << endl;
system("pause");
}
2.9 Entrada y salida de datos

• Para recibir datos desde el teclado utilizaremos el objeto cin.
• Para mostrar datos en la pantalla utilizaremos el objeto cout.
• Ambos están definidos en la librería iostream, la cuál puede ser
agregada a nuestro programa utilizando la instrucción
#include<iostream>.
• Si usamos la librería iostream (#include<iostream>) también debemos
usar el espacio de trabajo std (using namespace std).
3 SOLUCIÓN DEL PROBLEMA
Matriz de variables

Real aporteMi Aporte de Michael
Real aporteEf Aporte de Efraín
Real aporteEv Aporte de Eva
Real total Total de aportes
Real porcentajeMi Porcentaje de aporte de
Michael
Real porcentajeEf Porcentaje de aporte de Efraín
Real porcentajeEv Porcentaje de aporte de Eva


aporteMi, total= aporteMi + aporteEf + aporteEv total,
aporteEf, porcentajeMi= aporteMi/total porcentajeMi,
aporteEv porcentajeEf= aporteEf/total porcentajeEf,
porcentajeEv= aporteEv/total porcentajeEv

3.3 Diagrama N-S
3.4 Pseudocódigo con PseInt

aportes.psc
Proceso areaFigura
Definir aporteMi, aporteEf, aporteEv Como Real
Definir total, porcentajeMi, porcentajeEf, porcentajeEv Como Real
Escribir "Aporte de Michaela: "
Leer aporteMi
Escribir "Aporte de Efrain: "
Leer aporteEf
Escribir "Aporte de Even: "
Leer aporteEv
total=aporteMi+ aporteEf+ aporteEv
porcentajeMi= aporteMi/total
porcentajeEf= aporteEf/total
porcentajeEv= aporteEv/total
Escribir "Aporte de todos: ", total
Escribir "Porcentaje de aporte de Michaela: ",
redon(porcentajeMi*100),"%"
Escribir "Porcentaje de aporte de Efrain: ",
redon(porcentajeEf*100),"%"
Escribir "Porcentaje de aporte de Even: ",
redon(porcentajeEv*100),"%"
FinProceso
3.5 Código en C++
aportes.cpp
#include<iostream>
void main()
{
//Declarando las variables
float aporteMi, aporteEf, aporteEv;
float total, porcentajeMi, porcentajeEf, porcentajeEv;

//Leyendo los valores escritos en la pantalla
cout << "Aporte de Michaela: ";
cin >> aporteMi;
cout << "Aporte de Efrain: ";
cin >> aporteEf;
cout << "Aporte de Even: ";
cin >> aporteEv;
//Realizando los calculos

total = aporteMi + aporteEf + aporteEv;
porcentajeMi = aporteMi / total;
porcentajeEf = aporteEf / total;
porcentajeEv = aporteEv / total;
//Imprimiendo resultados
cout << "###RESULTADOS###" << endl;
cout << "Aporte de todos: " << total << endl;
cout << "Porcentaje de aporte de Michaela: "<< round(porcentajeMi * 100)<<
"%"<<endl;
cout << "Porcentaje de aporte de Efrain: "<< round(porcentajeEf *
100)<<"%"<<endl;
cout << "Porcentaje de aporte de Even: "<<round(porcentajeEv * 100)<<
"%"<<endl;
//Pausa la pantalla
system("pause");
}
Resultados
Aporte de Michaela: 250

Aporte de Efrain: 680
Aporte de Even: 220
###RESULTADOS###
Aporte de todos: 1150
Porcentaje de aporte de Michaela: 22%
Porcentaje de aporte de Efrain: 59%
Porcentaje de aporte de Even: 19%
Resuelto 1. SEDAPAL requiere determinar el pago que debe realizar una persona por el
total de metros cúbicos que consume de agua al llenar una piscina móvil (ver figura).
Elabore un programa en C++ que permita determinar ese pago si se tiene como dato
adicional el precio por m3 de agua.

Matriz de variables
Tipo Variable Descripción

Entero A Arista A
Entero L Arista L
Entero B Arista B
Real pmc Precio por metro cúbico
Real volumen Volumen de agua de la
piscina

A, L, B volumen=A*L*B pago
pago=volumen*pmc
Programa
#include<iostream>
int A, L, B;
float volumen, pmc;
void main()
{
//entradas
cout << "Dame valor de A: ";
cin >> A;
cout << "Dame valor de L: ";
cin >> L;
cout << "Dame valor de B: ";
cin >> B;
cout << "Precio del metro cúbico: ";
cin >> pmc;
//procesos
volumen = A * L*B;
//Salidas
cout << "El Pago total es: " << volumen * pmc << endl;
system("pause");
}
Resultado
Dame valor de A: 12
Dame valor de L: 15
Dame valor de B: 20
Precio del metro c·bico: 12.5
El Pago total es: 45000
Resuelto 2. Desarrollar un programa en C++ para una tienda que vende zapatos. Se
ingresa la cantidad de zapatos que el cliente desea comprar, el precio unitario. Hay un
descuento de 4% si la compra es mayor a 1000 y menor o igual a 2000 soles, un descuento
de 6% si la compra es mayor a 2000 y menor o igual a 3000, y un descuento de 11% si la
compra supera 3000 soles.

Matriz de variables

Entero cantidad Cantidad de zapatos
Real pu Precio unitario
Real total Total a pagar sin
descuento
Real descuento Descuento

Cantidad, pu total = pu * cantidad Total,
descuento = (total < 1000) * 0 + (total > 1000 descuento
&& total <= 2000)*0.04 +(total > 2000 && total
<= 3000)*0.06 + (total > 3000)*0.11
Programa
#include<conio.h>
#include<iostream>
void main()
{
int cantidad;
double pu, total, descuento;
cout << "Cantidad de zapatos a comprar :";

cin >> cantidad;
cout << "Precio Unitario: ";
cin >> pu;
total = pu * cantidad;
descuento = (total < 1000) * 0 + (total > 1000 && total <= 2000)*0.04 +
(total > 2000 && total <= 3000)*0.06 + (total > 3000)*0.11;
cout << "Total: " << total << endl;
cout << "Descuento: " << descuento * total << endl;
cout << "Total a pagar: " << total - descuento * total << endl;
system("pause");
}
Resultados
Cantidad de zapatos a comprar: 200
Precio Unitario: 180
Total: 36000
Descuento: 3960
Total a pagar: 32040
Resuelto 3. Elabore un programa en C++ en donde se ingrese un número entero de 3
cifras únicamente y luego se debe determinar si el número ingresado es capicúa. Un
número capicúa se lee igual de izquierda a derecha que derecha a izquierda.
• Si el número que se ingresa es incorrecto, esto significa no tiene 3 cifras,
se debe mostrar una “E”, que indica error.
• Si el número que se ingresa es correcto, se debe mostrar un mensaje: “S”
si el número es capicúa o “N” si el número no es capicúa.

Ejemplos: 161, 343, 565.
Matriz de variables

Entero numero Número entero
Entero n1 Primer digito del numero
Entero n3 Último digito del numero

Cantidad, pu (n1 == n3 && escribir "S") || (n1 Total, descuento
!= n3 && escribir "N")
Programa V1
#include<iostream>
int numero;
int n1, n2, n3;
void main() {
cout << "Ingrese un numero de tres cifras: ";
cin >> numero;
n1 = numero / 100;
n3 = numero % 10;
cout << n1 << " - " << n3 << endl;
(n1 == n3 && cout << "S") || (n1 != n3 && cout << "N");
cout << endl;

system("pause>NULL");
}
Resultado
Ingrese un número de tres cifras: 354
3 - 4
N
Programa v2
#include<iostream>
int numero;
int n1, n2, n3;
void main() {
cout << "Ingrese un numero: ";
cin >> numero;
n1 = numero / 100;
n3 = numero % 10;
cout << n1<<" - "<< n3<<endl;
((numero>=100 && numero<=999) && ((n1 == n3 && cout << "S") || (n1 != n3
&& cout << "N"))) ||
((numero < 100 || numero >999) && cout<<"E");
cout << endl;
system("pause");
}

Resultado
Ingrese un número: 124
1 - 4
N
Elabore programas en C++:
Propuesto 1. Que calcule y muestre el menor número de monedas de 5,

2 y 1 para desglosar una cantidad C, de Soles.
• Por ejemplo si C fuese 36, entonces la cantidad de monedas de 5 sería 7,
de 2 sería 0 y de 1 sería 1.
Propuesto 2. Que teniendo como dato una hora expresada en segundos
(t), nos calcule y muestre la cantidad de horas, minutos y segundos
contenidos en dicha hora.
• Por ejemplo si t fuese 3879, entonces el número de horas sería 1, los
minutos serían 4 y los segundos serían 39.
Propuesto 3. Que teniendo como dato una hora expresada en horas,
minutos y segundos (h, m, s) nos calcule y muestre la nueva hora luego de
un segundo.
• Por ejemplo si h fuese 11, m fuese 59 y s fuese 59 entonces la nueva hora
sería 12:0:0
Propuesto 4. Que lea el valor de un ángulo en radianes y calcule y
muestre su valor en grados, minutos y segundos.
Propuesto 5. Que lea las coordenadas (x, y) de un punto y nos indique si
se encuentra en el círculo x2 + y2 = 25.
6 INVESTIGACIÓN
Lógicamente los algoritmos son previos a la implementación de los programas.
Sin embargo, a manera de práctica, pase los programas de los ejercicios
propuestos a diagramas N-S, DFD y seudocódigo.
7 EVALUACIÓN

Capítulo 5:
Identificadores de tipo
cadena
1 PROBLEMA
1.1 Enunciado
Diseña la función inviertePalabra que invierta una palabra de cuatro letras que
se le pasa como parámetro. Por ejemplo si la función recibe la palabra “HOLA”
esta debe retornar “ALOH”.

• ¿Cuál crees que es el problema principal aquí? Saber cuál sería el
resultado de una palabra invertida, el algoritmo o el programa que nos
permita invertir palabras de cuatro caracteres.
• Identifica
o Las entradas del programa
o Los procesos y cálculos que se requieren para solucionar el problema
o Las salidas del programa
• ¿Cuál será la representación del conjunto de pasos o algoritmo que
resuelve el problema?
• ¿Cuáles serían las características del lenguaje C++ que me falta conocer
para resolver este problema?

El problema principal pasa por identificar el algoritmo o programa que invierta
palabras. En ese caso nos interesa construir el algoritmo o escribir un programa
que inveierta palabras de cuatro letras.
Cuáles son las MEPS: Matriz de entradas, proceso y salidas

palabra palabraInvertida

• ¿Cómo se escribe un programa en C++?
• ¿Cuáles son los elementos de un programa en C++?
• ¿Qué herramienta de software se puede usar para escribir el en codigo
en C++?
2 TEORÍA
Para trabajar con cadenas se usa un vector de caracteres o un objeto de la
clase string. El trabajo con cadenas de caracteres se usa en C y requiere del

conocimiento básico de vectores. Las variables u objetos de la clase string se
usa en C++ y son muy sencillas de manejar, similar a una variable de tipo
número. La lectura de cadenas en general se hacen utilizanco el objeto cin,
este objeto tiene metodos y hay que conocerlos.
2.1 Contenido
• Cadenas con vector de caracteres
• Cadenas con objetos de la clase string
• Métodos de cin>>
2.2 Cadenas con vector de caracteres

2.2.1 Variables de tipo caracter
Recordemos que una variable de tipo carácter se declara así:
char letra1
char letra2 = 'M'; //la asignación es con comilla simple
¡Importante! es posible comparar caracteres con ==, >=, >,<=, < y ¡=.
Ejemplo es correcto escribir letra==’A’, también se puede asignar caracteres
con el operador de asignación =, por ejemplo letra=’S’.
Ejemplo ilustrativo
void main() {
char letra1;
char letra2 = 'M';
letra1 = 'X';
(letra1 > 'C' && cout << letra1 << " es mayor que " << "C" << endl);
}
Resultado
X es mayor que C
2.2.2 Variables de tipo cadena de caracteres
Declaremos una variable de tipo cadena de caracteres:
char nombre[5];
La variable nombre es un vector de tamaño cinco. Las cuatro primeras

posiciones de nombre, de 0 a 3 con para almacenar caracteres, uno en cada
posición, en la última posición se reserva para guardar el carácter nulo ó ‘\0’,
es decir que, siempre que se declare un vector de caracteres se debe
considerar un espacio para un carácter adicional.
Un vector de caracteres se puede inicializar con un valor inmediatamente se

declare y el carácter nulo se agrega automáticamente al final de la cadena,
ejemplo:
char nombre[5] = "JUAN";

El código anterior es equivalente a:
char nombre[5] = {'J', 'U', 'A', 'N', '\0'};
En C++, para leer una cadena mediante la entrada estándar (teclado) en

memoria dinámica se usa cin>>variable (variable no tiene el operador de
indirección *), de igual manera para mostrarlo en la salida estándar
(pantalla).
char *cadena=new char;

cout << "Palabra : ";cin >> cadena;
cout << cadena;
En C, las cadenas de caracteres no se manejan como los enteros o flotantes
char nombre[40], apellidos[40], completo[80];

nombre = "Manuel"; /* incorrecto */
apellidos = " Lopez Albujar"; /* incorrecto */
completo = "Señor: " + nombre + apellidos; /* demasiado incorrecto */
Sin embargo en C++, las cadenas de caracteres, denominadas strings, se

manejan como los enteros o flotantes, es decir lo siguiente es correcto
string nombre, apellidos, completo;

nombre = "Manuel"; /* incorrecto */
apellidos = "Lopez Albujar"; /* incorrecto */
completo = "Señor: " + nombre + apellidos; /* demasiado incorrecto */
cout << completo;
2.2.3 Inicializacion de una cadena de caracteres 2
La inicialización de una cadena de caracteres en C++ debe hacerse al

momento de declaralas
#include <iostream>
using namespace System;
void main() {
char *cadena1 = "HOLA";
char cadena2[] = "HOLA";
char cadena3[] = { 'H','O','L','A','\0' };
char cadena4[] = { 'H','O','L','A' };
char cadena5[1024] = "Una cadena en C";
char cadena6[] = "";
char cadena7[5] = "HOLA";//El tamaño es 5 porque se requiere un espacio para el ultimo caracter '\0'
cout << "El primer caractere se encuentra en la posición 0" << endl;
cout <<"*cadena1:"<<cadena1<<" Caracteres:"<<strlen(cadena1)<<" Caracter pos 3:"<<cadena1[3]<<endl;
cout << "cadena2[]:" << cadena2 << " Caracteres:" << strlen(cadena2) << " Caracter pos 3:" << cadena2[3] << endl;
2 Adaptamos los ejemplos y recomendaciones propuestas por José Luis Alonzo

Velázquez, Universidad de Guanajuato, 2010.

cout << "cadena5[1024]:" << cadena5 << " Caracteres:" << strlen(cadena5) << " Caracter pos 0:" << cadena5[0] << endl;
cout << "cadena7[5]:" << cadena7 << " Caracteres:" << strlen(cadena7) << " Caracter pos 3:" << cadena7[3] << endl;
system("pause>null");
}
Resultado
El primer caracter se encuentra en la posición 0
*cadena1:HOLA Caracteres:4 Caracter pos 3:A
cadena2[]:HOLA Caracteres:4 Caracter pos 3:A
cadena5[1024]:Una cadena en C Caracteres:15 Caracter pos 0:U
cadena6[]: Caracteres:0 Caracter pos 3:l
cadena7[5]:HOLA Caracteres:4 Caracter pos 3:A
• Viendo el ejemplo, el tamaño de cadena1, cadena2 y cadena3 es 5 (4

espacios para los caracteres alfanuméricos y uno al final para el carácter
especial ‘\0’), este tamaño fue asignado automáticamente.
• El tamaño de Cadena6 es uno.
• En caso de que no se indique el tamaño de una cadena de caracteres,
como es el caso de cadena2 el tamaño es asignado automáticamente,
en este caso 5.
• La función strlen() nos regresa la cantidad de caracteres existentes en el
vector a excepción del carácter especial ‘\0’.
• Tambien se puede inidicar la cantidad de caracteres, incluido ‘\0’ que
tendrá el vector.
2.2.4 Aspectos importantes en la lectura de cadenas de
caracteres
• Una vez que se indique la cantidad de elementos de un vector3 ya no

pueden cambiar de tamaño.
• Las cadenas se leen con cin>> sin incluir el operador de indirección *
delante de la variable, pero este lee hasta que encuentra el primer
blanco (espacio, tabulador, enter o ‘\n’). Es decir que, con cin>> no
podemos leer frases.
• Las frases se leen con getline, por ejemplo cin.getline(cadena, TAM),
getline permite leer hasta TAM-1 caracteres.
• Si el usuario introduce una cantidad de caracteres mayor al tamaño,
estos se quedan en el buffer y la siguiente lectura pueden ocurrir
frustraciones en la lectura.
2.2.5 Dificultades cuando se usa » y getline
int num;
char cadena[1000];
cout << "Número = "; cin >> num;
cout << "Escribe una cadena: "; cin.getline(cadena, 1000);
cout << "Lo que he leído es: " << cadena << endl;
3 En caso que el vector se declare en la memoria estática.

Salida en pantalla
Número = 145
------------------
Escribe una cadena: Lo que he leído es:
¿Por qué?
Con cin>> se lee 145 en la variable numérica num, pero deja de leer cuando se
encuentra el primer carácter no numérico ‘\n’. Cuando se pulsa enter se asigna
al buffer ‘\n’, entonces con el getline que sigue leemos en cadena lo que
encuentra en el buffer, es decir ‘\n’ y el programa salta a la línea que sigue.
La solución
La solución pasa por escribir cin.get() justo después de que se lee el número
para leer el caracter ‘\n’ que se generó cuando se pulsó la tecla enter.
int num;
char cadena[1000];
cout << "Número = "; cin >> num;
cin.get(); //lee '\n'
//cin.ignore(); //brinca o ignora un carácter es decir '\n'
cout << "Escribe una cadena: "; cin.getline(cadena, 1000);
2.3 Cadenas con objetos de la clase string
• Para trabajar con cadenas en C++ se usa un objeto de la clase string.
• En el paso de parámetros (valor / referencia), se parece a cualquier tipo
simple (int, float, char,...).
• Los valores de las variables son de tamaño variable (no hay máximo), y
puede crecer.
• La cadena no termina en ‘\0’.
2.3.1 Declaración de identificadores String
Constante:
const string cadena = "hola";
Variable:
string cadena;
Declaración con inicialización:

string cadena = "hola";
2.3.2 Métodos del objeto cin para la lectura de cadenas
cin.get()
Lo usamos para leer el primer caracter de una cadena ingresado por el teclado.
Para utilizarlo basta tener una variable de tipo char.
char letra = cin.get();
cin.ignore()

a) cin.ignore() sin parámetro, se utiliza para ignorar lo que hay en el buffer y
no se salte la lectura de datos cuando de cambia de un tipo de dato a otro,
por ejemplo de string a int. La función ignore() saltea un caracter de la
entrada.
b) cin.ignore(N) saltea N caracteres de la entrada.
c) cin.ignore(N, 'c') con parámetro se usa cuando se lee ignorando hasta N
caracteres o hasta que se llegue a la letra ‘c’.
Ejemplo
char inicial1, inicial2;
cout << "Ingresa tu nombre seguido por primer apellido: ";//Manuel Lopez
inicial1 = cin.get();// Del total de la cadena en el buffer leemos el primer
carácter.
cin.ignore(5, ' ');// Salteamos 5 posiciones o hasta encontrar un espacio para leer
el siguiente caracter.
//En caso de que el nombre tenga más de más de 5 letras juntas
nos salteamos hasta el lugar 6.
//En caso de que el nombre tenga menos de 6 letras entonces
nos salteamos hasta el carácter vacío para leer el primer carácter del apellido,
es decir el primer carácter después del espacio.
inicial2 = cin.get(); // Obtenemos la segunda inicial
cout << "Tus iniciales son " << inicial1 << inicial2 << '\n';
Caso 1:
Ingresa tu nombre seguido por primer apellido: Alejandro Mendoza

-------------------------
Tus iniciales son: Ad
Caso 2:
Ingresa tu nombre seguido por primer apellido: Luis Mendoza

-------------------------
Tus iniciales son LM
Importate! El carácter vacío del ejemplo anterior puede ser otro carácter.
getline()
a) getline() se usa para leer frases. Usa como delimitador el salto de línea,
enter o ‘\n’.
b) getline (cin, variable, ‘carácter delimitador’) permite leer una cadena
hasta se ingrese el carácter delimitador y pulsemos enter.
Ejemplo:
#include <iostream>
#include<string>
void main() {
string cadena1, cadena2;
cout << "Introduzca dos palabras: ";
getline(cin, cadena1, 'a');//Lee la frase hasta la letra 'a'
cin.get(); //Espera que se escriba algo

cout << "Introduzca otra palabra: ";
getline(cin, cadena2); //la cadena del buffer posterior a la primera
letra 'a' se asigna a cadena2
cout << "Las dos cadenas: " << cadena1 << " " << cadena2;
}
Resultado 1: Si la primera frase termina en ‘a’ y pulsamos enter, tenemos chance

de ingresar la siguiente frase.
Introduzca dos palabras: Lima
Introduzca otra palabra: Peru
Las dos cadenas: Lim Peru
Resultado 2: Si la primera frase termina en ‘a’ y pulsamos enter, ya no tenemos

chance de ingresar la siguiente frase.
Introduzca dos palabras: Lima Peru
Introduzca otra palabra: Las dos cadenas: Lim Peru
2.3.3 Entrada/salida con strings

cout << Se usa para imprimir como los tipos simples (int, float, . . . )
cin>> Ignora los blancos antes de la cadena y termina de leer en cuanto

encuentra el primer blanco después de la cadena. Con cin>> no se puede leer
frases.
getline(cin,cadena) Se usa para leer frases de tamaño ilimitado

getline(cin,cadena), cadena es una variable de tipo string. Para leer vectores
de caracteres se usa cin.getline(cadena, TAM), cadena es una variable vector
de caracteres.
Si se pulsa enter antes de un getline para una variablea de tipo string, ocurre lo
mismo que para una variable vector de caracteres. La solución pasa por escribir
cin.get() ó cin.ignore() antes del getline respectivo.
#include <iostream>
#include<string>
void main() {
int num;
string cadena;
cout << "Número : "; cin >> num; //cuando se pulsa enter se toma el numero
pero el caracter enter se queda en el buffer
cin.get(); //lee '\n'
//cin.ignore();//ignora la lectura del caracter enter ó '\n'
cout << "Escribe una cadena: "; getline(cin, cadena);
cout << "El texto que escribió: " << cadena<<" y numero: "<<num;
}

Número: 26702558
Escribe una cadena: Juan Carlos
El texto que escribió: Juan Carlos y número: 26702558
2.3.4 Métodos de la clase string

Al ser una clase, los métodos de los objetos se invocan con un punto tras el
nombre de la variable.
cadena.length()
Código Descripción Resultado

string completo = "Manuel Lopez Albujar"; Longitud del string 20
cout << completo.length() << endl; completo
cadena.substr(inicio, cantidad);

string completo = "Manuel Lopez Albujar"; 8 letras de completo, nuel Lop
string subcadena2 = completo.substr(2, 8); desde la tercera
cout << subcadena2 << endl;
cadena.insert(posición inicial, "sub cadena a insertar")

string completo = "Manuel Lopez Albujar"; Insertar un texto a partir de Manuel
completo.insert(7, "Alberto "); la posición 7 Alberto Lopez
cout << completo << "\n";
Albujar
completo.replace(posición inicial, cantidad de caracteres a reemplazar,
"nueva sub cadena");

string completo = "Manuel Lopez Albujar"; Cambio 2 letras desde la Manuel
completo.replace(7, 2, "Eu"); posición 7 Eupez Albujar
Comparar dos cadenas con el operador relacional ==

string completo = "Manuel López Comparamos dos Nombre correcto del
Albujar"; textos. escritor es: Manuel
if (completo == "Manuel López Albujar")
cout << "Nombre correcto del escritor López Albujar
es: Manuel López Albujar\n";
Comparar dos cadenas con el método compare

string completo = "Manuel Lopez Albujar"; Comparamos dos textos, Nombre
if (completo.compare("Manuel Lopez siendo que correcto del
Albujar")==0) cadena1.compareto(cad
cout << "Nombre correcto del escritor es: escritor es:
ena2) regresa cero Manuel
Manuel Lopez Albujar\n";
cuando las cadenas son
Lopez Albujar
iguales, otro valor mayor o

menor que cero en otros
casos.
Buscar una cadena y regresar su posición

string completo = "Manuel Lopez Albujar"; La posición a partir de la Manuel
int encuentra = completo.find("bujar"); cual se encuentra un texto Lopez Albujar
cout << completo << endl;
cout << "bujar inicia en la posición: " << bujar inicia en
encuentra << endl; la posición: 15
Borrar una parte de la cadena

string completo = "Manuel Lopez Albujar"; Borramos 6 letras a partir Manuel
completo.erase(7, 6); de la letra 7 Albujar
cout << completo << "\n";cout << completo
<< "\n";
Un programa completo
/*Adaptado de Jose Ignacio Cabanes de

http://www.aprendeaprogramar.com/mod/resource/view.php?id=172
*/
#include <iostream>
#include<string>
void main()
{
string completo, nombre = "Manuel ", apellido("Lopez");
completo = nombre + apellido + " Albujar ";
cout << completo << "\n"; //"Manuel Lopez albujar"
string subcadena1(completo, 2, 4); // 4 letras de completo, desde la terecera
cout << subcadena1 << "\n";//"nuel"
string subcadena2 = completo.substr(2, 8); // 8 letras de completo, desde
la tercera
cout << subcadena2 << endl; //"nuel Lop"
cout << completo << endl; //"Manuel Lopez Albujar"
completo.insert(7, "Alberto "); // Inserto un texto a partir de la posicion
7
completo.replace(7, 2, "Eu"); // Cambio 2 letras en la posicion 7
cout << "La cantidad de letras la cedena es: " << completo.size() << " o
tambien "<< completo.length()<<"\n";
cout << "La tercera letra de la cadena es: " << completo[2] << " o bien "
<< completo.at(2) << "\n";
if (nombre == "Manuel ")
cout << "Nombre correcto es Manuel\n";
int encuentra = completo.find("berto") ;
cout << "berto inicia en la posicion: "<<encuentra << endl;
completo.erase(6, 8); //borramos 8 letras apartir de la letra 7
}

2.3.5 Operaciones de string
• Las comparaciones se hacen con: ==, !=, >, <, >= y <=
• La asignación de una cadena a otra se hace con el operador =, como
con cualquier tipo simple.
• La concatenación de cadenas se hace con el operador +
string s1 = "Hola"; string s2 = "mundo";
string saluda = s1 + ", " + s2;
cout << saluda << endl; // muestra ’Hola, mundo’
• Acceso a componentes como si fuera un vector de caracteres

(solamente si el string tiene algo).
string s1 = "Hola"; string s2 = "mundo";
string saluda = s1 + ", " + s2;
saluda[4] = '!'; saluda[6] = 'M';
cout << saluda << endl; // muestra "Hola, Mundo"
cout << saluda[0] << saluda[6]; // muestra "HM"
2.3.6 Conversión entre vectores de caracteres y String

Vector de caracteres a string : con la asignación (=)
char cadena[] = "hola";
string saluda;
saluda = cadena;
saluda = saluda + ", mundo";
String a vector de caracteres: con c_str

#include <iostream>
#include<string>
#define tCAD 10
void main()
{
char cadena[tCAD];
string saluda = "Mundo";// CUIDADO: debe haber sitio suficiente en cadena
strcpy(cadena, saluda.c_str());
cout << cadena << endl;
}
2.3.7 Conversión entre string y enteros

entero a string
#include <iostream>
#include <sstream>
#include<string>
void main()
{
int n = 100;
stringstream stream1;
stream1 << n;
// Tambien se pueden concatenar mas cosas, por ejemplo:
// ss << "El numero es: " << n << endl;
string snumero = stream1.str();
cout << "100 en cadena es: " << snumero << endl;

}
string a entero
#include <iostream>
#include <sstream>
#include<string>
void main()
{
string numero = "148A9";
int n = atoi(numero.c_str()); //regresa un numero compuesto por los primeros
dígitos de una cadena
cout << "La cadena 148A9 en número es: " << n << endl;
}
2.4 Vectores de caracteres vs string

Vectores de caracteres Cadenas con string
char letras[TAM]; string scadena;
char letras []="hola"; string scadena ="hola";
strlen(letras) scadena.length()
cin.getline(letras,TAM); getline(cin, scadena);
if (!strcmp(c1,c2)){..} if (s1 == s2){..}
ó
if(!s1.compare(s2)){}
strcpy(cdestino, cfuente); sdestino = sfuente;
char *cfuente = "148A9"; string sfuente = "148A9";
char *cdestino; string sdestino;
strcpy(cdestino, cfuente); sdestino= sfuente;
cout << "Dato de la variable destino : cout << "Dato de la variable destino :
" << cdestino << endl; " << sdestino << endl;
strcat(c1,c2); s1 = s1 + s2;
strcpy(cdestino, sfuente.c_str());
//sfuente es una string
#include <iostream>
#include<string>
void main()
{
string sfuente = "148A9";
char *cdestino;
strcpy(cdestino, sfuente.c_str()); //destino no puede estar formateado
previamente
cout << "Destino : " << sdestino << endl;
}
Terminan con ’\n’ NO terminan con ’\n’
Tamaño reservado fijo El tamaño reservado puede crecer
Tamaño ocupado variable Tamaño ocupado = tamaño
reservado
Se usan en ficheros binarios NO se pueden usar en ficheros
binarios

Matriz de variables

Cadena palabra Palabra que se va invertir
Cadena pinvertida Palabra invertida

palabra pinvertida=inviertePalabra(palabra) Pinvertida

invierteCadena.psc
Proceso inviertePalabra
Definir palabra como caracter
Definir a como caracter
Escribir "Palabra de cuatro letras"
Leer palabra
Escribir SubCadena(palabra,4,4), SubCadena(palabra,3,3),
SubCadena(palabra,2,2), SubCadena(palabra,1,1)
FinProceso
3.3 Codigo del programa
3.3.1 Código en C++ con un objeto(variable) de la clase string
Importante! El uso de string es tan sencillo como el uso de variables numéricas.
invierteCadena.cpp
#include <iostream>
#include<string>
string invierteCadena(string *psi) { //psi palabra sin invertir
string *pinvertida = new string;
*pinvertida = (*psi).substr(3,1) + (*psi).substr(2, 1)+(*psi).substr(1,
1)+(*psi).substr(0, 1);
return *pinvertida;
}
int main()
{
string *palabra = new string;
cout << "Ingrese una palabra de cuatro letras : ";
cin >> *palabra;
cout <<"Palabra invertida: " <<invierteCadena(palabra) << endl;
}

Resultado:
Ingrese una palabra de cuatro letras: ARTE
-----------------------
Palabra invertida: ETRA
3.3.2 Código en C++ con una cadena de caracteres

El uso de cadena de caracteres requiere el conocimiento básico de vectores
de caracteres.
invierteCadena.cpp
#include <iostream>
#include<string>
char * invierteCadena(char *psi) { //psi palabra sin invertir
char *pinvertida = new char[5];
strcpy(pinvertida,"xxxx"); //formateamos la variable pinvertida
pinvertida[0] = psi[3];
return pinvertida;
}
int main()
{
char *palabra = new char[5];
cout << "Ingrese una palabra de cuatro letras : ";
cin >> palabra;
cout <<"Palabra invertida: " <<invierteCadena(palabra) << endl;
}
Resultado:
Ingrese una palabra de cuatro letras: ARTE
------------------------------------------------
Palabra invertida: ETRA
Resuelto 1. Haga un resumen de las funciones principales de que se utilizan en el manejo
de cadenas mediante cadena de caracteres.
Solución
#include <iostream>
#include <string>
void main() {
char direccion[50];
cout << "Ingrese dirección: ";
gets_s(direccion);
int longitud = strlen(direccion);
cout << "Tamaño o longitud: " << longitud << endl;
char destino[50];
strcpy(destino, direccion);
cout << "Imprimiendo la copia: " << destino << endl;
char cadena1[10] = "sistemas", cadena2[10] = "SISTEMAS";

int resultado = strcmp(cadena1, cadena2); //regresa 0 cuando son iguales
cout << "Comparación com strcmp: " << resultado << endl;
/*stricmp: compara 2 cadenas ignorando si estan en minusculas
o mayusculas*/
resultado = stricmp(cadena1, cadena2); //regresa 0 cuando son iguales
cout << "Comparando con stricmp: " << resultado << endl;
strcat(cadena1, cadena2);
cout << "Concatenando cadenas: " << cadena1 << endl;
cout << "Convertimos la cadena a minúsculas con strlwr : " <<
strlwr(cadena1) << endl;
cout << "Convertimos una cadena en mayúsculas strupr: " << strupr(cadena1)
<< endl;
//strchr: devuelve el resto de una cadena a partir de un caracter indicado
char *puntero = NULL;
puntero = strchr(direccion, 'a');
cout << "Función strchr: " << puntero << endl;
}
Resultado
Ingrese dirección: Antúnez de Mayolo Cdra. 4824

--------------------------------------------------------------------
Tamaño o longitud: 28
Imprimiendo la copia: Ant£nez de Mayolo Cdra. 4824
Comparación con strcmp: 1
Comparando con stricmp: 0
Concatenando cadenas: sistemasSISTEMAS
Convertimos la cadena a minusculas con strlwr : sistemassistemas
Convertimos una cadena en mayusculas strupr: SISTEMASSISTEMAS
Función strchr: ayolo Cdra. 4824
Resuelto 2. Escribir un programa que lea la edad y los nombres de una persona, luego
imprima la edad y los nombres ingresados respectivamente.
Dame tu edad: 17
Dame tu nombre: Pepe Lucho
-------------------
Hola Pepe Lucho tienes 17 años
Solución con cadena de caracteres

#include <iostream>
int main()
{
char nombre[100];
int edad;
cout << "Ingresa tu edad: ";
cin >> edad;
cin.ignore(); //se usa para ignorar el carácter ‘\n’ escrito al pulsar enter
después de escribir la edad en la pantalla
cout << "Nombre y apellido:";
cin.getline(nombre, 100);
//Muestra resultados
cout << "Hola: " << nombre << endl;
cout << "Tienes : " << edad << " años" <<endl;
}

Salida
Ingresa tu edad: 32
Nombre y apellido: Juan Manuel
---------------------------
Hola: Juan Manuel
Tienes: 32 años
Solución con la clase string

#include <iostream>
#include<string>
int main()
{
string nombre;
int edad;
cout << "Ingresa tu edad: ";
cin >> edad;
cin.ignore();
cout << "Nombre y apellido:";
getline(cin, nombre);
//Muestra resultados
cout << "Hola: " << nombre << endl;
cout << "Tienes : " << edad <<" años" <<endl;
}
Salida
Ingresa tu edad: 32
Nombre y apellido: Juan Manuel
---------------------------
Hola: Juan Manuel
Tienes: 32 años
Resuelto 3. Escribir un programa en C++ que permita ingresar por el teclado

cierta fecha en el orden día, mes y año. El programa debe imprimir la fecha
en formato inglés nombre del mes, día y año.
Ejemplo:
Día : 27
Mes :3
Año : 2019
-------------------------------
La fecha en letras es:
March 27, 2019
Matriz de variables

Entero dia Numero de día
Entero mes Número de mes
Entero anio Numero de año
cadena de mesLetras Mes en letras
caracteres/strig


Dia, mes, ((*mes == 1) && strcpy(mesLetras, "January")) mesLetras,
anio || dia, anio
((*mes == 2) && strcpy(mesLetras, "February"))
||
((*mes == 3) && strcpy(mesLetras, "March"))
….. ;
El proceso con funciones lo puede observar en la solución del problema con
funciones, cuya solución está apoyada en el uso de punteros a espacios de
memoria dinámica.
Programa
Solución sin funciones
#include <iostream>
#include <cstdlib>
#include <string>
int main()
{
char *mesLetras = new char[20];
int *dia = new int;
int *mes = new int;
int *anio = new int;
cout << "Dia :"; cin >> *dia;
cout << "Mes: "; cin >> *mes;
cout << "Anio : "; cin >> *anio;
((*mes == 1) && strcpy(mesLetras, "January")) ||
((*mes == 2) && strcpy(mesLetras, "February")) ||
((*mes == 3) && strcpy(mesLetras, "March")) ||
((*mes == 4) && strcpy(mesLetras, "April")) ||
((*mes == 5) && strcpy(mesLetras, "May")) ||
((*mes == 6) && strcpy(mesLetras, "June")) ||
((*mes == 7) && strcpy(mesLetras, "July")) ||
((*mes == 8) && strcpy(mesLetras, "August")) ||
((*mes == 9) && strcpy(mesLetras, "September")) ||
((*mes == 10) && strcpy(mesLetras, "October")) ||
((*mes == 11) && strcpy(mesLetras, "November")) ||
((*mes == 12) && strcpy(mesLetras, "December"));
cout << "La fecha en letras es: " << endl;
cout << mesLetras << ", " << *dia << " of " << *anio;
}
Resultados
Día: 15
Mes: 10
Año: 2018
-------------------------------
La fecha en letras es:
October, 15 of 2018
Solución con funciones

#include <iostream>
#include <string>

bool asignarCadena(string cadena, string *nmes) {
*nmes = cadena;
return 1;
}
int main() {
string *mesLetras = new string;
int *dia = new int;
int *mes = new int;
int *anio = new int;
cout << "Dia :";
cin >> *dia;
cout << "Mes: ";
cin >> *mes;
cout << "Anio : ";
cin >> *anio;
(*mes == 1 && asignarCadena("January", mesLetras)) ||

(*mes == 2 && asignarCadena("Febrary", mesLetras)) ||
(*mes == 3 && asignarCadena("March", mesLetras)) ||
(*mes == 4 && asignarCadena("April", mesLetras)) ||
(*mes == 5 && asignarCadena("May", mesLetras)) ||
(*mes == 6 && asignarCadena("June", mesLetras)) ||
(*mes == 7 && asignarCadena("July", mesLetras)) ||
(*mes == 8 && asignarCadena("August", mesLetras)) ||
(*mes == 9 && asignarCadena("September", mesLetras)) ||
(*mes == 10 && asignarCadena("October", mesLetras)) ||
(*mes == 11 && asignarCadena("November", mesLetras)) ||
(*mes == 12 && asignarCadena("Decembre", mesLetras));
cout << "La fecha inglesa en letras es: " << endl;
cout << *mesLetras << ", " << *dia << " of " << *anio;
}
Resultados
Día: 10
Mes: 11
Año: 2019
--------------------------------
La fecha inglesa en letras es:
November, 10 of 2019
Elabore programas en C++ que resuelvan los siguientes problemas:
Propuesto 1 Diseña una función “SubCadena” que extraiga la

subcadena de longitud n que empieza en la posición p de otra cadena.
Tanto el argumento como el valor de retorno deben ser string. Ejemplo:
SubCadena("hoooola", 2, 5) ) debe dar como resultado "la".
Propuesto 2 Diseña una función llamada “CreaPalindromo” que añada
a un string de cuatro caracteres el mismo string invertido, de forma que el
resultado sea un palíndromo. Ejemplo: "HOLA” nos dé como resultado
"HOLAALOH".
Propuesto 3 Diseña una función “Codifica” que codifique una cadena
de cuatro caracteres sumando una cantidad c al código ASCII de cada
carácter, pero teniendo en cuenta que el resultado debe ser una letra. Por

ejemplo, si n = 3, la ’a’ se codifica como ’d’, la ’b’ como ’e’, . . . , la ’x’ como
’a’, la ’y’ como ’b’ y la ’z’ como ’c’. La función debe admitir letras
mayúsculas o minúsculas, los caracteres que no sean letras no se deben
codificar y el argumento debe ser string.
Ejemplo: Codifica("hola", 3) debe dar como resultado "krod".
Ejercicios con estructuras repetitivas
Propuesto 4 Diseña una función llamada “BorraCaracterDeCadena”

que dado un string y un carácter borre todas las apariciones del carácter en
el string. "hola, mundo" ’o’ "hla, mund".
Propuesto 5 Escribir un programa que cuente la cantidad de vocales
que hay en una cadena de cuatro caracteres.
Propuesto 6 Diseña una función “BuscarSubCadena” que busque la
primera aparición de una subcadena a dentro de una cadena b, y devuelva
su posición o -1 si no está. Tanto a como b deben ser string. Ejemplo:
BuscarSubCadena("oool", "hoooola") ) da como resultado 2. Hacer otra
función similar que devuelva el número de apariciones de la subcadena en
la cadena.
Propuesto 7 Diseña una función “EsPalindromo” que devuelva true si el
string que se le pasa como parámetro es palíndromo.
Ejemplo:
EsPalindromo("hola,aloh") ) regresa true
EsPalindromo("hola, aloh") ) regresa false
6 INVESTIGACIÓN
¿Cómo se leen los datos de un archivo?
7 EVALUACIÓN

Capítulo 6:
Operadores numéricos
1 PROBLEMA
1.1 Enunciado
Una empresa empaquetadora de sobres requiere de un programa en C++ que
optimice el número de empaques de sobres que utilizará para empaquetar sus
productos. Se sabe que la empresa tiene empaques de 12, 30 y 50 sobres
respectivamente.
Ejemplo:
• Ingrese la cantidad de sobres: 148

• Cantidad de empaques de 50: 2
• Queda 6 Sobres si empacar
• ¿Cuáles son las dificultades para resolver el problema?
• Idetifica
o Las posibles Procesos y cálculos que se requieren incluir en el
programa
• ¿Cuál será el algoritmo que respresenta la solución de al problema?
• ¿Cuáles serían las características del lenguaje C++ que falta conocer?
Se trata de calcular la cantidad de empaques de 50, 30 y 12 sobres necesarios
para empacar una cantidad de sobres dada, de tal manera que la cantidad
de empaques sea la mínima. Nos piden representar la solución al problema
mediante diagrama de flujo de datos, diagrama N-S, pseudocódigo y código
en C++.
Entradas Operaciones y Salidas

procediemientos
sobres … de50
de30
de12
sobres

• ¿Cómo se escribe un programa en C++ para resolver el problema
propuesto?
• ¿Cómo se usan los operadores aritméticos de C++ para realizar
operaciones matemáticas?
2 REPASO TEÓRICO
2.1 Contenido
• Variable numérica
• Operadores aritméticos
• Orden en que se evalúa una expresión
• Operadores de incremento y decremento
2.2 Variable numérica
float peso;
int edad;
double probabilidad;
Importante: Cuando asignamos un valor decimal a una variable entera,

solamente se almacena la parte entera.
2.3 Operadores aritméticos

Símbolo Operación
+ Suma
- Resta
* Multiplicación
/ División
% Módulo (Solo para números enteros)
2.4 Orden de los operadores
Se requiere conocerlos para usarlos al momento de evaluar expresiones, por
ejemplo, es comun no dar con el resultado de 4*8/(2+2).
El orden en que se evalúa la expresión se puede especificar,facilmente,

utilizando paréntesis para agrupar las operaciones internas; o asumir el orden de
precedencia que se indica a continuación:
Orden Operador
Mayor jerarquía ()
*, /,%
Menor jerarquía +, -
Si en una expresion tenemos muchos operadores debemos aplicar primero el
operador de mayor jerarquía y luego el que le sigue en jeraquía. En caso que
estemos frente a operadores del mimo nivel como por ejemplo *, / y %, se opera
primero el que está más a la izquierda. Por ejemplo: 30*3/5=18 (primero se opera
30*3) y 30/3*5=50 (primero se opera 30/3).

Ejemplo ilustrativo
Operación Igual a Resultado

15 / 2 + 3.0 * 2 7 + 6.0 13.0
15 / 2.0 + 3.0 * 2 7.5 + 6.0 13.5
(3 – 4.7) * 5 -1.7 * 5 -8.5
1+7%3 1+1 2
Impotante: Se puede emplear paréntesis para especificar el cálculo de un grupo

de números. Los parentesis mas internos se ejecutan primero (5*(2+6))=40.
Más ejemplos ilustrativos
10-12+5 10+5-12 9+7*8-36/5

-2+5 15-12 9+56-36/5
3 3 9+56-7.2
65-7.2
57.8
30*3/5 30*(3/5) 150/2/5
90/5 30*0.6 75/5
18 18 15
30/3*5 30/(3*5) 7*8*(15%4/2)*2-2+15

10*5 30/15 7*8*(3/2)*2-2+15
50 2 7*8*1.5*2-2+15
84*2-2+15
168-2+15
168+13
181
2*5*8/2 150/5*2*3 15/2*(7+(68-15*33+(2025/16)/3/15))+19
10*8/2 30*2*3 …
80/2 60*3 -3109.91
40 180
Evaluar:
15/2*(7+(68-15*33+(2025/16)/3/15))+19=?
#include<iostream>
void main()
{
float resultado;
cout << "15 / 2.0 * (7 + (68 - 15 * 33 + (2025 / 16.0) / 3.0 / 15.0)) + 19
= " << 15 / 2.0 * (7 + (68 - 15 * 33 + (2025 / 16.0) / 3.0 / 15.0)) + 19 << endl;
resultado = 2025 / 16.0;
cout << "Resultado : " << resultado << endl;
resultado=resultado/3.0;
resultado = resultado / 15.0;
resultado = -15*33+resultado ;
resultado = 68+resultado;

resultado = 7 + resultado;
resultado = 15/2.0*resultado;
resultado = resultado+19;
system("pause");
}
2.5 Operadores de incremento y decremento
Operación Ejemplo Equivalencia
++ a++; a = a + 1;
++a;
-- a--; a = a - 1;
--a;
+= a += 10; a = a + 10;
-= a -= 10; a = a - 10;
*= a *= 10; a = a * 10;
/= a /= 10; a = a / 10;
Ejemplo: Evaluar el operador de pre y post incremento

#include <iostream>

int main()
{
cout << "\n a++" << endl;
int a = 10;
cout << a << endl;
cout << a++<<endl;//El incremento de a será posterior
cout << a << endl; //El incremento de a fue posterior
cout << "\n ++b" << endl;

int b = 20;
cout << b<<endl;
cout<< ++b << endl;//El incremento de b se adelanto
cout << b<<endl; //El incremento de b fue inmediato
int i;
for (i = 0; i < 10; i++)
{//
}
cout << "i Post incrementado : "<<i << endl;
int j;
for (j = 0; j < 10; ++j)
{//
}
cout << "i pre incrementado : "<<j << endl;
return 0;
}

Matriz de variables

int sobres Cantidad de sobres a
empacar
int De50 Cantidad de empaques de 50
Entradas Procesos Salidas

sobres de50=sobres / 50 de50
sobres=sobres mod 50 de30
de30= sobres / 30 de12
sobres=sobres mod 30 sobres
de12= sobres / 12
sobres=sobres mod 12
3.3 Diagrama N-S

empaques.psc
Proceso empaque
Definir sobres Como Entero
Definir de50, de30, de12 Como Entero
Escribir "Ingrese la cantidad de sobres: "
Leer sobres
de50 = sobres / 50
sobres = sobres MOD 50
de30 = sobres / 30
de12 = sobres / 12
Escribir "Cantidad de empaques de 50: ", trunc(de50)
Escribir "Queda : " , sobres," sobres sin empacar"
FinProceso
3.5 Código en C++
empaques.cpp
#include<iostream>
void main()
{
int sobres;
int de50, de30, de12;
cout << "Ingrese la cantidad de sobres: ";
cin >> sobres;
de50 = sobres / 50;
sobres = sobres % 50;
de30 = sobres / 30;

de12 = sobres / 12;
cout << "Cantidad de empaques de 50: " << de50 << endl;
cout << "Queda " << sobres << " sobres si empacar" << endl;
}
Resultados del código C++

Ingrese la cantidad de sobres: 149
Cantidad de empaques de 50: 2
Resuelto 1. Que teniendo como dato una hora expresada en segundos (t), nos calcule y
muestre la cantidad de horas, minutos y segundos contenidos en dicha hora
Matriz de variables

Entero cantidad Cantidad de segundos
Entero hora Hora
Entero minuto Minuto
Entero segundo Segundo

cantidad=3728 temporal = cantidad; hora, minuto,
hora = cantidad / 3600; segundo
cantidad = cantidad % 3600;
minuto = cantidad / 60;
segundo = cantidad;
Diagrama Nassi

Programa
#include<iostream>
void main()
{
long cantidad= 3728;
long temporal = cantidad;
int hora = cantidad / 3600;
int minuto = cantidad / 60;
int segundo = cantidad;
cout << "Cantidad de segundos: " << temporal << endl;
cout << "Hora : " << hora << endl;
cout << "Minutos : " << minuto << endl;
cout << "Segundos : " << segundo << endl;
}
Resultados
Cantidad de segundos: 3728

Hora : 1
Minutos : 2
Segundos : 8
Resuelto 2. Que teniendo como dato una hora expresada en horas, minutos y segundos (h,
m, s) nos calcule y muestre la nueva hora luego de un segundo. Por ejemplo si h fuese 11,
m fuese 59 y s fuese 59 entonces la nueva hora sería 12:0:0
Matriz de variables

Entero Hora La hora dada
Real Minuto Minuto dado
Real Segundo Segundo dado
Real todoSegundos Cantidad de hora, minutos y
segundos en segundos

Hora, todoSegundos = hora * 3600 + minuto * 60 + segundo hora,
minuto, +1 minuto,
segundo hora = todoSegundos / 3600 segundo
todoSegundos = todoSegundos % 3600
minuto = todoSegundos / 60
todoSegundos = todoSegundos % 60
segundo = todoSegundos
Diagrama Nassi

Programa
#include<iostream>
void main()
{
int hora = 10, minuto = 59, segundo = 59;
cout << "Hora inicial en H:M:S : " << hora << " - " << minuto << " - " <<
segundo << endl;
int todoSegundos;
todoSegundos = hora * 3600 + minuto * 60 + segundo + 1;
hora = todoSegundos / 3600;
todoSegundos = todoSegundos % 3600;
minuto = todoSegundos / 60;
todoSegundos = todoSegundos % 60;
segundo = todoSegundos;
cout << "Nueva hora: " << hora << endl;
cout << "Nuevo minutos: " << minuto << endl;
cout << "Nuevo segundos: " << segundo << endl;
}
Resultados
Hora inicial en H:M:S : 10 - 59 - 59
Nueva hora: 11
Nuevo minutos: 0
Nuevo segundos: 0
Resuelto 3. Que lea el valor de un ángulo en radianes y calcule y muestre su valor en

grados, minutos y segundos.
Matriz de variables

Ángulo en grados sexagesimales= (cantidad en radianes)*180/𝜋 radianes.

Real radian Valor del ángulo en radianes
Real sexagesimal Valor del ángulo en grados
sexagesimales
Real grado Grados del ángulo
Real minuto Minutos del ángulo
Real segundo Segundos del ángulo

PI = 3.14159265; radian = 7.2 grado,
radian sexagesimal = radian * (180 / PI) minuto,
grados = floor(sexagesimal) segundo
minutos = (sexagesimal - grados) * 60
segundos = (minutos - floor(minutos)) * 60
Diagrama Nassi
Programa

#include<iostream>
const float PI = 3.14159265;
void main()
{
float radian = 7.2;
float sexagesimal = radian * (180 / PI);
float grados, minutos, segundos;
cout << "Angulo en radianes: " << radian << endl;
cout << "Angulo en grados sexagecimal: " << sexagesimal << endl;
grados = floor(sexagesimal);
minutos = (sexagesimal - grados) * 60;
segundos = (minutos - floor(minutos)) * 60;
cout << "Grados sexagesimales: " << grados << endl;
cout << "Minutos sexagesimales: " << floor(minutos) << endl;
cout << "Segundos sexagesimales: " << segundos << endl;
system("pause");
}
Resultados
Angulo en radianes: 7.2
Angulo en grados sexagecimal: 412.53
Grados sexagesimales: 412
Minutos sexagesimales: 31
Segundos sexagesimales: 46.4575
Elabore el programas en C++ que resuelva cada uno de los siguientes
problemas:
Propuesto 1. Corrija el programa adjunto escrito para hallar las raíces de

una ecuación cuadrática. Valide el discriminante y los divisores.
#include<iostream>
void main()
{
int A, B, C;
double raiz1, raiz2;
cout << "Valor de A: ";
cin >> A;
cout << "Valor de B: ";
cin >> B;
cout << "Valor de C: ";
cin >> C;
raiz1 = pow(B, 2) - 4 * A*C;
raiz1 = sqrt(raiz1);
raiz1 = -B + raiz1 / (2 * A*C);
raiz2 = (-B - raiz1) / 2 * A*C;
cout << "Primera raiz: " << raiz1 << endl;
cout << "Primera raiz: " << raiz2 << endl;
system("pause");
}
Propuesto 2. Elabore un programa en C++ para una empresa de ventas

de piezas de automóviles, que determine el precio al que debe vender una

pieza considerando un porcentaje de ganancia. Para ello se leerán el precio
de compra de la pieza y el porcentaje de ganancia que desea obtener la
empresa en tanto por ciento.
Propuesto 3. Una tienda ha puesto en oferta la venta de un producto
ofreciendo un determinado porcentaje de descuento sobre el importe de la
compra. Elabore un programa en C++ que determine el importe de la
compra, el importe del descuento y el importe a pagar por la compra de
cierta cantidad de unidades del producto.
Propuesto 4. El cálculo del pago mensual de un empleado de una
empresa se efectúa de la siguiente manera: el sueldo básico se calcula en
base al número total de horas trabajadas basado en una tarifa horaria; al
sueldo básico, se le aplica una bonificación del 18% del mismo obteniéndose
el sueldo bruto; al sueldo bruto, se le aplica un descuento del 12%
obteniéndose el sueldo neto. Elabore un programa en C++ que calcule e
imprima el sueldo básico, el sueldo bruto y el sueldo neto de un trabajador.
Propuesto 5. Elabore un programa en C++ que calcule el sueldo bruto, el
descuento por ESSALUD, el descuento por AFP y el sueldo neto del empleado
de una empresa de acuerdo a los siguientes criterios: el sueldo bruto se
calcula multiplicando el número de horas trabajadas por una tarifa horaria,
el descuento por ESSALUD es igual al 9% del sueldo bruto, el descuento por
AFP es igual al 11.5% del sueldo bruto, el sueldo neto es la diferencia entre el
sueldo bruto y el descuento total.
6 INVESTIGACIÓN
Sin embargo, a manera de entrenamiento, elabore los diagramas N-S, DFD y
seudocódigo de cada uno de los ejercicios propuestos.
7 EVALUACIÓN

Capítulo 7:
Operadores lógicos y de
relación
1 PROBLEMA
1.1 Enunciado
Realice un programa en C++ y entorno consola que teniendo como datos de
entrada la distancia a recorrer y el número de días de estancia, calcule el costo
total de un Tour de Viaje. El precio por cada 100 KM de recorrido es de S/.150 y,
de cada día de estancia S/.520. Por último si el monto total a pagar sobrepasa
los S/.2500 existe un descuento del 35%.

• Idetifica:
o Los procesos y cálculos que se requieren para solucionar el
problema

Se trata de calcular el monto a pagar dado una ccantidad de kilométros
recorridos y días de estancia en una lugar, este mosto tendrá un descuento de
35% en caso supere los 2500 soles. Nos piden representar la solución al problema
mediante diagrama de flujo de datos, diagrama N-S, pseudocódigo y código
en C++.

Distancia … Total
Estancia Descuento
montoPagar
propuesto?
• ¿Cómo se usan los operadores relacionales de C++ para realizar
operaciones matemáticas?

2 REPASO TEÓRICO
2.1 Contenido
• Variable lógicas
• Operadores lógicos
• Operadores de relación
2.2 Variables lógicas

¿Qué es verdad?
0 es falso y cualquier valor diferente de 0 es verdad.
Ejemplo 1
#include<iostream>
void main()
{
int cierto1, falso1;
cierto1 = (10 > 2);
falso1 = (10 == 2);
cout << "cierto1 = (10 > 2) : " << cierto1 << endl;
cout << "falso1 = (10 == 2) : " << falso1 << endl;
bool cierto2, falso2;
cierto2 = (10 > 2);
falso2 = (10 == 2);
cout << "cierto2 = (10 > 2) : " << cierto2 << endl;
cout << "falso2 = (10 == 2) : " << falso2 << endl;
cout << "bool(15) : " << bool(15) << endl;
cout << "bool(0) : " << bool(0) << endl;
}
Ejemplo 2
bool valor1, valor2, valor3, valor4;
valor1 = (bool)77;
valor2 = (bool)-33;
valor3 = (bool)1;
valor4 = (bool)0;
Solamente el valor4 es falso, es decir valor4==0. Cualquier otro valor

diferente de cero es considerado como verdadero, aquí valor1==1, valor2==1 y
valor3==1, es decir son verdad.

2.3 Operadores lógicos
Operador Significado
&& and (y)
|| (alt+124) or (o)
! not (no)
2.4 Valores de verdad
A B A && B A|| B !A !B
V V V V F F
V F F V F V
F V F V V F
F F F F V V
2.5 Operadores de relación
Operador Descripción Ejemplo Valor Valor
10 > 20 F 0
> Mayor 30 > 20 V 1
20 > 20 F 0
10 < 20 V 1
< Menor 30 < 20 F 0
20 < 20 F 0
10 >= 20 F 0
>= Mayor o igual 30 >= 20 V 1
20 >= 20 V 1
10 <= 20 V 1
<= Menor o igual 30 <= 20 F 0
20 <= 20 V 1
10 == 10 V 1
== Igual
20 == 10 F 0
10 != 10 F 0
!= Diferente
20 != 10 V 1

2.6 Ejemplos representativos
Expresión Valor Explicación
(5 > 2) = V
(5 > 2) && (4 > 7) Falso (4 > 7) = F
(V) && (F) = F
(5 > 2) = V
(5 > 2) || (4 > 7) Verdadero (4 > 7) = F
(V) || (F) = V
(4 > 7) = F
! (4 > 7) Verdadero
!(F) = V
‘A’ > ‘C’ Falso
(100 > 3) && (‘A’ > ‘C’) Falso
!(100 > 3) Falso
num es igual o mayor que 1

(num >= 1) && (num < 9)
pero menor que 9
El valor de la
(num > 1) && (num < 9) && num está entre 1 y 9, pero
expresión depende
(num!= 5) no es 5
del valor de num
num no está comprendido
(num < 1) || (num > 9)
entre 1 y 9
2.7 Estructura de control condicional sin IF-ELSE
2.7.1 Con un solo bloque
(condición && instrucción);
En la estructura anterior: si la condición es verdad se ejecuta la instrucción. Lo

anterior es equivalente a:
si(condición) entonces
{
Instrucción;
}
La condición puede ser una expresión lógica compuesta. Si la instrucción es
una asignación va dentro de paréntesis
Tres ejemplos
De la forma 1 o la forma 2 logramos los mismos resultados.

Forma 1 Forma2
(compra>1500 && descuento=(compra>1500)*0.2;
(descuento=0.2));
((compra>1500 && compra descuento=(compra>1500 && compra
<=5000) && (descuento=0.15)); <=5000) *0.15;
((compra>1500 || edad >80) && descuento=(compra>1500 || edad

(descuento=0.18)); >80) *0.18;
2.7.2 Con más de un bloque

A continuación mostramos una estructura condicional de tres bloques sin if-else
(Condición1 && instrucción1) || (Condición2 && instrucción2) ||

(Condición3 && instrucción3);
En la estructura anterior tenemos tres bloques, si la condición de un bloque es

verdad entonces solamente se ejecuta la instrucción de ese bloque y los otros
dos bloques se descartan.
La instrucción puede ser, de impresión cout<<”algo”, así como de asignación

de un valor a una variable de tipo char o número, a excepción de un variable
de tipo string. Las cadenas de tipo char se asignan usando la función
strcpy(variable, “cadena”)4, por ejemplo esto no es posible.
#include<iostream>
#include<string>
void main()
{
int edad = 30;
string situacion="Adulto";
((edad > 25) && (situacion = "Adulto")); //NO es posible.
cout << situacion;
}
4 Puede ver ejemplos en el apartado que corresponde a identificadores de tipo cadena.

Pero esto si es posible
#include<iostream>
#include<string>
bool asignarCadena(string cadena, string *s) {
*s = cadena;
return 1;
}
void main()
{
int edad = 30;
string *situacion=new string;
((edad > 25) && asignarCadena("Adulto", situacion)); //SI es posible.
cout << *situacion;
}
Tres ejemplos
De la forma 1 o la forma 2 logramos el mismo resultado.
Forma 1 Forma2
(compra<=1000 && (descuento=0.2))|| descuento=(compra<=1000 )*0.2 +
((compra>1000 && compra <=5000) && (compra>1000 && compra <=5000)*0.25
(descuento=0.25))|| + (compra>5000) *1.08;
((compra>5000) && (descuento=0.18));
Matriz de variables

Entero distancia Distancia recorrida
Entero dias Días de estancia
Real pagoRecorrido Pago por el recorrido
Real pagoEstancia Pago por la estancia
Real total Total pago acumulado
Real descuento Descuento según las restricciones
Real costo Costo del producto que se debe
pagar

distancia, pagoRecorrido = (distancia / 100.00) * 150 costo
dias pagoEstancia = dias * 520
total = pagoRecorrido + pagoEstancia
descuento = (total > 2500)*0.35
costo = total + total * descuento

Solución 1 Solución 2

3.3 Diagrama N-S
Solución 1 Solución 2

tour.psc
Proceso tour
Definir distancia, dias Como Entero
Definir total, pagoRecorrido, pagoEstancia, descuento, costo Como
Real
Escribir "Distancia recorrida: "
Leer distancia
Escribir "Estancia en días: "
Leer dias;
pagoRecorrido = (distancia / 100.00) * 150;
pagoEstancia = dias * 520;
total = pagoRecorrido + pagoEstancia
si total>2500 entonces
costo = total + total * 0.35;
FinSi
Escribir "Costo total del tour: ", costo
FinProceso

3.5 Código en C++
tour.cpp
#include<iostream>
void main()
{
int distancia, dias;
double total, pagoRecorrido, pagoEstancia, descuento, costo;
cout << "Distancia recorrida: " << endl;
cin >> distancia;
cout << "Estancia en días: " << endl;
cin >> dias;
pagoRecorrido = (distancia / 100.00) * 150;
pagoEstancia = dias * 520;
total = pagoRecorrido + pagoEstancia;
descuento = (total > 2500)*0.35;
costo = total + total * descuento;
cout << "Costo total del tour: " << costo << endl;
system("pause");
}
Resultados del código C++
Distancia recorrida:
250
Estancia en días:
5
Costo total del tour: 4016.25
Resuelto 1. Evalúe las siguientes expresiones lógicas (booleanas) y encuentre
el resultado de cada uno de ellos.
1 3> 5 || 8 <= 9 == 1
2 16*8/2+2<=16*8/(2+2) == falso 14/5*8 14*8/5
3 ! (4 * 3 > 12 && 15 < 2 * 3)
4 (2 >= 3 || 5 > 1+3) && ! (6 >= 5)
5 Suponga que A=5 y B=5, el resultado de (A^2) > (B*2) es:
6 Suponga que X=8 y B=7, el resultado de ( X * 5 + B^ 3 / 4 ) <= ( X ^ 3 \B )
es:
7 ( ( 1580 % 6 * 2 ^ 7 ) > ( 7 + 8 * 3 ^ 4 ) ) > ( ( 15 * 2 ) == ( 60 * 2 / 4 ) )
8 !( 15 >= 7 ^2 ) || (43 – 8 * 2 \4 <> 3 * 2 \2)
9 ( 15 >= 7 * 3 ** 2 && 8 > 3 && 15 > 6 ) && ! ( 7 * 3 < 5 + 12 * 2 \ 3 ^2 )
10 ! ( ( 7 * 3 \2 * 4 ) > ( 15 / 2 * 6 >= 15 * 2 / 17 == 15 ) )
\ : División entera, ejm: 10\4=2, 11\3=3
^ : Potencia, ejm: 2^4=16

Resuelto 2. Dada una fecha de vencimiento y fecha actual, escribir un
programa que verifique si un producto está vencido. Considere que un mes
tiene 30 días y un año 365 días.
Matriz de variables

Entero av Año de vencimiento
Entero mv Mes de vencimiento
Entero dv Día de vencimiento
Entero aa Año de vencimiento
Entero ma Mes de vencimiento
da Día de vencimiento

av, mv, dv, diasVencimiento = dv + mv * 30 + av * 365 Vencido
aa, ma, da diasActual = da + ma * 30 + aa * 365 No vencido
Diagrama Nassi
Programa
#include <iostream>
long long diasVencimiento, diasActual;
int main() {
int av, mv, dv;
int aa, ma, da;
cout << "Año de vencimiento: ";
cin >> av;
cout << "Mes de vencimiento: ";
cin >> mv;
cout << "Dia de vencimiento: ";
cin >> dv;
diasVencimiento = dv + mv * 30 + av * 365;

cout << "Año actual: ";
cin >> aa;
cout << "Mes actual: ";
cin >> ma;
cout << "Día actual: ";
cin >> da;
diasActual = da + ma * 30 + aa * 365;
(diasActual <= diasVencimiento && cout << "producto NO vencino") ||
(diasActual > diasVencimiento && cout << "producto vencido");
cout << endl;
system("pause");
}
Resultados
Año de vencimiento : 2020

Mes de vencimiento : 11
Dia de vencimiento : 24
A±o actual : 2020
Mes actual : 1
DÝa actual : 27
Producto NO vencino
Resuelto 3. Permita leer tres valores distintos, determinar cuál de los tres valores
es el mayor y cuál es el menor y escribirlos
Matriz de variables

Entero A Valor de A
Entero B Valor de B
Entero C Valor de C
Entero mayor Mayor valor
Entero menor Menor valor

A, B, C mayor = (A >= B && A >= C)*A +(B >= A && B >= C)*B mayor,
+ (C >= A && C >= B)*C; menor
menor = (A <= B && A <= C)*A + (B <= A && B <= C)*B
+ (C <= A && C <= B)*C;

Diagrama Nassi
Programa
#include<conio.h>
#include<iostream>
void main()
{
int A=780,B=950,C=80;
int mayor = 0, menor = 0;
mayor = (A >= B && A >= C)*A +

(B >= A && B >= C)*B +
(C >= A && C >= B)*C;
menor = (A <= B && A <= C)*A +
(B <= A && B <= C)*B +
(C <= A && C <= B)*C;
cout << "Numeros: " << A << " - " << B << " - " << C << endl;
cout << "Mayor es: " << mayor << endl;
cout << "Menor es: " << menor << endl;
system("pause");
}
Resultados
Numeros : 780 - 950 - 80

Mayor es : 950
Menor es : 80
Resuelto 4.Calcule el monto a pagar por el servicio de estacionamiento,

teniendo en cuenta que por la primera hora de estadía se tiene una tarifa
de 10 y las restantes tienen un costo de 6. Se tiene como datos: hora de
entrada (hhmm), hora de salida (hhmm), iniciada una hora se contabiliza
como hora total. La hora de entrada y salida serán ingresadas como
números enteros.

Matriz de variables

Entero hentrada Hora de entrada
Entero mentrada Minuto de entrada
Entero hsalida Hora de salida
Entero msalida Minuto de salida
Entero entrada Cantidad de segundos de la entrada
Entero salida Cantidad de segundos de salida
Real estadia Cantidad de horas de estadía
Real pago Pago por la estadía

hentrada, salida = hsalida * 3600 + msalida * 60 estadia,
mentrada, hsalida, estadia = (salida - entrada) / 3600.00 pago
msalida, entrada,
salida, estadia,
pago
Diagrama Nassi
Programa
#include<iostream>
int hentrada, mentrada, entrada;
int hsalida, msalida, salida;
float estadia, pago;
void main() {
cout << "Hora de entrada: ";
cin >> hentrada;
cout << "Minutos de entrada : ";
cin >> mentrada;
entrada = hentrada * 3600 + mentrada * 60;
cout << "Hora de salida: ";
cin >> hsalida;

cout << "Minutos de salida : ";
cin >> msalida;
salida = hsalida * 3600 + msalida * 60;
estadia = (salida - entrada) / 3600.00;
((estadia > 1) && (pago= 10 + (ceil(estadia) - 1) * 6)) ||
((estadia<=1) && (pago=10));
cout << "Estadía: " << estadia << endl;
cout << "Pago: " << pago << endl;
system("pause");
}
Resultado
Hora de entrada : 10
Minutos de entrada : 10
Hora de salida : 15
Minutos de salida : 25
EstadÝa : 5.25
Pago : 40
Resuelto 5. Dependiendo del costo de un producto se hacen los descuentos,
si este es menor de 1000 el descuento es 10%, si está entre 1000 y 5000 el
descuento es de 20% y si es mayor a 5000 el descuento es de 32%. Escriba el
programa en C++ que ayude a realizar compras.
Matriz de variables

Real Costo Costo producto
Real Descuento Descuento de la compra

costo descuento = (costo < 1000)*0.1 +(costo >= costo,
1000 && costo<=5000)* 0.2 +(costo>5000)* descuento,
0.32; costo-descuento
Diagrama Nassi

Programa v1
#include<iostream>
void main()
{
double descuento;
double costo = 2600;
descuento = (costo < 1000)*0.1 + (costo >= 1000 && costo <= 5000)* 0.2 +
(costo > 5000)* 0.32;
cout << "Costo : " << costo << endl;

cout << "Descuento : " << descuento * costo << endl;
cout << "Costo con descuento : " << costo - descuento * costo << endl;
system("pause");
}
Resultado
Costo : 2600
Descuento : 520
Costo con descuento : 2080
Programa v2
#include<iostream>
void main()
{
double descuento;
(costo < 1000 && (descuento=0.1)) ||

(costo >= 1000 && costo < 5000 && (descuento=0.2)) ||
(costo >= 5000 && (descuento=0.32));
cout << "Descuento : " << descuento * costo << endl;
cout << "Costo del producto : " << costo - descuento * costo << endl;
system("pause");
}
Resuelto 6. Dependiendo del costo de un producto se califica el pago, si este

es menor de 1000 se clasifica como barato, si está entre 1000 y 5000 se
clasifica como regular y es mayor a 5000 se clasifica como caro. Escriba el
programa en C++ que ayude a clasificar el producto como barato, regular
o caro.
Programa
#include<iostream>
void main()
{
double costo = 800;
cout << "El producto es : ";
(costo < 1000 && cout << "Barato ") || (costo >= 1000 && costo < 5000 &&
cout << "Regular") || (costo >= 5000 && cout << "Caro");
cout << endl;
system("pause");
}

Resultado
El producto es: Barato
Elabore el programas en C++ que resuelva cada uno de los siguientes
problemas:
Propuesto 1. Permita leer tres valores distintos y los ordene de mayor a

menor.
Propuesto 2. Realice un programa en C++ y entorno consola que solicite
el ingreso de un número entero y si este es mayor o igual a 10 devuelva el
triple de este de lo contrario la cuarta parte de este.
Propuesto 3. Permita leer un número entero e imprima si este es un dígito
o una letra mayúscula o letra minúscula u otro carácter. Recuerde que los
dígitos se encuentran en el rango de 48 a 57, las letras mayúsculas están en
el rango de 65 a 90 y las letras minúsculas están en el rango de 97 a 122.
Propuesto 4. Determine el pago a realizar por las entradas a un
espectáculo donde se pueden comprar sólo hasta cuatro entradas, donde
al costo de dos entradas se les descuenta el 10%, al de tres entradas el 15%
y a la compra de cuatro se le descuenta el 20 %. Debe ingresar el costo de
la entrada y el número de entradas a comprar
6 INVESTIGACIÓN
Sin embargo, a manera de práctica, haga los diagramas N-S, DFD y
seudocódigo de cada uno de los ejercicios propuestos.
7 EVALUACIÓN

Capítulo 8:
Funciones de programador
1 PROBLEMA
1.1 Enunciado
Realizar un programa para calcular las raíces reales de una ecuación
cuadrática:
𝑎𝑥 2 + 𝑏𝑥 + 𝑐 = 0
Si se asume que la ecuación si tiene solución, entonces los valores de x1 y x2

calculan usando la siguiente fórmula:
−𝑏 ± √𝑏 2 − 4𝑎𝑐
𝑥=
2𝑎
Construya una función en lenguaje C++ para calcular las raíces de la ecuación.

• Idetifica:
d) Las entradas del programa
e) Los procesos y cálculos que se requieren para solucionar el

problema
f) Las salidas del programa


Se trata de hallar las raices de una ecuación cuadrática cuyo modelo
matemático se encuentra en el enunciado del problema. Nos piden representar
la solución al problema mediante diagrama de flujo de datos, diagrama N-S,
pseudocódigo y código en C++.

a, b, c ¿? x1
x2
propuesto?

• ¿Cómo se definen y se utilizan las funciones de programador?
• ¿Cómo se envían las variables por direccion y por valor?
• ¿Cómo se reciben las variables por direccion y por valor?
• ¿Cómo se usan las funciones del lenguaje?
2 REPASO TEÓRICO
2.1 Contenido
• Sintaxis de una función
• Algunas funciones propias del lenguaje C++
• Funciones de programador: paso de variables por valor
• Funciones de programador: paso de variables por referencia
• Funciones de programador: llamando a una función
• Namespaces
A una función que no regresa un valor se le conoce como procedimiento y si
regresa un valor como función.
2.2 Sintaxis de una función en C++

<tipo de dato retorno> <nombre función> ( <parámetros> )
{
[instrucciones;]
return valorDeRetorno;
}
<tipo de dato retorno> int, float, double, long, char, bool, etc.
void
<nombre función> El nombre que se le desee dar a la función
respetando las reglas establecidas para nombrar
variables.
<parámetros> Cero o más parámetros. Cada parámetro debe
especificar el tipo de dato y el nombre. Los
parámetros se deben separar con comas.
return Devuelve el valor esperado. Si la función tiene
como tipo de dato retorno un int entonces el
valorDeRetorno deberá ser un int.
En el caso de que el tipo de dato retorno sea void
bastará con poner return o nada;
2.3 Algunas funciones del lenguaje C++
Función Ejemplo de uso Descripción
_getch char c = _getch(); Espera a que el usuario presione una tecla
y devuelve la tecla presionada. Para usarlo
correctamente la memoria del teclado
debe estar limpia fflush(stdin)
srand y srand(time(0)); Funciones para crear número aleatorios:
rand int n1 = rand() % 10 srand inicia el generador de números
+ 1; aleatorios y rand devuelve un número
aleatorio entre 0 y RAND_MAX, si tratamos
el resultado podemos obtener números

entre el rango que nosotros deseemos. Por
ejemplo: n1 toma cualquier valor aleatoria
entre 1 a 10.
sqrt double raiz = Devuelve la raíz cuadrada del número.

sqrt((double)4.0);
2.4 Funciones de programador: paso de variables por

valor
La definición de las funciones, dependiendo del lenguaje, tienen una pequeña
variación en cuanto a la manera como se escriben. Cuando se llama a este tipo
de función, se le pasa un argumento, estos se reciben en la función que
corresponde mediante parámetro.
Función/Procedimiento Paso de variable por valor

Procedimiento void imprimeAlgo()
NO regresa valor (solo imprime {
cout << “Algo”;
algo), NO recibe parámetros.
}
Función int void regresaValor()
SI regresa un entero, NO recibe {
return 100;
parámetros.
}
Procedimiento void hallaSuma(int a, int b)
NO regresa valor, SI recibe dos {
int suma = a + b;
parámetros enteros.
cout << “La sumas es : ” << suma;
}
Función int hallaSuma(int a, int b)
SI regresa un entero, SI recibe {
int suma = a + b;
dos parámetros enteros.
return suma;
}
Función double promedio(double a, double b, int c)
SI regresa un double, SI recibe {
double suma = a + b + (double)c;
tres parámetros enteros.
double prom = suma / 3.0;
return prom;
}
Función bool aprobaste(double nota)
Regresa un valor booleano {
if (nota >= 12.5)
(verdad o falso), SI recibe un
return true;
parámetro double. else
return false;
}
Procedimiento void combina(int a, int b)
La función NO regresa valor, {
int suma = hallaSuma(a, b);
recibe dos parámetros enteros.
double prom = promedio(suma, 15.0,
10);
Importante: El procedimiento if (aprobaste(prom))
combina llama a las funciones cout << “Felicitaciones”;
else

hallaSuma, promedio y cout << “Lo siento”;
Aprobaste. }
2.5 Funciones de programador: paso de variables por

referencia
Las funciones, dependiendo del lenguaje, tienen una pequeña variación en
cuanto a su forma. Cuando se llama a este tipo de función, se le pasa las
variables fuente, estas se reciben en la función que corresponde mediante
variables destino (argumentos). Para cumplir con su tarea, las funciones usan las
variables que llegan a través del argumento. SI es posible modificar el valor de
la variable fuente, dado que a través del argumento se pasa la dirección de la
variable fuente en la memoria estática.
Función/Procedimiento Paso de variable por referencia

Procedimiento void hallaSuma(int &a, int &b)
NO regresa valor, SI recibe dos {
argumentos enteros mediante int suma = a + b;
parámetros por referencia. cout << “La sumas es : ” << suma;
El valor de la variable original a=500;
que se corresponde con la }
variable “a”, cambia a 500.
Función int hallaSuma(int &a, int &b)
SI regresa valor, SI recibe dos {
argumentos enteros mediante int suma = a + b;
parámetros referencia. a=600;
El valor de la variable original return suma;
que se corresponde con la }
variable “a”, cambia a 600.
2.6 Funciones de programador: Llamando a una función

Al momento de invocar a las funciones, las variables fuentes con los argumentos
se corresponden biunívocamente y en el mismo orden. Si la función a la que se
llama permite paso por valor, los valores de la variable fuente (original) NO
pueden modificarse cuando se ejecute la función. Si la función a la que se
llama, permite paso por referencia, los valores de la variable fuente (original) SI
pueden modificarse cundo se ejecuta la función.
Función/Procedimiento Estructura
La función (procedimiento en void hallaSuma(int va, int vb)
este caso) hallaSuma NO regresa {
int suma = va + vb;
valor, recibe mediante el cout << “La sumas es : ” << suma;
parámetro “va” el valor de la va=500;
variable num1. NO se modifica el }
valor de la variable num1.
void combina(int a, int b)
{
El procedimiento combina llama al int num1 = 14;
procedimiento hallaSuma int suma = hallaSuma(num1, b);
pasándole el valor de la variable cout<<num1; //14
num1. }

La función (procedimiento en void hallaSuma(int &va, int &vb)
este caso) hallaSuma NO regresa {
int suma = va + vb;
valor, recibe mediante el cout << “La sumas es : ” << suma;
parámetro “va” en valor de la va=500;
variable num1. SI se modifica el }
valor de la variable num1.
void combina(int a, int b)
{
El procedimiento combina llama al int num1 = 14;
procedimiento hallaSuma int suma = hallaSuma(num1, b);
pasándole la dirección de la cout<<num1; //500
variable num1. return suma;
}
2.7 Namespaces
Los namespaces se utilizan para agrupar funciones.
•
No son una característica de C, sino de C++.
•
Al agrupar funciones podemos tener dos o más funciones con el
•
mismo nombre siempre y cuando estén en diferentes namespaces.
• Para agrupar a las funciones solo basta colocar a todas las funciones
dentro de un bloque como el que sigue:
namespace <nombre>
{
Funciones …
•Donde <nombre> es el nombre de la agrupación de funciones.

•Para acceder a las funciones dentro del namespace basta con
colocar <nombre>::<nombre función>()
Ejemplo ilustrativo
#include <iostream>
#include <conio.h>
void ImprimeLinea()
{
cout << "Linea\n";
}
namespace guiones
{
void ImprimeLinea()
{
cout << "------------------------\n";
}
}
namespace asteriscos
{
void ImprimeLinea()
{
cout << "***********************\n";
}
}
void main()
{

ImprimeLinea();
guiones::ImprimeLinea();
asteriscos::ImprimeLinea();
_getch();
}
3 SOLUCIÓN DEL PROBLEMA PROPUESTO

Matriz de variables
TIPO VARIABLE DESCRIPCIÓN

Entero Discriminate
Entero X1
Real X2

a, b, c discriminante = potencia(b,2) – 4 * a * c x1
discriminante = raiz(discriminante) x2
x1 = hallaValor(a, b, discriminante)
x2 = hallaValor(a, b, - discriminante)
hallaValor (vala,valb,vald)
resultado = (-vala + vald) / (2 * vala)
Diagrama de flujo principal Sub proceso

3.3 Diagrama N-S
Función principal Función construida

ecuacioncuadratica.psc
SubProceso resultado <- hallaValor (vala,valb,vald)
FinSubProceso
Leer a
Leer b
Leer c;

FinProceso

3.5 Código en C++
ecuacioncuadratica.cpp
#include<iostream>
#include<cmath>
double hallaValor(float a, float b, float d)
{
float resultado;
resultado= (-b + d) / (2 * a);
return resultado;
}
void main()
{
float a, b, c, discriminante, rd, x1, x2;
cout << "Ingrese el coeficiente a: ";
cin >> a;
cout << "Ingrese el coeficiente b: ";
cin >> b;
cout << "Ingrese el coeficiente c: ";
cin >> c;
discriminante = pow(b,2)-4 * a * c;
rd = sqrt(discriminante);
x1 = hallaValor(a, b, rd);
x2 = hallaValor(a, b, -rd);
cout << "La primera raiz es: " << x1 <<endl;

cout << "La segunda raiz es: " << x2 << endl;
system("pause");
}
3.6 Resultados del código C++
Ingrese el coeficiente a : 2
Ingrese el coeficiente b : 3
Ingrese el coeficiente c : -8
La primera raiz es : 1.386
La segunda raiz es : -2.886

Resuelto 1 El dueño de una casa desea calcular el gasto de agua en su
vivienda si se tiene como dato el número de litros consumidos. Se sabe
además que el sistema de cobro es el siguiente:
• La cuota fija mensual es de 20 soles
• Por los primeros 50 litros no se cobran (opción 1)
• Entre 51 y 200 litros se cobra el litro a 2 soles (opción 2)
• A partir de 201 litros el litro, por encima de 200, se cobra a 3.5 soles (opción
3)
Elabore el algoritmo y represéntelo mediante un programa en C++ que permita
calcular el gasto de agua.
Por ejemplo:
Si el consumo fuese 250 litros entonces el pago sería: 20 + 50*0 + 150*2 + 50*3.5
Solución
1. Matriz inicial de entradas y salidas
q pago
2. Matriz de variables
Entero q Cantidad de litros de agua
consumidos
Real pago Pago por la cantidad de litros
consumidos, teniendo en cuenta los
descuentos respectivos
3. MEPS: Matriz de entradas, proceso y salidas
q calculaPago(q) pago
4. Diagrama Nassi
Funciones Principal
5. Programa
#include <iostream>
int calculaPago(int cantidad)
{

int pago;
((cantidad <= 50) && (pago = 0)) ||
((cantidad > 50 && cantidad <= 200) && (pago = (cantidad - 50) *
2)) ||
((cantidad > 200) && (pago = 300 + (cantidad - 200)*3.5));
return pago + 20;
}
void main() {
int q = 100;
cout << "Tu pago es: " << calculaPago(q) << endl;
system("pause");
}
Resultados
Tu pago es: 495
Resuelto 2 Una distribuidora de abarrotes con el fin de llevar un mejor control

de sus productos ha decidido implantar un código de barras en cada uno
de los mismos. Este código, de 12 dígitos, contiene la siguiente información
del producto: fecha de vencimiento, una letra que identifica al tipo de
producto y un indicador si se trata de un producto perecible o no.
La estructura del código de barras es el siguiente: DDMMAAAATTPP
Dónde:
DD: día de vencimiento.
MM: mes de vencimiento.
AAAA: año de vencimiento.
TT: Es el código ASCII de la letra que identifica el tipo de producto.
PP: Un entero positivo que indica si el producto es perecible o no.

00 significa perecible.
Se le solicita que elabore un programa en C++ que reciba como dato el código
de barras de un producto y luego nos imprima los siguientes datos tal como se
muestra en el ejemplo.
Ejemplo:
Ingrese código de barras: 120820166712
El programa debe imprimir:
Día de vencimiento : 12
Mes de vencimiento :8
El tipo de producto es :C
Producto perecible (0: No; 1: Sí): 0

Solución
Matriz inicial de entrada y salidas

codigo ¿? DD, MM, AAAA,
TT, PP
Matriz de variables

Entero codigo Código de barras
Entero DD Día
Entero MM Mes
Entero AAAA Año
Entero TT Tipo de producto
Entero PP Producto perecible o no

codigo imprimeValores(codigo) DD, MM, AAAA,
TT, PP
Diagrama Nassi
Funciones Principal
Programa

#include <iostream>
void imprimeValores(long long codigo)
{ //formato DDMMAAAATTPP
int DD, MM, AAAA, TT, PP;
cout <<"Código de barras : "<<codigo << endl;
PP = codigo % 100;
codigo = codigo / 100;
TT = codigo % 100;
AAAA = codigo % 10000;
MM = codigo % 100;
DD = codigo;
cout << "Día de vencimiento :" << DD << endl;
cout << "Mes de vencimiento : " << MM << endl;
cout << "Año de vencimiento : " << AAAA << endl;
cout << "El tipo de producto es : " << char(TT) << endl;
cout << "Producto perecible(0: No; 1: Sí) :" << (((PP == 0) && cout << 0)
|| ((PP != 0) && cout << 1)) << endl;
}
void main() {
long long codigo = 120820166712;
imprimeValores(codigo);
system("pause");
}
Resultados
Código de barras : 120820166712
Día de vencimiento : 12
Mes de vencimiento : 8
El tipo de producto es: C
1Producto perecible (0: No; 1: Sí):1
Resuelto 3 En una entidad del estado se está realizando un proceso de

calificación del personal que labora en la misma. Conocedores de su
habilidad en la programación le solicitan que escriba una aplicación que
ayude a determinar el puntaje que obtiene un empleado.
Para realizar la calificación se tomará en cuenta los siguientes criterios de
asignación de puntos:
Sobre la experiencia:
Años laborando en la Puntos
entidad
Menos de 5 años 5
5 años a más 10
Sobre la educación:
Estudios Puntos
Primarios 5
Secundarios 10

Universitarios 20
Posgrado 30
Se le solicita que elabore un programa en C++ que reciba como datos la
cantidad de años que el empleado labora en la entidad y los estudios realizados
y nos determine e imprima el puntaje obtenido.
Ejemplo
Ingrese la cantidad de años que labora: 10
Estudios (P: primaria; S: secundaria; U: universitario; G: posgrado): U
Puntaje Obtenido: 30
Matriz de variables

Entero cantitad Cantidad de años que labora
Char estudio Estudio máximo que alcanzó
Real pExperiencia Puntaje por años que laboró
Real pEstudio Puntaje por estudios realizados
Real puntaje Puntaje total

cantidad, calculaPuntaje(q, e) puntaje
estudio pExperiencia = (q < 5) * 5 + (q >= 5) * 10
pEstudio = (e == 'P') * 5 + (e == 'S') * 10 + (e == 'U') *
20 + (e == 'G') * 30
puntaje = calculaPuntaje(cantidad, estudio)
Diagrama Nassi
Funciones Principal

Programa
#include <iostream>

int calculaPuntaje(int q, char e)
{
int pExperiencia, pEstudio;
pExperiencia = (q < 5) * 5 + (q >= 5) * 10;
pEstudio = (e == 'P') * 5 + (e == 'S') * 10 + (e == 'U') * 20 + (e == 'G')
* 30;
return pExperiencia + pEstudio;

}
void main() {
int cantidad;
char estudio;
int puntaje;
cout << "Ingrese la cantidad de años que labora: ";
cin >> cantidad;
cout << "P: primaria; S: secundaria; U: universitario; G: posgrado: ";
cin >> estudio;
puntaje = calculaPuntaje(cantidad, estudio);
cout << "Puntaje obtenido es: " << puntaje << endl;
system("pause");
}
Resultados
Ingrese la cantidad de años que labora: 12
P: primaria; S: secundaria; U: universitario; G: posgrado: U
Puntaje obtenido es: 30
Propuesto 1. Se tiene como datos el peso y la altura de una persona y se
desea calcular su índice de masa corporal (IMC = peso [kg] /altura2 [m]).
Debe indicar el estado en el que se encuentra esa persona en función del
valor de IMC:
Valor de IMC Diagnóstico
< 15 Criterio de ingreso en hospital
de 15 a 20 inclusive bajo peso
de 20 a 30 inclusive peso normal (saludable)
de 30 a 40 inclusive sobrepeso (obesidad de grado I)
>40 sobrepeso crónico (obesidad de grado II)
Propuesto 2. Si se ingresa un valor de 6 dígitos, como el siguiente formato:
abcdef. Entonces imprimir un valor con el siguiente formato: afbecd. Por
ejemplo:
Propuesto 3. El presidente de un club de fútbol requiere calcular el sueldo
de sus jugadores si se tiene como dato la edad y nacionalidad del jugador.
Además se sabe que el sueldo se calcula de la siguiente manera:
• Sueldo fijo 2500 soles

• Si es extranjero recibe un bono de 500 soles
Además recibe otro bono:

• Si la edad esta entre 15 y 20 el sueldo se incrementa en 1400 soles • Si la
edad esta entre 21 y 25 el sueldo se incrementa en 1500 soles
• Si la edad esta entre 25 y 30 el sueldo se incrementa en 1200 soles • En
otros casos será de 800 soles.
Determine el sueldo de un jugador si se tienen como datos su edad y
nacionalidad (E: Extranjero; N: Nacional).
Propuesto 4. En la pizzería “Los Tortuninjas” se tienen las siguientes ofertas:

• [1] Por la compra de una pizza grande descuentan el 10%
• [2] Por la compra de una pizza familiar descuentan el 15%
• [3] Por la compra de una pizza fiesta descuentan el 20%.
Entonces solicitar el tipo de pizza, el precio unitario y hallar el total a pagar. Por
ejemplo:
• Tipo de pizza [1, 2, 3]: 1

• Precio: 25
• Total a pagar: 22.50.
6 INVESTIGACIÓN
Resuelva cada uno de los ejercicios propuestos de diferente manera, algunos
de los ejercicios que se resuelven con funciones también se pueden resolver con
procedimientos.
7 EVALUACIÓN

Capítulo 9:
Estructuras de control selectivo
simple y doble
1 PROBLEMA
1.1 Enunciado
Escribir un programa en C++ usando funciones que permita calcular el número de
pulsaciones normales que debe tener una persona por cada 10 segundos de
ejercicio aeróbico.
• Si la persona es del sexo femenino, la fórmula es: Número de pulsaciones = (220

– edad) /10
• Si el sexo es masculino, la fórmula es: Número de pulsaciones = (210 – edad)
/10.
Ejemplo:
Ingrese el sexo de la persona (F o M): F

Ingrese la edad de la persona: 24
El número debe ser de 20 pulsaciones por cada 10 segundos aproximadamente.
Idetifica:


Se trata de calcular la cantidad de pulsaciones que cada 10 segundos debe tener
una persona teniendo en cuenta su edad y su sexo. Nos piden representar la solución
al problema mediante diagrama de flujo de datos, diagrama N-S, pseudocódigo y
código en C++.

sexo, edad … pulsaciones

• ¿Cómo se escribe un programa en C++ para resolver el problema propuesto?
• ¿Cómo se definen estructuras de control condicionales?
2 TEORÍA
Algunos problemas requieren el uso de estructuras de control selectivos, los mismos
que pueden ser: simple, doble, anidadas y múltiples. Se recomienda revisar el capítulo
que correspende a algortimos con diagramas de flujo de datos para ver el formato
de estas estructuras de control.
2.1 Contenido
• Estructura de control de selección simple
• Estructura de control de selección doble
• Estructura de control de selección con anidamiento
• Estructura de control de selección múltiple
• El operador ? :
2.2 De selección simple if

En está estructura, la condición es una expresión lógica como tal puede ser
verdadera o falsa. En caso que la condición sea VERDADERA se ejecutará el bloque
de instrucciones inmediato. . Si la condición es FALSA todo sigue normal.
Formato
if (condición)
{
bloque de instrucciones
}
Ejemplo
if (numero> 0)
cout << "El número es positivo";
Si el bloque de instrucciones sólo contiene una instrucción, no es necesario colocar {

}
2.3 De selección doble

En está estructura, la condición es una expresión lógica como tal puede ser
verdadera o falsa. Si la condición es VERDADERA se ejecutará el bloque de
instrucciones 1, si es FALSA, se ejecuta el bloque de instrucciones 2. Dependiendo del
valor de verdad de la condición solo se puede ejecutar un bloque a la vez y jamás
los dos a la vez.
if (condición)
{

bloque de instrucciones 1
}
else
{
}
2.4 De selección con anidamiento
Ocurre cuando usamos dentro del bloque de instrucciones if o else, otras
sentencias if o if / else. Pudiendo escribirse de dos formas.
Ejemplo ilustrativo
Primera forma Segunda forma

if (edad < 10) if (edad < 10)
{ {
edadCronologica = 'N'; edadCronologica = 'N';
} }
else else if (edad < 15)
{ {
if (edad < 15) edadCronologica = 'A';
{ }
edadCronologica = 'A'; else
} { //podríamos seguir anidando
else edadCronologica = 'M';
{ //podríamos seguir anidando }
edadCronologica = 'M';
}
}
2.5 De selección múltiple
Mediante la etructura switch pasamos una variable cuyo valor será igual a alguno
de los valores en los case. Cuando se da la igualdad se ejecuta el bloque de
instrucciones que le corresponde.
Estructura general Casos especial
switch (variable) switch (variable)
{ {
case valor1: case valor1:
instrucciones1 instrucciones1
break; break;
instrucciones2 case valor3:
break; instrucciones2
... break;
default: ...
instruccionesn; default:
break; instruccionesn;
} break;
}
Dependiendo del valor que le asigne a Cuando variable toma el valor2 o
la variable se ejecuta el grupo de valore3 se ejecuta el grupo de
instrucciones que le corresponde. instrucciones2.

2.6 El operador condicional “?:”
En esta estructuram, si la condición es VERDADERA, el valor de Exp1 se asigna
variable, si es FALSA, se le asignará Exp2. Tambien podemos hacer anidamiento.
Expresión condicional Equivale a:

variable = condición ? Exp1 : Exp2; if (condición)
{
variable = Exp1;
}
else
{
variable = Exp2;
}
Importante: el operador ?: permite obtener resultados numéricos y de texto, su
combinación requiere de ciertas modificaciones.
Ejemplo ilustrativo 1: El valor de descuento puede ser 10%, 20% o 50%, dependiendo
del costo de un producto.
#include<conio.h>
#include<iostream>
#include"Catalogo.h"
void main()
{
double descuento;
descuento = (costo < 1000 ? 0.1 : (costo >= 1000 && costo < 5000 ? 0.2 : 0.5));

cout << "Descuento : " << descuento*costo << endl;
cout << "Pago : " << costo-descuento*costo << endl;
system("pause");
}
Ejemplo ilustrativo 2: Clasificando un costo

#include<iostream>
void main()
{
string clasificacion;
clasificacion = (costo < 1000 ? "Barato " : (costo >= 1000 && costo < 5000 ?
"Regular" : "Caro"));
cout << "El producto es : " << clasificacion << endl;
system("pause");
}

Ejemplo ilustrativo 3: Combinando texto con número
Es posible que los resultados del operador ?: no se asignen a una variable.
#include<iostream>
void main()
{
int saldo = 22;
double acumuladorTiempoD = 65;
cout << "El producto se vende : ";

(saldo <= 30 ? cout << "\nDelivery: " << acumuladorTiempoD : cout << "En
tienda: " << acumuladorTiempoD / (double)saldo);
cout << endl;
system("pause");
}
3 SOLUCIÓN AL CASO PROPUESTO

Matriz de variables

Entero Sexo Sexo del paciente
Entero Edad Edad del paciente
Real pulsaciones Pulsaciones del paciente

sexo, edad pulsaciones= numeroPulsaciones (sexo, pulsaciones
edad)
numeroPulsaciones Si aSexo='F' Entonces
(aSexo, aEdad) numeroPulsaciones = (220-aEdad) / 10
Sino
numeroPulsaciones = (210-aEdad) / 10

3.3 Diagrama N-S
Función principal

Función numeroPulsaciones

3.4.1 pulsacionesV1.psc
//Con función
SubProceso rPulsaciones<-hallaPulsaciones(sexo, edad)
Definir rPulsaciones Como Real
Si sexo ='F' Entonces
rPulsaciones = (220- edad) / 10;
Sino
FinSi
FinSubProceso
Proceso pulsaciones
Definir pSexo Como Caracter
Definir pEdad Como Entero
Escribir "Ingrese el sexo de la persona (F o M): "
Leer pSexo
Escribir "Ingrese la edad de la persona: "
Leer pEdad
Escribir "El número debe ser de ", hallaPulsaciones(pSexo, pEdad) ,
" pulsaciones por cada 10 segundos aproximadamente"
FinProceso
Resultado
Ingrese el sexo de la persona (F o M):

> F
Ingrese la edad de la persona:
> 65
El número debe ser de 15.5 pulsaciones por cada 10 segundos aproximadamente

3.4.2 pulsacionesV2.psc
//Con procedimiento
SubProceso hallaPulsaciones(sexo, edad)
Definir rPulsaciones Como Real
Si sexo ='F' Entonces
Sino
FinSi
Escribir "El número debe ser de ", rPulsaciones, " pulsaciones por
cada 10 segundos aproximadamente"
FinSubProceso
Proceso pulsaciones
Definir pSexo Como Caracter
Definir pEdad Como Entero
Escribir "Ingrese el sexo de la persona (F o M): "
Leer pSexo
Escribir "Ingrese la edad de la persona: "
Leer pEdad
hallaPulsaciones(pSexo, pEdad)
FinProceso
Resultado
Ingrese el sexo de la persona (F o M):

> M
Ingrese la edad de la persona:
> 46
El número debe ser de 16.4 pulsaciones por cada 10 segundos aproximadamente
3.5 Código en C++
3.5.1 pulsacionesV1.cpp
//Con función
#include<iostream>
int hallaPulsaciones(char sexo, int edad)
{
int numeroPulsaciones;
if (sexo == 'F')
{
numeroPulsaciones = (220- edad) / 10;
}
else
{
numeroPulsaciones = (210- edad) / 10;
}
return numeroPulsaciones;
}
void main()
{
char pSexo;
int pEdad;
cout << "Ingrese el sexo de la persona (F o M): ";

cin >> pSexo;
cout << "Ingrese la edad de la persona: ";
cin >> pEdad;
cout << "El número debe ser de " << hallaPulsaciones(pSexo, pEdad) << "
pulsaciones por cada 10 segundos aproximadamente"<<endl;
system("pause");
}
Resultados
Ingrese el sexo de la persona (F o M) : M
Ingrese la edad de la persona : 84
El n·mero debe ser de 12 pulsaciones por cada 10 segundos aproximadamente
3.5.2 pulsacionesV2.cpp
//Con procedimiento
#include<iostream>
void hallaPulsaciones(char sexo, int edad)
{
int numeroPulsaciones;
if (sexo == 'F')
{
numeroPulsaciones = (220 - edad) / 10;
}
else
{
numeroPulsaciones = (210 - edad) / 10;
}
cout << "El número debe ser de " << numeroPulsaciones << " pulsaciones por cada
10 segundos aproximadamente" << endl;
}
void main()
{
char pSexo;
int pEdad;
cout << "Ingrese el sexo de la persona (F o M): ";
cin >> pSexo;
cout << "Ingrese la edad de la persona: ";
cin >>pEdad;
hallaPulsaciones(pSexo, pEdad);
system("pause");
}
Resultado
Ingrese el sexo de la persona (F o M) : M
Ingrese la edad de la persona : 52
El n·mero debe ser de 15 pulsaciones por cada 10 segundos aproximadamente

Propuesto 1. Escribir un programa en C++ que teniendo como dato de
entrada un número entero, determine si el número es par o impar.
Ejemplo
Ingrese un número entero: 364
Es un número par
Matriz de variables

Entero numero Número entero
String clasificacion Calificación de número

numero clasificaNumero(numero) clasificacion
clasificaNumero(numero) si (numero mod 2 == 0)
clasificacion = "PAR"
sino
clasificacion = "IMPAR"
finsi
Diagrama Nassi
Función principal Funciones y procedimientos

Programa
#include <iostream>
#include<string>

string clasificaNumero(int numero) {
string clasificacion;
if (numero % 2 == 0)
clasificacion = "PAR";
else
clasificacion = "IMPAR";
return clasificacion;
}
void main() {
int numero;
cout << "Numero: ";
cin >> numero;
cout << "EL número que leí es " << clasificaNumero(numero) << endl;
system("pause");
}
Resultados
Numero: 445
El número que leÝ es IMPAR
Propuesto 2. Si se tiene el peso de dos animales: dinosaurio y un elefante,

escribir un programa en C++ que permita calcular cuál de los dos tiene el peso
mayor.
Ejemplo:
Ingrese el peso del dinosaurio: 120.50
Ingrese el peso del elefante: 255.50
El elefante pesa más que el dinosaurio
Matriz de variables

Entero Pd Peso del dinosaurio
Entero pe Peso del elefante
string resultado Mensaje de clasificación

Pd, pe pesaAnimales(double _pd, double _pe) resultado
si (_pd > _pe)
resultado = "El dinosaurio pesa más que el
elefante"
sino
resultado = "El elefante pesa más que el
dinosaurio"

Diagrama Nassi con funciones
Función principal
Funciones y procedimientos
Programa
#include<iostream>
#include<string>
string pesaAnimales(double _pd, double _pe) {
string resultado;
if (_pd > _pe)
{
resultado = "El dinosaurio pesa mas que el elefante";
}
else {
resultado = "El elefante pesa mas que el dinosaurio";

}
return resultado;
}
void main()
{
double pd, pe;
cout << "Peso del dinosaurio: ";

cin >> pd;
cout << "Peso del elefante: ";
cin >> pe;
cout << pesaAnimales(pd, pe) << endl;
system("pause");
}
Resultado
Peso del dinosaurio : 1542
Peso del elefante : 6554
El elefante pesa más que el dinosaurio
Propuesto 3. Escriba un programa en C++ que teniendo como datos dos

variables numero y opt de tipo entero, obtenga valor de función 𝑓(𝑜𝑝𝑡, 𝑛𝑢𝑚𝑒𝑟𝑜):
100 ∗ 𝑛𝑢𝑚𝑒𝑟𝑜 𝑆𝑖 𝑜𝑝𝑡 = 1
100^𝑛𝑢𝑚𝑒𝑟𝑜 𝑆𝑖 𝑜𝑝𝑡 = 2
𝑓(𝑜𝑝𝑡, 𝑛𝑢𝑚𝑒𝑟𝑜) = {
100/𝑛𝑢𝑚𝑒𝑟𝑜 𝑆𝑖 𝑜𝑝𝑡 = 3
0 𝑐𝑢𝑎𝑙𝑞𝑢𝑖𝑒𝑟 𝑜𝑡𝑟𝑜 𝑣𝑎𝑙𝑜𝑟 𝑑𝑒 𝑜𝑝𝑡
Matriz de variables

Entero val Resultado de la operación
Entero numero Número ingresado
Entero opt Opción

opt, numero Switch(opt) val
{
Case 1:halla1(numero); break;
otro:cout<<0; break;
}
halla1(numero)
halla2(numero)
halla3(numero)

Diagrama Nassi
Función principal Funciones y

procedimientos
Programa
#include<iostream>
#include<conio.h>
#include<math.h>
double halla1(double V)
{
return 100 * V;
}
{
return pow(100, V);
}

{
return 100.0 / V;
}
int main()
{
int opt; double numero;
cout << " Ingrese una opcion (1, 2, 3, 4) :";
cin >> opt;
cout << " Ingresa el numero :";
cin >> numero;
switch (opt)
{
case 1:
cout << " El valor es: " << halla1(numero) << endl;
break;
case 2:
cout << " El valor es: " << halla2(numero) << endl;
break;
case 3:
cout << " El valor es:" << halla3(numero) << endl;
break;
default:
cout << " El valor es: " << " 0 ";
}
_getch();
}
Resultados
Ingrese una opción (1, 2, 3, 4) : 3
Ingresa el valor : 150
El valor es : 0.666667
Propuesto 1. Una discoteca requiere de un programa para leer la edad de un
asistente y mostrar un mensaje que indicando “ACCESO DENEGADO” si no es mayor
de edad. En la solución use el operador lógico de negación. Escriba una función
para verificar la edad cuyo resultado debe imprimirse en la función principal .
Propuesto 2. Una compañía de telefonía necesita un programa que tenga

una funciones necesarias para calcular el costo de una llamada telefónica,
capturando la duración de la llamada en minutos y conociendo lo siguiente:
o Toda llamada que dure 5 minutos o menos tiene un costo de 2 soles.

o Cada minuto adicional cuesta 1.2 soles
o Escriba una función con una estructura condicional simple para calcular el
costo cuyo valor debe imprimirse en la función principal.
Propuesto 3. Escriba un programa que lea la edad de una persona e imprima
si será aceptado en el ejército. Una persona es aceptado si es mayor o ya cumplio
17 años. Implementar una función que devuelva el valor booleano true si la
persona es aceptado o false en caso contrario. Escriba una función con una

estructura condicional doble para validar la edad y el resultado debe imprimirse
en la función principal indicando “ACEPTADO”o “NO ACEPTADO” según
corresponda.
Propuesto 4. El sistema de facturación de la luz se hace de acuerdo al tipo de

consumo realizado, pudiendo ser este comercial (tipo1) o doméstico (tipo 2). El
costo de 1 KWH en el tipo 1 es de S/. 1.58 . El costo de 1 KWH en el tipo 2 es variable:
o Por los primeros 100(que es el consumo mínimo) se paga S/.0.35 por unidad.
o Por el exceso de 100 hasta 500 inclusive se paga S/.1.05 por unidad.
o Por los restantes se paga 1.36 por unidad.
Escriba un programa en C++ que lea el consumo y el tipo e indique la cantidad

total a pagar por el consumo de luz.
Propuesto 5. Escriba un programa en C++ que calcule el número de días de

un mes, dados como datos un mes y un año cualquiera. Debe considerar que
dicho año puede ser o no bisiesto.
6 INVESTIGACIÓN
Elabore los algoritmos en diagrama de flujo o N-S para cada uno de los ejercicios
propuestos. Resuelvalos usando procedimientos y funciones.
7 EVALUACIÓN

Capítulo 10:
Estructuras de control selectivo
con anidamiento
1 PROBLEMA
1.1 Enunciado
El nivel de avance de un estudiante dentro de una universidad se determina, según
el número de créditos cumplidos hasta la fecha (ver tabla).
Créditos Acumulados Año académico

Menos que 32 Primer año
32 a 63 Segundo año
64 a 95 Tercer año
96 o más Cuarto año
Usando esta información, escribir un programa en C++ que acepte el número de
créditos que ha acumulado un estudiante y determine en qué año académico se
encuentra, mostrando los resultados por pantalla
Ejemplo:
Ingrese la cantidad de créditos acumulados: 76

El estudiante se encuentra en el TERCER AÑO
Idetifica:
Este es un problema muy común, en donde se dan varios rangos de valores los mismos
que tenemos que ir anidando ordenadamente. El esquema siguiente puede facilitar
la escritura del código solución.
Primer año Segundo año Tercer año Cuarto año
32 63 96


pCreditos anioAcademico(cCreditos) anioacademico
anioAcademico(creditos) si créditos<32 entonces
Escribir “PRIMER AÑO”
…
• ¿Cómo se definen estructuras de control condicionales con anidamiento?
2 REPASO TEÓRICO
Es suficiente revisar el capítulo que corresponde a algortimos con diagramas de flujo
de datos de para ver el formato de estas estructuras de control, además el tema de
estructuras de control condicional simple y doble.
1.8 Contenido
1.9 De selección con anidamiento
Ocurre cuando usamos en el bloque de instrucciones correspondiente a la
sección del if o del else, otras sentencias if o if / else. Pudiendo escribirse de dos
formas.
Ejemplo ilustrativo

{ {
} }
{ {
{ }
}
}
La solución del problema es un programa de clasificación.

Matriz de variables

Entero pCreditos Número de créditos cumplidos hasta la
fecha
string anioacademico Año académico

pCreditos anioAcademico(cCreditos) anioacademico
anioAcademico(creditos) si créditos<32 entonces
Escribir “PRIMER AÑO”
…
anioAcademico(creditos)

3.3 Diagrama N-S

Función principal


Mostramos el pseudocódigo PSeInt está en formato Smalltalk
Con función
SubProceso resultado<-anioAcademico(c)
Definir resultado Como Caracter
Si c<32 Entonces
resultado= "PRIMER AÑO"
SiNo
Si c<=63 Entonces
resultado ="SEGUNDO AÑO"
SiNo
Si C<=95 Entonces
resultado ="TERCER AÑO"
SiNo
resultado ="CUARTO AÑO"
Fin Si
Fin Si
Fin Si
FinSubProceso
Proceso academico
Definir pCreditos Como Real
Escribir "Cantidad de créditos: ";
Leer pCreditos
Escribir anioAcademico(pCreditos)
FinProceso

Con procedimiento
SubProceso anioAcademico(c)
Si c<32 Entonces
escribir "PRIMER AÑO"
SiNo
Si c<=63 Entonces
escribir "SEGUNDO AÑO"
SiNo
Si C<=95 Entonces
escribir "TERCER AÑO"
SiNo
escribir "CUARTO AÑO"
Fin Si
Fin Si
Fin Si
FinSubProceso
Proceso academico
Definir pCreditos Como Real
Escribir "Cantidad de créditos: ";
Leer pCreditos
anioAcademico(pCreditos)
FinProceso
3.5 Código en C++

3.5.1 estudiantev1.cpp
#include<iostream>
void anioAcademico(int creditos)
{
double rMonto;
if (creditos<32)
{
cout << "El estudiante se encuentra en PRIMER AÑO" << endl;
}
else
{
if (creditos<=63)
{
cout << "El estudiante se encuentra en SEGUNDO AÑO" << endl;
}
else
{
if (creditos <= 95)
{
cout << "El estudiante se encuentra en TERCER AÑO" << endl;
}
else
{
cout << "El estudiante se encuentra en CUARTO AÑO" << endl;
}
}
}
}
void main()
{

int pCreditos;
cout << "Ingrese la cantidad de créditos acumulados : ";
cin >> pCreditos;
anioAcademico(pCreditos);
system("pause");
}
Resultado
Ingrese la cantidad de crÚditos acumulados : 65
El estudiante se encuentra en : TERCER AÑO
3.5.2 estudianteV2.cpp
#include<iostream>
void anioAcademico(int creditos)
{
double rMonto;
if (creditos<32)
{
cout << "El estudiante se encuentra en PRIMER AÑO" << endl;
}
else if (creditos<=63)
{
cout << "El estudiante se encuentra en SEGUNDO AÑO" << endl;
}
else if (creditos <= 95)
{
cout << "El estudiante se encuentra en TERCER AÑO" << endl;
}
else
{
cout << "El estudiante se encuentra en CUARTO AÑO" << endl;
}
}
void main()
{
int pCreditos;
cout << "Ingrese la cantidad de créditos acumulados : ";
cin >> pCreditos;
anioAcademico(pCreditos);
system("pause");
}
Resultado
Ingrese la cantidad de crÚditos acumulados : 23

El estudiante se encuentra en : PRIMER AÑO

Resuelto 1. El discriminante D = B2 - 4AC de la ecuación general de segundo grado
Ax2+Bxy+Cy2+Dx+Ey+F=0 nos permite averiguar la forma de la gráfica.
• Si D<0 y los coeficientes A y C son iguales, la grafica será una circunferencia,
sino, será una elipse.
• Si D>0, la gráfica será una hipérbola.
• Si D=0 y los coeficientes A y C son iguales a cero, la grafica es una recta, sino,
será una Parábola.
Escriba un programa que:
• Reciba los valores de los coeficientes, el centro y reporte el tipo de gráfica que
representa la ecuación
• Reciba un punto P cualquiera y reporte si el punto pertenece o no a la gráfica
• Suponiendo que el centro de la grafica es el punto (0,0), indicar en qué
cuadrante se encuentra el punto P.
Programa
#include<iostream>
float px, py, x, y;
void validaPunto(float A, float B, float C, float D, float E, float F)
{
float tmp = A * pow(px, 2) + B * px*py + C * pow(py, 2) + D * px + E * py + F;
if (tmp == 0) cout << "El punto P SI pertence a la gráfica" << endl;
else cout<< "El punto P NO pertence a la gráfica" << endl;
}
void validaGrafica(float A, float B, float C, float D, float E, float F)
{
float discriminante=pow(B,2)-4*A*C;
if (discriminante < 0)
{
if (A == C) cout << "CIRCCUNFERENCIA" << endl;
else cout << "ELIPSE" << endl;
}
else if (discriminante > 0)
{
cout << "HIPERBOLA" << endl;
}
else
{
if (A == C) cout << "RECTA" << endl;
else cout << "PARÁBOLA" << endl;
}
}
void main()
{
float A, B, C, D, E, F;
cout << "Valor de A: "; cin >> A;
cout << "Valor de B: "; cin >> B;
cout << "Valor de C: "; cin >> C;
cout << "Valor de D: "; cin >> D;
cout << "Valor de E: "; cin >> E;

cout << "Valor de F: "; cin >> F;
cout << "Centro X: "; cin >> px;
cout << "Centro Y: "; cin >> py;
cout << "Punto X: "; cin >> x;
cout << "Punto Y: "; cin >> y;
cout << endl;
validaGrafica(A, B, C, D, E, F);
validaPunto(A, B, C, D, E, F);
}
Resultado
Valor de A: 2
Valor de B: 5
Valor de C: -7
Valor de D: 1
Valor de E: 5
Valor de F: 6
Centro X: 10
Centro Y: 10
Punto X: 5
Punto Y: 6
HIPERBOLA
El punto P NO pertence a la gráfica
Resuelto 2. Una línea de transporte interprovincial establece un plan de descuentos
(A, B y C) en el precio de sus boletos en función del perfil del pasajero:
• A: Los pasajeros menores de 4 años no pagan. Los pasajeros cuya edad está
entre 4 y 7 años pagan 52% del boleto. Los mayores de 68 años pagan el 55%
del boleto. Para los demás no hay descuentos.
• B: Los pasajeros que son estudiantes pagan el 50% del precio.
• C: A los miembros de familia de más de 5 personas se les descuenta 23% del
precio.
Escribir un programa que reciba como entrada el precio de un boleto y los datos
necesarios para averiguar cuál de los planes le conviene al pasajero, imprimir que
porcentaje de descuento que se aplica y el precio rebajado según el plan asignado.
Analsisis
Para calcular el pago relacionado a la edad:
pagoEdad = 0 pagoEdad = 0.52*p pagoEdad = p pagoEdad = 0.55*p
4 7 68

Programa
#include<iostream>
void imprimePago(float ped, float pes, float pf, float p)
{
if (ped<pes && ped<pf)
{
cout << "Plan A, total : " << p << endl;
cout << "Plan A, descuento: " << p - ped << endl;
cout << "Precio rebajado : " << ped << endl;
} else if (pes < pf && pes < ped)
{
cout << "Plan B, total : " << p << endl;
cout << "Plan B, descuento: " << p - pes << endl;
cout << " Precio rebajado : " << pes << endl;
} else
{
cout << "Plan C, total : " << p << endl;
cout << "Plan C, descuento: " << p - pf << endl;
cout << "Precio rebajado: " << pf << endl;
}
}
void calculaPago(int edad, char e, int f, int p)
{
float pagoEdad, pagoFamilia, pagoEstudiante;
if (edad < 4) pagoEdad = 0;
else if (edad < 7) pagoEdad = 0.52*p;
else if (edad <= 68) pagoEdad = p;
else pagoEdad = 0.55*p;
pagoEstudiante = p;
if (toupper(e) == 'S') pagoEstudiante = 0.5*p;
pagoFamilia = p;
if (f>5) pagoFamilia = p - 0.23*p; //pagoFamilia=0.77*p
imprimePago(pagoEdad, pagoEstudiante, pagoFamilia, p);
}
void main()
{
char estudiante;
int familia, edad, precioUnitario;
cout << "Cual es su edad : "; cin >> edad;
cout << "Es usted estudiante S/N : "; cin >> estudiante;
cout << "Cuantas personas viven en su casa : "; cin >> familia;
cout << "Precio del boleto : "; cin >> precioUnitario;
cout << endl;
calculaPago(edad, estudiante, familia, precioUnitario);
}
Resultado
Cual es su edad : 5
Es usted estudiante S/N : S
Cuantas personas viven en su casa: 6
Precio del boleto : 200

Plan B, total : 200
Plan B, descuento : 100
Plan B, PAGUE : 100
Propuesto 1. El presidente de un club de fútbol requiere calcular el sueldo de
sus jugadores si se tiene como dato la edad y nacionalidad del jugador.
Además se sabe que el sueldo se calcula de la siguiente manera:
• Sueldo fijo 2500 soles

• Si es extranjero recibe un bono de 500 soles
• Si la edad esta entre 15 y 20 el sueldo se incrementa en 1400 soles
• Si la edad esta entre 21 y 25 el sueldo se incrementa en 1500 soles
• Si la edad esta entre 25 y 30 el sueldo se incrementa en 1200 soles - En otros
casos el sueldo será de 800 soles.
Se le pide elaborar un programa en C++ que permita determinar el sueldo de un

jugador si se tienen como datos su edad y nacionalidad (E: Extranjero; N: Nacional).
Nota: Debe validar los datos de entrada para una correcta ejecución de su
programa.
Propuesto 2. El costo de una póliza de seguros para automóviles se calcula de

la siguiente forma:
Costo total = 3% del valor del automóvil+ Cargo por modelo + Cargo por la edad del
propietario + Cargo por accidentes previos.
Escriba un programa que lea el nombre y la edad del propietario, el valor del
automóvil, el modelo y el número de accidentes que ha tenido; e imprima el nombre
del propietario seguido del costo de la póliza. El cargo por accidentes previos es de
$15 por los primeros tres accidentes y $20 por cada accidente extra. La compañía no
asegura automóviles a personas con edad fuera de estos rangos.
Utilice los siguientes datos para determinar los cargos:
Cargo por modelo Cargo por la edad

Modelo % del valor del auto Edad Cargo
90 o anterior 0.10% 18 a 23 años $ 350
91-97 0.30% 24 a 55 años $ 200
98 o más
reciente 0.50% 56 a 65 años $ 400

Propuesto 3. Una línea de transporte interprovincial establece descuentos en
el precio de sus boletos en función del perfil del pasajero:
• Por edad, los pasajeros menores de 4 años no pagan. Los pasajeros cuya edad
está entre 4 y 7 años tienen un descuento de 5.5% del boleto, los mayores de
68 de 8% del boleto y para los demás no hay descuentos.
• Por ser estudiantes, los pasajeros tiene descento de 4% del precio.
• Por ser miembro de familia de más de 5 miembros se les descuenta 3% del
precio.
Escribir un programa que reciba como entrada el precio de un boleto y los datos
necesarios para calcular el precio final del boleto, imprimir que porcentaje de
descuento que se aplica.
6 INVESTIGACIÓN
Resuelva cada uno de los ejercicios propuestos de diferente manera, algunos de los
ejercicios que se resuelven con funciones también se pueden resolver con
procedimientos.
7 EVALUACIÓN

Capítulo 11:
Estructura de control selectiva
combinada
1.1 PROBLEMA PROPUESTO
1.2 Enunciado
Una empresa de software vende aplicaciones para celulares (iPhone y Android) y
requiere un programa que genere el resumen por cada venta realizada. Los productos
que vende dicha empresa son:
Tipo Producto Tipo de Celular Precio x unidad

O Oficina iPhone 50.60
Android 20.30
J Juegos iPhone 90.80
Android 40.50
U Utilitarios iPhone 60.50
Android 30.60
Asimismo, el programa solicita la cantidad de aplicaciones que el cliente va a comprar.
Se le solicita que elabore un programa en C++ que reciba como datos el tipo de
producto, el tipo de celular (I: iPhone; A: Android) y la cantidad de unidades que el
cliente comprará y nos determine e imprima el monto que deberá pagar este.
Nota: Debe validar los datos de entrada para una correcta ejecución de su programa.
1.3 Reflexionemos
Idetifica:
1.4 Análisis del problema y propuesta de solución

Este es un problema común en donde se debe combinar estructura de control simple,
doble y anidada. Para cumplir con este propósito necesitamos saber cuáles son las
entradas y salidas del programa en la matriz de entrada/salida


pProducto, ¿? monto
pTipo,
pCantidad
¿?
• ¿Cómo se definen estructuras de control condicionales combinando estructura
de control simple, doble, múltiple y de anidamiento?
2 REPASO TEÓRICO
Recomendamos revisar los capítulos que correspeonde a algortimos con diagramas de
flujo de datos, ademas del capitulo de estructuras control selectivas simples, dobles y
anidadas para repasar el formato de estas estructuras de control.
2.1 Contenido
• Estructura de control de selección simple
• Estructura de control de selección doble
2.2 Selección simple

La condición es una expresión lógica. En caso que la condición sea VERDADERA se
ejecutará el bloque de instrucciones. Si el bloque de instrucciones sólo contiene una
instrucción, no es necesario colocar { }. Si la condición es FALSA todo sigue normal.
Condicional simple
if (condición)
{
bloque de instrucciones
}
Ejemplo
if (numero> 0)
cout << "El número es positivo";
2.3 Selección doble

La condición es una expresión lógica. Si la condición es VERDADERA se ejecutará el
bloque de instrucciones 1, si es FALSA, se ejecuta el bloque de instrucciones 2. Si el
bloque de instrucciones sólo contiene una instrucción, no es necesario colocar { }.
Dependiendo del valor de verdad de la condición solo se puede ejecutar un bloque a
la vez.

Condicional doble
if (condición)
{
}
else
{
}
2.4 Selección con anidamiento
Ocurre cuando usamos en el bloque de instrucciones correspondiente a la
sección del if o del else, otras sentencias if o if / else. Pudiendo escribirse de dos
formas.
Ejemplo ilustrativo

{ {
} }
{ {
{ }
}
}
Matriz de variables

char pProducto Identificador del producto
char pTipo Identificador del tipo de producto
int pCantidad
double monto

pProducto, pTipo, monto=calculaMonto(pProducto, monto
pCantidad pTipo, pCantidad)
calculaMonto(producto, tipo,
cantidad)
rMonto = cantidad * 50.60
…

Diagrama de flujo principal
calculaMonto(producto, tipo, cantidad)
3.3 Diagrama N-S

Función principal

calculaMonto(producto, tipo, cantidad)

3.4.1 software.psc
SubProceso rMonto<-calculaMonto(producto, tipo, cantidad)
Definir rMonto Como Real
Si producto == 'O' || producto == 'o' Entonces

Si tipo == 'I' || tipo == 'i' Entonces
rMonto = cantidad * 50.60;
SiNo
Si tipo == 'A' || tipo == 'a' Entonces
SiNo
Escribir "Tipo de celular incorrecto"
FinSi
FinSi
SiNo
Si producto == 'J' || producto == 'j' Entonces

SiNo
SiNo
FinSi
FinSi
SiNo
Si producto == 'U' || producto == 'u' Entonces
SiNo
SiNo
FinSi
FinSi
SiNo
Escribir "Producto incorrecto"
FinSi
FinSi
FinSi
FinSubProceso
Proceso principal
Definir pProducto, pTipo Como Caracter
Definir pCantidad Como Entero
Definir monto Como Real
Escribir "Ingrese producto (O)Oficina, (J)Juegos, (U)Utilitarios: "
Leer pProducto
Escribir "Ingrese tipo de Celular (I)Iphone, (A)Android : "
Leer pTipo
Escribir "Cantidad a comprar : "
Leer pCantidad;
monto = calculaMonto(Mayusculas(pProducto), Mayusculas(pTipo),
pCantidad)
Escribir "Monto a pagar es: ",monto
FinProceso
Resultado
Ingrese producto (O)Oficina, (J)Juegos, (U)Utilitarios:

> O
Ingrese tipo de Celular (I)Iphone, (A)Android :
> I
Cantidad a comprar :
> 10
Monto a pagar es: 506
3.5 Código en C++
3.5.1 software.cpp
#include<iostream>
double calculaMonto(char producto, char tipo, int cantidad)
{

double rMonto;
if (producto == 'O' || producto == 'o')

{
if (tipo == 'I' || tipo == 'i')
{
}
else if (tipo == 'A' || tipo == 'a')
{
}
else
{
cout << "Tipo de celular incorrecto" << endl;
}
}
else if (producto == 'J' || producto == 'j')
{
if (tipo == 'I' || tipo == 'i')
{
}
{
}
else
{
}
}
else if (producto == 'U' || producto == 'u')
{
if (tipo == 'I' || tipo == 'i')
{
}
{
}
else
{
}
}
else
{
cout << "Producto incorrecto" << endl;
}
return rMonto;
}
void main()
{
char pProducto, pTipo;
int pCantidad;
double monto;
cout << "Ingrese producto O(Oficina), J(Juegos), U(Utilitarios): ";
cin >> pProducto;
cout << "Ingrese tipo de Celular I(phone), A(Android) : ";

cin >> pTipo;
cout << "Cantidad a comprar : ";
cin >> pCantidad;
monto = calculaMonto(pProducto, pTipo, pCantidad);
cout << "Monto a pagar es: " << monto<<endl;
system("pause");
}
Resultados
Ingrese producto O(Oficina), J(Juegos), U(Utilitarios) : O
Ingrese tipo de Celular I(phone), A(Android) : A
Cantidad a comprar : 15
Monto a pagar es : 304.5
Resuelto 1. Una distribuidora de electrodomésticos con el fin de llevar un mejor control
de sus productos ha decidido implantar un código de barras en cada uno de los
mismos. Este código, de 12 dígitos, contiene la siguiente información del producto:
fecha de caducidad, una letra que identifica al tipo de producto y un indicador si
se trata de un producto de gama alta o no.
La estructura del código de barras es el siguiente: AAAADDMMTTPP Dónde:
• DD: día de vencimiento.

• MM: mes de vencimiento.
• AAAA: año de vencimiento.
• TT: Es el código ASCII de la letra que identifica el tipo de producto.
• PP: Un entero que indica si el producto es de gama alta o no. Únicamente 00
significa que es de gama alta (en los demás casos es de gama baja).
Se le solicita que elabore un programa en C++ que reciba como dato el código de
barras de un producto y luego nos imprima los siguientes datos tal como se muestra en
el ejemplo.
Ejemplo:
Ingrese código de barras: 202412086712
Día de vencimiento: 12 Mes de vencimiento: 8 Año de vencimiento: 2024 El tipo de

producto es: C
Producto perecible (0: No; 1: Sí): 0
Codigo
#include<iostream>
void desencriptaCodigo(long long *n) {
//202412086712
int gama = *n % 100;
*n = *n / 100;
int letra=*n % 100;
*n = *n / 100;
int mes = *n % 100;

*n = *n / 100;
int dia = *n % 100;
* n = *n / 100;
int anio = *n;
cout << "Año de vencimiento: " << anio<<endl;
cout << "Dia de vencimiento: " << dia << endl;
cout << "Mes de vencimiento: " << mes << endl;
cout << "Tipo de producto: " << char(letra) << endl;
cout << "Gama alta: " << (gama==0?"1":"0")<< endl;
}
void main() {
long long *codigo = new long long;
cout << "Ingrese el código de barras: "; cin >> *codigo;
if(*codigo>100000000000 && *codigo<=999999999999) desencriptaCodigo(codigo);
else cout << "El código es equivocado";
}
Resultados
Ingrese el c¾digo de barras: 124547587854

A±o de vencimiento: 1245
Dia de vencimiento: 47
Mes de vencimiento: 58
Tipo de producto: N
Gama alta: 0

Propuesto 1. Un vendedor en línea no ha visto mejor forma que asignarle
precio a las zapatillas que vende en facebook. Sin embargo, como la tarea no es
tan fácil, requiere contar con un algoritmo que represente la solución para esta
tarea, entonces se ha contactado con usted para que escriba un programa que
permita dar con los precios de venta más adecuados.
El precio final depende de:
• Cantidad de likes que recibe el producto

• Procedencia: 0: Importado, 1: Nacional y 2: Fabricado por el vendedor
El precio parcial por los likes se da según la siguiente tabla:
Cantidad de likes Precio parcial

0<= cantidad de likes < 150 120
Más de 2000 likes 150
En todos los demás casos 200
El precio parcial por la procedencia del producto se da según la siguiente tabla:
Procedenci Precio
a parcial
0 200
1 160
2 180
El precio final se consigue sumando el precio parcial obtenido por la cantidad de likes
con el precio parcial obtenido por la procedencia. Con el precio final obtenido, el
programa debe clasificar su producto en base a la siguiente información:
Precio final Clasificación

del producto
Es >= 100 y <= 400 BARATO
Es > 400 y <= 900 GAMA MEDIA
En otros casos GAMA ALTA
Propuesto 2. El programa nacional de becas “Pronabec”, conoce de su
habilidad en la programación y le solicita que escriba un programa que ayude a
preevaluar si se le puede otorgar o no la beca a una solicitante. Para realizar la
preevaluación de la persona se tomará en cuenta los siguientes criterios:

SUELDO MENSUAL DEL PADRE PUNTOS VIVIENDA PUNTOS
< 1500 30 Pariente 10
≥ 1500 y ≤ 6000 20 Alquilada 15
> 6000 10 Propia 5
Huérfano Puntos Cantidad de Puntos

hermanos
No 2 No tiene 1
Si 10 Entre 2 y 4 hermanos 7
Más de 4 hermanos 10
Cada criterio otorga un puntaje, para el puntaje total se suman los puntos obtenidos
por cada criterio. Para que a la persona se le pueda otorgar la beca, debe alcanzar
un puntaje total superior a 42.
Se le solicita que elabore un programa en C++ que reciba como datos de la persona
el sueldo mensual del padre, el tipo de vivienda donde vive, si es huérfano o no y si
tiene hermanos o no, y nos determine e imprima el puntaje obtenido y si se le otorga
o no la beca.
Ejemplo
Sueldo mensual: 1800

Vivienda (P: pariente; A: alquilada; M: propia): M
Huérfano (N: no; S: si): N

Cantidad de hermanos: 6
Puntaje Obtenido: 34
Se le otorga la beca (0: No; 1: Sí): 0
6 INVESTIGACIÓN
Resuelva cada uno de los ejercicios propuestos de diferente manera, algunos de los
ejercicios que se resuelven con funciones también se pueden resolver con
procedimientos.
7 EVALUACIÓN

Capítulo 12:
Estructura de control
selectiva múltiple
1 PROBLEMA
1.1 Enunciado del problema
Una tienda de venta de productos agrícolas al por mayor le ha solicitado que
elabore un programa que permita generar la boleta de venta de los clientes
que en ella compran.
Cuando el cliente realiza la compra se le solicita el tipo de producto y la

cantidad de sacos que comprará.
Los productos que vende dicha tienda son:
Tipo Producto Precio x saco

P Papa 20.5
C Cebolla 19.4
L Limón 32.3
A Ají 16.5
M Maíz 19.8
Se le solicita que elabore un programa en C++ que reciba como datos el tipo
de producto y la cantidad de sacos que el cliente comprará y nos determine e
imprima el monto que deberá pagar este.
Importante: Debe validar los datos de entrada para una correcta ejecución de
su programa.
Idetifica:
o Los procedientos y cálculos que se requieren para solucionar el

problema

Nos piden un programa que dado un tipo y cantidad de un producto, el
programa calcule el monto a pagar por una compra. Para cumplir con este
propósito necesitamos saber cuáles son las entradas y salidas del programa en
la matriz de entrada/salida

pTipo, monto=calculaMonto(pProducto, monto
pCantidad pCantidad)
calculaMonto(producto, cantidad)
rMonto = cantidad *20.5
…

propuesto?
• ¿Cómo se definen estructuras de control condicionales múltiples?
2 REPASO TEÓRICO
2.1 Contenido
• Estructura de control de selección múltiple
2.2 Estructura de control de selección múltiple

Mediante el switch pasamos una variable cuyo valor será igual a alguno de los
valores en los case. Cuando se da la igualdad se ejecuta el bloque de
instrucciones que le corresponde.
Estructura general Casos especial
switch (variable) switch (variable)
{ {
instrucciones1 instrucciones1
break; break;
instrucciones2 case valor3:
break; instrucciones2
... break;
default: ...
instruccionesn; default:
break; instruccionesn;
} break;
}
Dependiendo del valor que le Cuando variable toma el valor2 o
corresponda a la variable se ejecuta valore3 se ejecuta el grupo de
el grupo de instrucciones que le instrucciones2.
corresponde. case valor2:
case valor3:

Matriz de variables

char pProducto Identificador del tipo de producto
int pCantidad Cantidad de productos a comprar
double monto El monto a pagar por la compra

pProducto, monto=calculaMonto(pProducto, monto
pCantidad pCantidad)
rMonto = cantidad *20.5
…
calculaMonto(pProducto, pCantidad)

3.3 Diagrama N-S
Función principal

3.4.1 agricola.psc
SubProceso rMonto<-calculaMonto(producto, cantidad)
Definir rMonto Como Real
Segun producto Hacer

'P':
'C':
'L':
'A':
'M':
De Otro Modo:
Escribir "No vendemos este producto "
Fin Segun
FinSubProceso
Proceso principal
Definir pProducto Como Caracter
Definir pCantidad Como Entero
Definir monto Como Real
Escribir "Ingrese producto (P, C, L, A, M): "
Leer pProducto
Escribir "Cantidad a comprar : "
Leer pCantidad;
monto = calculaMonto(Mayusculas(pProducto), pCantidad)
Escribir "Monto a pagar es: ",monto
FinProceso
Resultado
Ingrese producto (P, C, L, A, M):
> P
Cantidad a comprar :
> 15
Monto a pagar es: 307.5
3.5 Código en C++
3.5.1 agricola.cpp
#include<iostream>
double calculaMonto(char producto, int cantidad)
{
double rMonto;
switch (producto)
{
case 'P': case 'p':
break;
case 'C':
break;
case 'L':

break;
case 'M':
break;
case 'A':
break;
default:
break;
cout << "Producto no existe (P, C, L, M, A) : " << endl;
}
return rMonto;
}
void main()
{
char pProducto;
int pCantidad;
double monto;
cout << "Ingrese producto (P, C, L, M, A) : ";
cin >> pProducto;
cout << "Cantidad a comprar : ";

cin >> pCantidad;
monto = calculaMonto(pProducto, pCantidad);
cout << "Monto a pagar es: " << monto<<endl;
system("pause");
}
Resultado
Ingrese producto (P, C, L, M, A) : C

Cantidad a comprar : 50
Monto a pagar es: 970
Resuelto 1. Se desea escribir un programa para el cálculo del área de diversas
superficies: cuadrado, rectángulo, círculo, triángulo y trapecio. El programa
mostrará al inicio el siguiente menú:
CÁLCULO DE AREAS DE SUPERFICIES (versión 1.0)
1. Cuadrado lado*lado
2. Círculo pi*radio*radio
3. Rectángulo base*altura
4. Trapecio (base1+base2)*altura/2
5. Triángulo (base*altura)/2
Seguidamente leerá de la entrada estándar un valor que estará comprendido

entre 1 y 5, indicando el tipo de superficie cuya área se desea calcular. El
programa leerá entonces los datos que necesite para calcular el área en
cuestión.

Programa
#include<iostream>
void menu()
{
cout<<"1. Cuadrado lado*lado" << endl;
cout<<"2. Círculo pi*radio*radio"<< endl;
cout<<"3. Rectángulo base*altura"<< endl;
cout<<"4. Trapecio(base1 + base2)*altura / 2" << endl;
cout<<"5. Triángulo(base*altura) / 2" << endl;
cout << "\nSeleccione una opcion : ";
}
void areaCuadrado(){
float lado;
cout << "Lado del cuadrado : "; cin >> lado;
cout << "Area: " << lado * lado << endl;
}
void areaCirculo() {
float radio;
cout << "Radio del círculo: "; cin >> radio;
cout << "Area: " << 3.1416*pow(radio,2) << endl;
}
void areaRectangulo() {
float ladoa, ladob;
cout << "Lado 1 del rectangulo : "; cin >> ladoa;
cout << "Lado 2 del rectangulo : "; cin >> ladob;
cout << "Area: " << ladoa * ladob << endl;
}
void areaTrapecio() {
float ladoa, ladob, altura;
cout << "Base 1 del trapecio : "; cin >> ladoa;
cout << "Base 2 del trapecio : "; cin >> ladob;
cout << "Altura del trapecio : "; cin >> ladob;
cout << "Area: " << (ladoa + ladob)*altura/2 << endl;
}
void areaTriangulo() {
float ladoa, ladob;
cout << "Base del triangulo : "; cin >> ladoa;
cout << "Altura del triangulo : "; cin >> ladob;
cout << "Area: " << ladoa * ladob/2 << endl;
}
void main()
{
int opt;
menu();
cin >> opt;
switch (opt)
{ case 1:
areaCuadrado();
break;
case 2:
areaCirculo();
break;
case 3:
areaRectangulo();
break;
case 4:
areaTrapecio();
break;
case 5:
areaTriangulo();

break;
default:
cout << "Opcion incorrecta " << endl;
break;
}
}
Resultado
1. Cuadrado lado*lado
2. Círculo pi*radio*radio
3. Rectángulo base*altura
4. Trapecio (base1 + base2)*altura / 2
5. Triángulo (base*altura) / 2
Seleccione una opcion: 3

Lado 1 del rectangulo: 10
Lado 2 del rectangulo: 12
Area: 120
Propuesto 1. Una empresa maderera vende sus bloques de madera en pies
cúbicos al por mayor le ha solicitado que elabore un programa que permita
generar la boleta de venta de los clientes que en ella compran.
Cuando el cliente realiza la compra se le solicita el tipo de madera y la cantidad

de pies cubicos que comprará. Los tipos de madra que vende dicha maderera
son:
Tipo Producto Precio x pie cúbico

I Ishpingo 10
C Cedro 13
B Caoba 11
T Tornillo 16.5
E Eucalipto 8
Se le solicita que elabore un programa en C++ que reciba como datos el tipo
de producto y la cantidad de sacos que el cliente comprará y nos determine e
imprima el monto que deberá pagar este.
Debe validar los datos de entrada para una correcta ejecución de su programa.
Propuesto 2. En una tienda , las ganacias se dan teniendo en cuenta el

penúltimo dígito del código del producto, lo codigos son formados por 6
digitos. El procentaje de ganancias que se ofrecen son los siguientes:

Dígito Descuento sobre el
precio
4, 9 3.5%
1, 5 7%
2, 6 3.5%
8 4.25%
3, 7 12%
Escriba un programa que calcule el precio de venta de cada uno de los
productos teniendo como entrada, el código, la cantidad de productos a
vender y el precio unitario.
Debe validar los datos de entrada para una correcta ejecución de su programa.
Propuesto 3. Una compañía de paquetería nacional tiene servicio de envío en

algunos regiones como: Amazonas, Iquitos, Cusco, Lima, Tacna. El costo por el
servicio de envío de bultos se basa en el peso y la región a la que va dirigido y se
detalla en la tabla adjunta.:
Zona Ubicació Costo/k

n g
1 Amazona S/. 11
s
2 Iquitos S/. 10
3 Cusco S/. 14
4 Lima S/. 15
5 Tacna S/. 11.4
6 INVESTIGACIÓN
Resuelva cada uno de los ejercicios propuestos, tenga en cuenta que algunos
de ellos que se resuelven usando funciones o procedimientos.
7 EVALUACIÓN

Capítulo 13:
repetitiva for
1 PROBLEMA
1.1 Enunciado
Escribir un programa que imprima los N primeros números naturales.
Ejemplo:
N: 10
Números de la sucesión: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
Importante: Debe validar los datos de entrada para una correcta ejecución del
programa.
1.2 Cuestiones generales

Idetifica:
o Los procedimientos y cálculos

Nos piden imprimir los N primeros números naturales. Si N sería un número
pequeño, podríamos escribir la serie imprimiendo número por número la misma
cantidad de lineas de código que N, pero si N sería grande ya no sería
conveniente escribir tantas líneas.
Entradas Cálculos y procedimientos Salidas

pN ¿? 1-2-3-4- … hasta pN
propuesto?
• ¿Cómo se define una estructura de control repetitiva for?
2 REPASO TEÓRICO
Algunos problemas requieren el uso de estructuras de control repetitivas, (for)
y mientras (while).

2.1 Contenido
• Serie numérica
• Estructura de control de repetitiva for
• For anidados
2.1 Serie numérica

En una sucesión de C términos: p, p+r, p+2r, p+3r, p+4r,…, U, se tiene que:
o La razón es r,
o El primer término es p y el último U.
o La cantidad de términos de la sucesión es C=1+(U-p)/r.
Ejemplo: 10, 12, 14, 16, 18, 20, 22. Entonces: p=10, U=22, r=2, C=1 + (22-10)/2=7
o C representa la cantidad de repeticiones en saltos de 1, que se requieren

para sumar los C términos de la sucesión.
2.2 Estructura de control de repetitiva for

Cuando se entra por primera vez a un bucle for se inicializa el contador y se
valida la condición, si ésta es verdadera se ejecuta las sentencias del bloque y
se incrementa el contador y regresamos al bucle para evaluar la condición, el
bucle se repite hasta que la condición sea falsa.
En un problema que requiere solución con este tipo de estructura es importante
separar entre las variables de repetición y de la sucesión.
2.2.1 For en diagrama de flujo de datos

For Lo mismo pero en en estilo while
contador =1 (se inicializa la variable contador, 1 es el límite inferior)

contador<=N (se especifica la condición, n es el límite superior)
contador++ (se incrementa el contador cuando la condición es verdadera)

2.2.2 For en diagrama N-S
2.2.3 For en pseudocódigo

Para contador=1 Hasta N Hacer
Escribir contador
FinPara
2.2.4 El contador
El contador es una variable de repetición que tendrá inicio, fin, salto. A lo largo
del bucle el contador se va modificando, por lo tanto, el valor de la condición
en cualquier momento se hará falsa.
2.2.5 For en código C++

for (int contador = 1; contador <= N; contador++)
{
cout << contador << " - ";
}
Secuencia de cómo se ejecuta la estructura repetitiva for :
1. Primero se inicializa el contador = 1 (1 es el límite inferior).

2. Evaluamos la condicion es decir que contador sea menor o igual a N (N
es el límite superior).
3. Ejecutamos el bloque cout << contador << " - ";
4. Aumenatmos el valor del contador en 1 (contador++)
5. Regresamos al paso 2 de la secuencia para verificar la condición.
2.2.6 For anidado
A veces es necesario implementar un estrutura repetitiva for dentro de otra, a
eso se le llama for anidado.
Ejemplo ilustrativo
//Esto imprime 4 veces "UPC"
#include<iostream>
void main() {
int i;

for( i = 1; i <= 4; i++)
{
cout << "UPC : "<< endl;
}
}
Ejemplo ilustrativo
#include<iostream>
void main() {
int i, j;
for( i = 1; i <= 4; i++)
{
cout << "UPC : " << i << endl;
for (j = 1; j <= 6; j++)
{
cout << "INGENIERIA " << j << endl;
}
}
}
Ejemplo ilustrativo
#include<iostream>
void main()
{
int i, j;
for (i = 1; i <= 6; i++)
{
for (j = 1; j <= 10; j++)
{
cout<<"*";
}
cout << endl;
}
}
Resultado
**********
**********
**********
**********
**********
**********

Matriz de variables

Int pN Numero natural (número positivo mayor que cero)
13 1 - 2 - 3 - 4 - 5 - 6 - 7 - 8 - 9 - 10 - 11 - 12 - 13 -
Entradas Cálculos y procedimientos Salidas

pN imprimeNumeros(N) 1-2-3-4- … N
imprimeNumeros(N)
for (int contador = 1; contador <= N;
contador++)
…
13 1-2-3-4-5-6-7-
8 - 9 - 10 - 11 - 12 - 13
-

Función principal procedimiento

3.3 Diagrama N-S
Función principal Función imprimeNumeros

SubProceso imprimeNumeros(N)
Definir contador Como Entero
Para contador=1 Hasta N Hacer
Escribir contador
FinPara
FinSubProceso
Proceso principal
Definir pN Como Entero
Escribir "Ingrese numero: "
Leer pN
imprimeNumeros(pN)
FinProceso
Resultado
Ingrese numero:
> 5
1
2
3
4
5
3.5 Código en C++

#include<iostream>
void imprimeNumeros(int N)
{
{

}
cout << endl;
}
void main()
{
int pN;
cout << "Cantidad de números naturales: ";
cin >> pN;
imprimeNumeros(pN);
system("pause");
}
Resultado
Cantidad de n·meros naturales: 6

1 - 2 - 3 - 4 - 5 - 6 -
Resuelto 1. Suma los N primeros números naturales múltiplos de un número

dado d. Ejemplo, sea el número dado d=10, N=5, entonces los números a
sumar son 12, 15, 18, 21 y 24.
Análisis
Sabemos que la cantidad de números a sumar será un número natural que

ingresaremos. Implementamos una estructura repetitiva, usando una variable
contador, que recorra los números naturales desde 1 hasta N inclusive y a
medida que los recorremos vamos acumulando el valor de contador en la
variable rSuma. Luego imprimimos el resultado.
En un problema que requiere solución con este tipo de estructura es importante
diferenciar entre las variables de repetición y serie.
Variables de repetición : contador, N
Variables de la sucesión : d, rSuma, contador
Programa
#include<iostream>
void sumaNumeros(int a, int N)
{
double rSuma;
for (int contador = a; contador <= N-a+1; contador++)
{
rSuma = rSuma + contador;
}
cout << "La suma de los 10 primeros números positivos es
posteriores a "<<a<< rSuma << endl;
}

void main()
{
Int a=15, pN = 10;
sumaNumeros(pN);
system("pause");
}
Resuelto 2. Imprimir los N primeros números naturales pares

Análisis
Sabemos la cantidad de números a mostrar será ingresada por el teclado.

Implementamos una estructura repetitiva, usando una variable contador, que
recorra los números naturales desde 1 hasta N inclusive y a medida que los
recorremos vamos imprimiendo el valor de la variable numero. La variable
numero la inicializamos en 2, la incrementamos en dos en cada iteración y la
imprimimos. Las variables :
De repetición : contador, cantidad
De serie : numero, inc
Programa
#include<iostream>
void muestraPares(int cantidad)
{
int inc = 2;
int suma = 2;
for (int contador = 1; contador <= cantidad; contador++) //N números
{
cout << suma << " - ";
suma = suma + inc;
}
cout << endl;
}
void main()
{
int pN;
cout << "Cantidad de nuemros naturales pares: ";
cin >> pN;
muestraPares(pN);
}
Resultado
Cantidad de números naturales pares: 12

2 - 4 - 6 - 8 - 10 - 12 - 14 - 16 - 18 - 20 - 22 - 24 -
Resuelto 3. Suma los números naturales impares menores a N

Análisis

No sabemos la cantidad de números a sumar, pero si sabemos el rango de
números que tenemos que recorrer. Implementamos una estructura repetitiva
usando una variable contador, que recorra los números naturales desde 1 hasta
N inclusive y a medida que los recorremos vamos imprimiendo contador siempre
y cuando cumpla la restricción a la vez que vamos acumulando en la variable
rSuma.
Código V1
#include<iostream>
void sumaImpares(int N)
{
int inc = 2;
int numero = 1;
int rSuma = 0;
for (int contador = 1; contador <= N; contador++) //N numeros
{
if (contador % 2!=0)
{
rSuma = rSuma + contador; //acumula
}
}
cout << "La suma de los impares es " << rSuma << endl;
cout << endl;
}
void main()
{
int pN;
cout << "Ingrese el valor de N : ";
cin >> pN;
sumaImpares(pN);
system("pause");
}
Resultado
Ingrese el valor de N : 12
La suma de los impares es 36
Código V2
No sabemos la cantidad de números a sumar. En esta versión hacemos que el

resultado se imprima de una forma especial. Puede ser práctico incrementar el
contador de 2 en 2 iniciándolo en 3.
Ejemplo
Ingrese N: 10
La suma es 1 + 3 + 5 + 7 + 9 = 25
#include<iostream>
void sumaImpares(int N)
{
double rSuma;
cout << "La suma es " << 1;

for (int contador = 3; contador < N; contador = contador + 2)
{
cout << "+" << contador;

rSuma = rSuma + contador;
}
cout << "=" << rSuma + 1 << endl;
}
void main()
{
int pN;
cout << "Ingrese el número : ";
cin >> pN;
sumaImpares(pN);
system("pause");
}
Resultado
Ingrese el valor número: 12
La suma es 1+3+5+7+9+11=36
Resuelto 4. Escriba un programa en C++ que permita determinar la suma de

los N primeros pares y los M primeros número impares. Tanto N y M, son
número enteros que deberán ser ingresados por el usuario y representan la
cantidad de números que desean operar.
Ejemplo:
Ingrese la cantidad de números pares a sumar: 4

Ingrese la cantidad de números impares a sumar: 5
Sumatoria de pares=2+4+6+8 = 20
Sumatoria de impares=1+3+5+7+9= 25
Análisis
Sabemos la cantidad de números a sumar. Sumaremos una sucesión de

números con incremento de 2.
Programa
#include<iostream>
void anioAcademico(int N, int M)
{
double rSuma;
int sInicio=2, sInc=2;
//Suma de pares
for (int contador = 0; contador < N; contador++)//N números
{ rSuma = rSuma + sInicio; //acumulando
sInicio = sInicio + sInc; //incrementando serie
}
cout << "La suma de los " << N << " primeros números pares es " << rSuma
<< endl;
//Suma de impares
sInicio = 1;
rSuma = 0;
for (int contador = 0; contador < M; contador++) //M números

{ rSuma = rSuma + sInicio; //acumulando
sInicio = sInicio + sInc; //incremento serie
}
cout << "La suma de los "<<N<<" primeros números impares es " << rSuma <<
endl;
}
void main()
{
int pN, pM;
cout << "Ingrese la cantidad de numeros pares a sumar: ";
cin >> pN;
cout << "Ingrese la cantidad de numeros impares a sumar: ";
cin >> pM;
anioAcademico(pN, pM);
system("pause");
}
Resultado
Ingrese la cantidad de numeros pares a sumar: 15
Ingrese la cantidad de numeros impares a sumar: 19
La suma de los 15 primeros n·meros pares es 240
La suma de los 15 primeros n·meros impares es 361
Resuelto 5. Suma los números múltiplos de 5 que se encuentran en el rango de

un número inferior y superior dado.
Por ejemplo si el número inferior ingresado es 12 y el número superior es 67, el

resultado sería: 15 - 20 - 25 - 30 - 35 - 40 - 45 - 50 - 55 - 60 - 65 -
Análisis
No sabemos la cantidad de números a sumar. Usamos la variable contador para

recorrer el rango. En cada iteración se selecciona contador siempre y cuando
cumpla la restricción de ser múltiplo de 5.
Programa
#include<iostream>
void sumaMultiplosDe5(int inferior, int superior)
{
int rSuma = 0;
for (int contador = inferior; contador <= superior; contador++) //N
números
{
if (contador % 5==0)
{
cout << contador<<" - ";
rSuma = rSuma + contador; //acumula
}
}
cout <<endl<< "La suma de los múltiplo de 5 es " << rSuma << endl;
}
void main()
{
int pInferior, pSuperior;
cout << "Ingrese el valor inferior del rango : ";
cin >> pInferior;

cout << "Ingrese el valor superior del rango : ";
cin >> pSuperior;
sumaMultiplosDe5(pInferior, pSuperior);
system("pause");
}
Resultado
Ingrese el valor inferior del rango : 10
Ingrese el valor superior del rango : 63
10 - 15 - 20 - 25 - 30 - 35 - 40 - 45 - 50 - 55 - 60 -
La suma de los múltiplo de 5 es 385
Resuelto 6. Hallar la suma de N términos de la sucesión:
189 194 199 204

,− + − +⋯
237 230 223 214
Análisis
Variables de repetición: i, N
Variables de las sucesión: rn=5, rd=-7, Nr, Dr, suma
Programa
#include<iostream>
void sumaFracciones(int N)
{
int rn = 5, rd = -7, Nr=189, Dr=237;
float suma = 0;
cout << "La suma de: ";
for (int i = 0; i < N; i ++)
{
suma = suma + (float)pow(-1, i)*Nr/Dr;
Nr = Nr + rn; Dr = Dr + rd;
cout << Nr << "/" << Dr << " ";
}
cout << " es " << suma << endl;
}
void main()
{
int C;
cout << "Ingrese la cantidad de términos : ";
cin >> C;
sumaFracciones(C);
system("pause");
}
Resultado
Ingrese la cantidad de términos: 8
La suma de: 194/230 199/223 204/216 209/209 214/202 219/195 224/188 229/181
es -0.225896

Resuelto 7. En la sucesión:
1 5 1 9
1, , , , , … .,
4 3 8 5
2𝑖 − 1
, 𝑠𝑖 𝑖 𝑒𝑠 𝑖𝑚𝑝𝑎𝑟
𝑖
𝐸𝑙 𝑡é𝑟𝑚𝑖𝑛𝑜 𝑔𝑒𝑛𝑒𝑟𝑎𝑙 𝑑𝑒 𝑙𝑎 𝑠𝑢𝑐𝑒𝑠𝑖ó𝑛 𝑒𝑠𝑡á 𝑑𝑒𝑡𝑒𝑟𝑚𝑖𝑛𝑎𝑑𝑜 𝑝𝑜𝑟
1 , 𝑠𝑖 𝑖 𝑒𝑠 𝑝𝑎𝑟
{ 2𝑖
Dónde: i es el i-ésimo término (i=1 para el primer término).
Se le solicita a usted elaborar un programa en C++ y en entorno consola que

halle la sumatoria de cierta cantidad de términos de la sucesión. La cantidad
de términos no debe ser menor de 10 ni mayor de 20.
Programa
#include<iostream>
double sumatorio(int *ct)
{
float *resultado = new float; *resultado = 0.0;
for (int i = 1; i <= *ct; i++)
{
if (i % 2==0) *resultado = *resultado + 1/(2.0*i);
else *resultado = *resultado + ((2.0*i-1)/i);
}
return *resultado;
}
void main() {
int *cantidad = new int; *cantidad = 0;
while (1) {
cout << "Cuantos términos? : "; cin >> *cantidad;
if (*cantidad >= 10 & *cantidad <= 20) break;
}
cout.precision(5);
cout << "\n------------------------------------------------" << endl;
cout << "La suma de los terminos es: " << sumatorio(cantidad) << endl;
}
Resultado
Cuantos tÚrminos? : 10
------------------------------------------------
La suma de los terminos es: 8.7835
Propuesto 1. Escribir un programa en C++ para sumar N términos de la

sucesion: 7/8, 12/10, 17/12, 22/14, ...

Propuesto 2. En la sucesión:
1 2 5 2 9
, , , , , … .,
1 6 9 12 25
2𝑖 − 1
, 𝑠𝑖 𝑖 𝑒𝑠 𝑖𝑚𝑝𝑎𝑟
𝑖2
𝐸𝑙 𝑡é𝑟𝑚𝑖𝑛𝑜 𝑔𝑒𝑛𝑒𝑟𝑎𝑙 𝑒𝑠𝑡á 𝑑𝑒𝑡𝑒𝑟𝑚𝑖𝑛𝑎𝑑𝑜 𝑝𝑜𝑟
2 , 𝑠𝑖 𝑖 𝑒𝑠 𝑝𝑎𝑟
{ 3𝑖

halle la sumatoria de n términos de la sucesión. La cantidad de términos no debe
ser menor de 10 ni mayor de 20.
Ejemplo:
Cuantos términos? : 8
------------------------------------------------
La suma de los términos:
1/1 2/6 5/9 2/12 9/25 2/18 13/49 2/24 17/81 2/30 21/121 2/36
Es: 3.381
No olvide que el programa deberá realizar todas las validaciones necesarias.
Propuesto 3. Si se tiene la siguiente serie:

𝐶 ∗ 𝑎 (𝐶 − 1) ∗ 𝑎 (𝐶 − 2) ∗ 𝑎 (𝐶 − 3) ∗ 𝑎
𝑆=− + − + −⋯
1! 2! 3! 4!
Se le solicita a usted un programa en C++ y en entorno consola que calcule el
valor de la serie, si se tiene como datos la cantidad de términos (C) y el valor de
a (a será un valor real entre 1 y 4). Recordar que C es un número entero positivo
entre 4 y 12.
Propuesto 4. Una máquina expendedora de helados está despacha un

tipo de helado. Si la compra es realizada por un niño el cobro es de 0.50
céntimos, ancianos pagan 0.60 y adultos 1.20. El sistema clasifica a los niños
si su edad es menor a 15 años, adultos si edad es mayor a 15 y menor a 60
años, ancianos cuando su edad es superior a 60. Hay un descuento de 10%
si la compra se realiza antes de las 9 horas y después de las 16 horas. El cobro
es automático, para el cual: el usuario indica su edad y hora de compra, la

máquina muestra el detalle de su compra. Una opción adicional puede
mostrar el resumen de todas las compras del día para ello el usuario pulsa la
tecla ‘S’ cuyo detalle corresponde a:
• Lo recaudado por niños, adultos y ancianos, además del total,

• La cantidad de niños, adultos y ancianos que compraron en la máquina;
• Cuál de los tres tipos de comprador obtuvo más compras.
Propuesto 5. Evalué las siguientes expresiones donde i y n son
proporcionadas por el usuario, proponga un menú para cada caso. Use
funciones así como las estructuras de control selectivas y repetitivas.
• ∑𝑛𝑖=1 √𝑥 3 − 3
2𝑖+1 −2𝑖
• ∑𝑛𝑖=1
𝑖+1
𝑖
• ∑𝑛𝑖=1(−1)𝑖+1
2𝑖
• ∏𝑛𝑖=1 𝑛(𝑛 + 1)
Propuesto 6. Implemente un programa que calcule las siguientes

integrales definidas, dado [a, b]. Use funciones así como las estructuras de
control selectivas y repetitivas.
𝑏 𝑥
• ∫𝑎 𝑑𝑥
𝑥 2 +𝑥+5
𝑏 𝑑𝑥
• ∫𝑎1+𝑥 2
𝑏
• ∫𝑎 𝑠𝑒𝑛(𝑥)𝑑𝑥
𝑏
• ∫𝑎 𝑠𝑒𝑛(𝑥)cos (𝑥)𝑑𝑥
6 INVESTIGACIÓN
Resuelva cada uno de los ejercicios propuestos, use la repetitiva for.
7 EVALUACIÓN

Capítulo 14:
repetitiva while y do-while
1 PROBLEMA
Escribir un programa en C++ que lea números enteros y que deje de leer cuando
se introduzca un cero. El programa debe mostrar por pantalla la cantidad de
números leídos, el mayor, el menor, la cantidad de números positivos, la
cantidad de números negativos y el promedio de los números ingresados.
Ejemplo:
Entrada Resultado
Ingrese un número: 5 ###RESUMEN DE DATOS###
Ingrese un número: -8 Números Leídos = 5
Ingrese un número: 7 Número Mayor = 7
Ingrese un número: 1 Número Menor = -8
Ingrese un número: 2 Números Positivos = 4
Ingrese un número: 0 Números Negativos = 1
Promedio = 1.40
programa.

Idetifica:

No sabemos la cantidad de números a leer. Pero si sabemos que la lectura de
números termina cuando ingresamos un cero (0). Se usa la variable cuenta para
obtener el cantidad de repeticiones del bloque, mayor para guardar el número
mayor.

procedimientos
Numero ¿? cuenta, mayor, menor,
cuentaPositivos, cuentaNegativos,
promedio

propuesto?
• ¿Cómo se define una estructura de control repetitiva while?
• ¿Cómo se define una estructura de control repetitiva do-while?
2 REPASO TEÓRICO
Las estructuras de control repetitivas while y do-while son parecidas.
2.2 Contenido
• Estructura de control repetitiva while
• Estructura de control repetitiva do-while
2.3 Estructura de control repetitiva while

Para entrar a un bucle while se valida la condición, si ésta es verdadera se
ejecuta las sentencias del buble y se incrementa el contador del bucle (si lo
tuviera) y regresamos a la condición del bucle.
2.3.1 While en diagrama de flujo

While en diagrama de flujo
Se entra al bloque mientras la

condición variable !=X sea cierta
2.3.2 While en diagrama N-S

While en Diagrama N-S
Se entra al bloque mientras la condición n !=0

sea cierta
2.3.3 While en pseudocódigo

La repetición termina cuando se escribe cero.
Definir n Como Entero
n=-1
Mientras n!=0 Hacer
Escribir "Dame el valor de n : "
Leer n
Fin Mientras
FinProceso
2.3.4 While en Código C++

La repetición termina cuando escribimos cero.
int numero=1;
while (numero!=0)
{
cout << "Ingrese un número : ";
cin >> numero;
}
2.4 Estructura de control repetitiva do-while

La estructura do-while es similar a la estructura while, con la diferencia que la
condición está al final. En un bucle while, la condición se evalúa en la entrada
y en el do-while a la salida. Esto hace que en un bucle do-while, el bloque de
instrucciones, siempre se ejecutará por lo menos una vez.

Hay por lo menos un extraño en la Nunca habrá un extraño en la
fiesta fiesta
do – while While
#include <iostream> #include <iostream>
using namespace std; using namespace std;
void main() void main()
{ {
int invitado = 0; int invitado = 0;
do while (invitado==1)
{ {
cout << “Que linda está la cout << “Que linda está la
fiesta”; fiesta”;
} while (invitado==1); }
system(“pause>NULL”); system(“pause>NULL”);
} }
Ejecutamos las instrucciones del bucle y Se evalúa la condición, si es verdad,

luego se evalúa la condición, si es ingresamos al bucle.
verdad, ingresamos por segunda vez al
bucle.
Matriz de variables

int numero Almacena el valor de un número entero
int cuenta Almacena la cantidad de números enteros
leídos
int mayor Almacena el mayor valor de todos los números
leídos
int menor Almacena el menor valor de todos los números
leídos
int cuentaPositivos Almacena la cantidad de números positivos
que se leyeron
int cuentaNegativos Almacena la cantidad de números negativos
que se leyeron
float rSuma Almacena la suma/cuenta de los números
leídos

numero leeEnteros() Cuenta, mayor, menor,
cuentaPositivos, cuentaNegativos,
rSuma
leeEnteros()
while (numero != 0)
{
}
…

Función principal Función programada

3.3 Diagrama N-S
Función principal Función programada
3.4 Pseudocodigo
SubProceso leeEnteros()
Definir contador Como Entero
Definir numero, mayor, menor Como Entero
Definir cuenta, cuentaPositivos, cuentaNegativos Como Entero
Definir rSuma Como Real
numero = 1
mayor=0
menor=99999
cuenta=0
cuentaPositivos=0
cuentaNegativos=0
rSuma = 0
Mientras numero <> 0 Hacer

Escribir "Ingrese un número : "
Leer numero
rSuma = rSuma + numero
Si mayor<=numero Entonces
mayor = numero
FinSi
Si menor>numero Y numero <> 0 Entonces
menor = numero
FinSi
Si numero>0 Entonces

cuentaPositivos=cuentaPositivos+1
FinSi
Si numero<0 Entonces
cuentaNegativos=cuentaNegativos+1
FinSi
cuenta=cuenta+1
Fin Mientras
Escribir "###RESUMEN DE DATOS###"
Escribir "Números Leídos = ",(cuenta-1)
Escribir "Número Mayor = ",mayor
Escribir "Número Menor = ",menor
Escribir "Números Positivos = ",cuentaPositivos
Escribir "Números Negativos = ",cuentaNegativos
Escribir "Promedio = ", rSuma/(cuenta-1)
FinSubProceso
Proceso principal
leeEnteros()
FinProceso
Resultado
Ingrese un número:
> 5
Ingrese un número:
> 8
Ingrese un número:
> -7
Ingrese un número:
> 62
Ingrese un número:
> 0
###RESUMEN DE DATOS###
Números Leídos = 4
Número Mayor = 62
Número Menor = -7
Números Positivos = 3
Números Negativos = 1
Promedio = 17
3.5 Código C++
#include<iostream>
void leeEnteros()
{
int numero = 1, mayor=0, menor=99999;
int cuenta=0, cuentaPositivos=0, cuentaNegativos=0;
float rSuma = 0;
while (numero!=0)
{
cin >> numero;
rSuma += numero;
if (mayor<=numero) mayor = numero;
if (menor>numero && numero !=0) menor = numero;
if (numero>0) cuentaPositivos++;
if (numero<0) cuentaNegativos++;
cuenta++;

}
cout << "\n###RESUMEN DE DATOS###" << endl;
cout << "Números Leídos = " << (cuenta-1) << endl;
cout << "Número Mayor = " << mayor << endl;
cout << "Número Menor = " << menor << endl;
cout << "Números Positivos = " << cuentaPositivos << endl;
cout << "Números Negativos = " << cuentaNegativos << endl;
cout.precision(2);
cout << "Promedio = " << rSuma/(cuenta-1) << endl;
}
void main()
{
leeEnteros();
}
Resultado
Ingrese un número: -8
###RESUMEN DE DATOS###
Números leídos = 5
Número mayor = 26
Número menor = -8
Números positivos = 4
Números negativos = 1
Promedio = 7.6
Resuelto 1. Suma N primeros números naturales múltiplos de un número dado
d. Ejemplo, sea el número dado d=10, N=5, entonces los números a sumar
son: 12, 15, 18, 21 y 24.
Programa
#include<iostream>
void sumaNumeros(int d, int N)
{
int rSuma=0;
while (d%3!=0)
{
d++;
}
int t = d; //primer término múltiplo de 3 porsterior a 10
for (int i = 0; i <N; i++)
{
rSuma = rSuma + d;
cout << d<<" ";

d += 3;
}
cout << "\nLa suma de términos es: "<< rSuma << endl;
}
void main()
{
int d = 7, N = 5;
sumaNumeros(d, N);
}
Resultado
Ingrese un número : 127

Cantidad de tÚrminos de la sucesión : 5
129 132 135 138 141
La suma de tÚrminos es: 675
Resuelto 2. Juego adivina

Escriba un programa en C++ que implemente el siguiente juego:
• El programa seleccionará un número aleatorio entre 0 y 100 y el jugador

debe acertarlo.
• En cada intento el jugador propondrá una respuesta y se le informará si
el número a acertar es menor o mayor que el propuesto por el jugador.
• EL juego termina en dos caso: Si el jugador gana (acierta el número) o si
el jugador pierde (que hayan sucedido un máximo de 12 intentos) en
cuyo caso se le mostrará al jugador la calificación obtenida según la
siguiente tabla:
Rango Mensaje
1-3 ¡Fue pura suerte!!
4-6 ¡Eres bueno!
7 No está mal
8 Se puede mejorar
Más de 8 Que mal estás!!!!
Ejemplo: En el caso de que el número generado sea 25
Intento 1 – Ingrese N: 50
El número es menor
El número es mayor
¡Fue pura suerte!!
Análisis
La restricción es: El juego termina siempre y cuando se haya adivinado el

número generado por la computadora o la cantidad de intentos sea 12. Esto
implica el uso de una estructura de control repetitiva que no sabemos cuantas
veces se va a repetir, y la más adecuada por el momento es while.

Programa
#include<iostream>
#include<ctime>
void jugar()
{
int intento = 0, numero;
bool salir = false;
srand(time(NULL));
int generado = rand() % 100;
cout << generado << endl;
while (intento<12 && salir==false)
{
cout << "Intento " << intento << " – Ingrese un número entre 0 y
100 : ";
cin >> numero;
if (numero==generado)
{
salir = true;
}
else if (generado>numero)
{
cout << "El número generado es mayor"<<endl;
}
else if (generado<numero)
{
cout << "El número genrado es menor"<<endl;
}
intento++;
}
if (intento<=3)
{
cout << "Fue pura suerte ! !" << endl;
}
else if (intento<=6)
{
cout << "Eres bueno !" << endl;
}
else if (intento <= 7)
{
cout << "No está mal" << endl;
}
else if (intento <= 8)
{
cout << "Se puede mejorar" << endl;
}
else
{
cout << "Que mal estas !!!!" << endl;
}
}
void main()
{
jugar();
system("pause");
}
Resuelto 3. Escriba un programa para simular el movimiento de una estrellita

en la consola, dicho movimiento debe ser controlado por el teclado. El área

de la consola será de 60 espacios de ancho y 30 de alto. La teclas a usar
son: W arriba, S abajo, A izquierda y D derecha.
Programa
#include <iostream>
#include <windows.h>
#include <conio.h>
void gotoXY(int &x, int &y) {
Console::SetCursorPosition(x, y);
}
void borraObjeto(int &x, int &y) {
gotoXY(x, y);
cout << " ";
}
void pintaObjeto(int &x, int &y) {
gotoXY(x, y);
cout << "*";
}
void mueveIzquierda(int &x, int &y) {

if (x < 1) x = 0;
else x--;
}
void mueveDerecha(int &x, int &y) {

if (x > 60) x = 60;
else x++;
}
void mueveArriba(int &x, int &y) {

if (y < 1) y = 0;
else y--;
}
void mueveAbajo(int &x, int &y) {

if (y > 30) y = 30;
else y++;
}
int main() {
int x = 10;
int y = 10;
pintaObjeto(x, y);
bool gameover = false;
while (!gameover) {
borraObjeto(x, y);
//mueve
if (_kbhit()) {
char tecla = getch();
if (toupper(tecla) == 'A') { mueveIzquierda(x, y); }

if (toupper(tecla) == 'D') { mueveDerecha(x, y); }
if (toupper(tecla) == 'W') { mueveArriba(x, y); }

if (toupper(tecla) == 'S') { mueveAbajo(x, y); }
}
pintaObjeto(x, y);
Sleep(100);
}
return 0;
}
Propuesto 1 Hallar la suma de los términos de la sucesión hasta que el
numerador y el denominador sean iguales:
179 184 189 194

− + ,− +⋯
251 244 237 230
Propuesto 2 Sumar de los N términos de la sucesión

7 9 11 13
−5, , − , , − , …
2 3 4 5
El término general está determinado por :
(−1)𝑖 (2𝑖 + 3)
𝑖

halle la suma de los términos de la sucesión hasta que la suma del numerador y
denominador sea 33.
Propuesto 3 Escriba un programa que permita mover en la consola un

cuadrado de 3 por 3 estrellitas en diferentes direcciones, el movimiento será
controlado con las teclas direccionales.
Propuesto 4 Escriba un programa que simule el movimiento autónomo de un

caracter en la consola. La estrellita debe moverse respetando el ancho de
la consola de 60 pixeles y 3 de alto.
6 INVESTIGACIÓN
de ellos que se resuelven usando estructuras repetitiva for se pueden programar
usando while o do-while.
7 EVALUACIÓN

Capítulo 15:
repetitiva while vs for
1 PROBLEMA
1.1 Enunciado
Escribir un programa en C++ en el que dado un numero natural N mayor a 5 y
menor a 20, calcule:
• Suma los N primeros números naturales

• Suma los N primeros números naturales pares
• Suma los N primeros números naturales impares
• Suma los N primeros números naturales múltiplos de 3
Importante: Debe validar los datos de entrada y demás para una correcta
ejecución del programa.

Idetifica:


Este tipo de problemas se resuelve cómodamente si se usa la estructura de
control repetitiva for, dado que sabemos de antemano cuántos números vamos
a sumar. Para la solución de cada caso se requieren N repeticiones con saltos
de 1.
Veamos un ejemplo: “sumar los C términos de la sucesión: 17, 21, 25, 29, …”.
r=4; S=17;
for(int i=0; i<C; i++)//variables de repeticion
{
S=S+r; //variables de la sucesión
}

Volviendo al problema: para el caso “suma los N primeros números naturales
impares”, con for tendríamos:
int S=1; r=2, d=1;

for(int i=0; i<N; i+=d)//variables de repetición
{
S=S+r; //variables de sucesión
}
Y con while:
int i=0, S=1; r=2, d=1;

While(i<N)//variable de la repetición
{
S=S+r; //variables de la sucesión
i+=d; //variable de la repetición
}
En ambos casos es importante separar las variables de repeticion (i,N,d) con

las variables de la sucesión (S, r), en algunos casos se pueden combinar.
Para la sucesión: 17, 21, 25, 29, … se requieren C=20 términos, se tiene.
FOR WHILE
int S=17; r=2; int i=0, S=17; r=2;
for(int i=0; i<C; i++) While(i<C)
{ {
S=S+r; S=S+r;
} i++;
}

procedimientos
N ¿? sumaEnteros
sumaPares
sumaImpares
sumaMultiplos3
propuesto?
• ¿Cómo se define una estructura de control repetitiva while?
• ¿Cómo se define una estructura de control repetitiva for?

2 REPASO TEÓRICO
Es importante saber que algunos programas se pueden escribir usando for o
while.
2.1 Contenido
• Estructura de control repetitiva while
• Estructura de control repetitiva for
2.2 Estructura de control repetitiva while

while (numero!=0)
{
cin >> numero;
}
2.3 Estructura de control repetitiva for
{
}
Matriz de variables

int N Almacena el valor de un número entero.
int sumaEnteros Almacena la suma de los N números enteros.
int sumaPares Almacena la suma de los N números pares.
int sumaImpares Almacena la suma de los N números enteros
impares
int sumaMultiplos3 Almacena la suma de los N números múltiplos de
3.

N sumaEnteros(int N) sumaEnteros
sumaPares(int N) sumaPares
sumaImpares(int N) sumaImpares
sumaMultiplos3(int N) sumaMultiplos3

3.3 Código
3.3.1 Usando for
#include<iostream>
int sumaEnteros(int n)
{
int suma = 0;
for (int numero = 1; numero <= n; numero++)
{
suma = suma + numero; //numero es el contador
}
return suma;
}
int sumaPares(int n)
{
int suma = 0;
int incremento = 2;
int numero = 0; // número de la serie
for (int i = 0; i < n; i++)
{
numero = numero + incremento; //numero incrementa su valor en 2
suma = suma + numero; //acumulamos valor de numero en suma
}
return suma;

}
int sumaImpares(int n)
{
int suma = 0;
int incremento = 2;
int numero = -1;
for (int i = 0; i < n; i++)
{
}
return suma;
}
int sumaMultiplosDeTres(int n)
{
int suma = 0;
int incremento = 3;
int numero = 0;
for (int i = 0; i < n; i++)
{
}
return suma;
}
void main()
{
int N;
cout << "Candidad de numeros a sumar : "; cin >> N;
cout << "La suma de los " <<N << " números es: " << sumaEnteros(N) <<
endl;
cout << "La suma de los " << N << " números pares es: " << sumaPares(N) <<
endl;
cout << "La suma de los " << N << " números impares es: " <<
sumaImpares(N) << endl;
cout << "La suma de los " << N << " números múltiplos de tres es: " <<
sumaMultiplosDeTres(N) << endl;
}
Resultado
Candidad de numeros a sumar : 20
La suma de los 20 n·meros es: 210
La suma de los 20 n·meros pares es: 420
La suma de los 20 n·meros impares es: 400
La suma de los 20 n·meros m·ltiplos de tres es: 630
3.3.2 Usando while
//Es importarte saber diferenciar entre el incremento de la serie y el incremento
del contador i
#include<iostream>
{
int suma = 0;
int numero = 1; //número de la serie
while (numero <= n)
{
suma = suma + numero;

numero++;//numero es el contador y a la vez es el número de la
serie
}
return suma;
}
{
int suma = 0;
int incremento = 2;
int numero = 0; // número tomará los valores de la serie
int i = 0; //contador
while (i<n)
{
numero = numero + incremento; //numero cambia de valor en cada
repetición
suma = suma + numero; //acumulamos el valor de numero en la
variable suma
i++; //contador
}
return suma;
}
{
int suma = 0;
int incremento = 2;
int numero = -1; // número tomará los valores de la serie
while (i<n)
{
repetición
variable suma
i++; //contador
}
return suma;
}
{
int suma = 0;
int incremento = 3;
while (i<n)
{
repetición
variable suma
i++; //contador
}
return suma;
}
void main()
{
int N;
cout << "Candidad de numeros a sumar : ";
cin >> cn;

cout << "La suma de los " << N << " números es: " << sumaEnteros(N) <<
endl;
cout << "La suma de los " << N << " números pares es: " << sumaPares(N) <<
endl;
cout << "La suma de los " << N << " números impares es: " <<
cout << "La suma de los " << N << " números múltiplos de tres es: " <<
sumaMultiplosDeTres(N) << endl;
system("pause");
}
Resultado
Candidad de numeros a sumar: 15

La suma de los 15 números es: 120
La suma de los 15 números pares es: 240
La suma de los 15 números impares es: 225
La suma de los 15 números mútiplos de tres es: 360
Resuelto 1. Escribir un programa en C++ en el que dado un número natural N,
calcule:
• Suma los números naturales menores a N

• Suma los números naturales pares menores a N
• Suma los números naturales impares menores a N
• Suma los números naturales múltiplos de 3 menores a N
Análisis
Este tipo de problemas se resuelve cómodamente si se usa la estructura de

control repetitiva while. La diferencia de este problema con el anterior es que
aquí, se pide la sumatoria de los términos anteriores o iguales a N. Si N=12 y se
pide sumar los números pares anteriores a N tenemos: 2, 4, 6, 8, 10 y 12. Si se pide
sumar los N=12 términos entonces tendríamos 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22 y
24.
Matriz de variables

int N Almacena el valor de un número entero.
int sumaEnteros Almacena la suma de los N números enteros.
int sumaPares Almacena la suma de los N números pares.
int sumaImpares Almacena la suma de los N números enteros
impares
int sumaMultiplos3 Almacena la suma de los N números múltiplos de
3.

N sumaEnteros(int N) sumaEnteros
sumaPares(int N) sumaPares

sumaImpares(int N) sumaImpares
sumaMultiplos3(int N) sumaMultiplos3
Diagrama de flujo
Código v1: Con while

//Es importarte saber diferenciar entre el incremento de la serie y el incremento
del contador
#include<iostream>
{
int suma = 0;
while (numero < n)
{
numero++;//numero incrementa su valor en 1 en cada repetición
}
return suma;
}
{
int suma = 0;

int incremento = 2;
while (numero < n)
{
variable suma
numero = numero + incremento; //numero incrementa su valor en 2 en
cada repetición
}
return suma;
}
{
int suma = 0;
int incremento = 2;
while (numero < n)
{
variable suma
cada repetición
}
return suma;
}
{
int suma = 0;
int incremento = 3;
while (numero < n)
{
variable suma
cada repetición
}
return suma;
}
void main()
{
int N;
cout << "Sumar numeros menores a : ";
cin >> N;
cout << "La suma de los números enteros menores a " << N << " es: " <<
sumaEnteros(N) << endl;
cout << "La suma de los números pares menores a " << N << " es: " <<
sumaPares(N) << endl;
cout << "La suma de los números impares menores a " << N << " es: " <<
cout << "La suma de los números múltiplos de 3 menores a " << N << " tres
es: " << sumaMultiplosDeTres(N) << endl;
system("pause");
}

Resultado
Sumar numeros menores a : 50
La suma de los n·meros enteros menores a 50 es: 1225
La suma de los n·meros pares menores a 50 es: 600
La suma de los n·meros impares menores a 50 es: 625
La suma de los n·meros m·ltiplos de 3 menores a 50 tres es: 408
Con for
//Es importarte saber diferenciar entre el r de la sucesión y el r del contador
#include<iostream>
{
int suma = 0;
for (int numero = 0; numero < n; numero++)
{
}
return suma;
}
{
int suma = 0;
int incremento = 2;
for (int numero = 0; numero < n; numero = numero +incremento)
{
variable suma
}
return suma;
}
{
int suma = 0;
int incremento = 2;
for (int numero = 1; numero < n; numero = numero + incremento)
{
variable suma
}
return suma;
}
{
int suma = 0;
int incremento = 3;
for (int numero = 0; numero < n; numero = numero + incremento)
{
variable suma
}
return suma;
}
void main()
{
int N;

cin >> N;
system("pause");
}
Resultado

La suma de los números enteros menores a 50 es: 1225
La suma de los números pares menores a 50 es: 600
La suma de los números impares menores a 50 es: 625
La suma de los números múltiplos de 3 menores a 50 tres es: 408
Código v2
Con while
//Es importarte saber diferenciar entre el r de la sucesión y el r del contador
#include<iostream>
{
int suma = 0;
while (numero<n)
{
numero++;//numero incrementa su valor en 1 en cada repetición
}
return suma;
}
{
int suma = 0;
while (numero<n)
{
{
variable suma
}
numero++; //numero incrementa su valor en 1 en cada repetición
}
return suma;
}
{
int suma = 0;
while (numero<n)

{
{
variable suma
}
}
return suma;
}
{
int suma = 0;
while (numero<n)
{
{
variable suma
}
}
return suma;
}
void main()
{
int N;
cin >> N;
system("pause");
}
Resultado

Con for
En la solución que proponemos a continuación si o si se generan N repeticiones.

#include<iostream>
{
int suma = 0;

{
}
return suma;
}
{
int suma = 0;
{
{
variable suma
}
}
return suma;
}
{
int suma = 0;
{
{
variable suma
}
}
return suma;
}
{
int suma = 0;
{
{
variable suma
}
}
return suma;
}
void main()
{
int N;
cin >> N;
system("pause");

}
Resultado
Propuesto 1. Resuelva el problema enunciado en este capítulo usando una
estructura repetitiva for modificando la variable N y los incrementos en el
propio contador.
Propuesto 2. Resuelva el problema enunciado en este capítulo usando una
estructura repetitiva while modificando la variable N y los incrementos en el
propio contador.
Propuesto 3. Una máquina expendedora de helados está ofertando helados.
Si la compra es realizada por un niño el cobro es de 0.60 céntimos, ancianos
pagan 0.80 y adultos 1.10. El sistema clasifica a los niños si su edad es menor
a 16 años, adultos si edad es mayor a 15 y menor a 65 años, ancianos cuando
su edad es superior a 65. El cobro es automático, para el cual: el usuario
indica su edad y la cantidad de helados a comprar, la máquina muestra el
detalle de su compra. Una opción adicional puede mostrar el resumen de
todas las compras del día para ello el usuario pulsa la tecla ‘S’ cuyo detalle
corresponde a:
• Lo recaudado por niños, adultos y ancianos, además del total,
• La cantidad de niños, adultos y ancianos que compraron en la máquina;
• Cuál de los tres tipos de comprador obtuvo más compras.
Ejemplo:
Pulse 'V' Ver reporte, 'C' Hacer compra: c
Edad: 63
Cantidad de chocolates: 10
Pague: 11
Pulse 'V' Ver reporte, 'C' Hacer compra: 64
Edad: Cantidad de chocolates: 4
Pague: 2.4
Pulse 'V' Ver reporte, 'C' Hacer compra: 61
Edad: Cantidad de chocolates: 10
Pague: 6
Edad: 10
Pague: 2.4
Edad: 13
Pague: 4.2
Pulse 'V' Ver reporte, 'C' Hacer compra: v
RECAUDACIÓN:
------------------------------

Niños: 15 Adultos: 11 Ancianos: 0
Cantidad de compradores:
Niños: 4 Adultos: 1 Ancianos: 0
Los que compraron más fueron los: Niños
6 INVESTIGACIÓN
Resuelva cada uno de los ejercicios propuestos, modifique las variables de la
estructura así como las variables de la sucesión usando repetitiva for, while y do-
while.
7 EVALUACIÓN

Capítulo 16:
Sentencias break, continue,
exit
1 PROBLEMA
La constante π (3.1416...) se puede aproximar por la siguiente sucesión de
términos:
2 4 4 6 6 8 8
4∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗…
3 3 5 5 7 7 9
Se le solicita a usted un programa en C++ y en entorno consola que calcule
el valor de π si se tiene como dato la cantidad de términos de la serie (n).
Recordar que n es un número entero positivo mayor que 1.
Ejemplo 1:
Ingrese el valor de N : -6
Ingrese el valor de N : 3
Resultado : 3.555556
programa.

Idetifica:

1.3 Análisis propuesta de solución
Realizar las validaciones necesarias nos permite implementar el programa opere
solamente para valores de n números mayores a 1, en caso de ingresar un valor
menor o igual a 1, el programa debe continuar pidiendo otro valor hasta que el
usuario ingrese un número válido, es decir mayor que 1. Cuando el usuario
ingresa un valor mayor a 1 un bucle se ejecuta para realizar la multiplicación de
los términos y se rompe al llegar al término n.

La serie se observa mejor así:
2 2 4 4 6 6 8 8
2 …
1 3 3 5 5 7 7 9
i 1 2 3 4 5 6 7 8 …
Se requiere n repeticiones, en cada repeticion evaluamos para i –ésima
repetición impar (i+1)/i, y para la i repetición par i/(i+1).

N ¿? Producto
propuesto?
• ¿Cómo se usa las sentencia break, continue y exit?
2 REPASO TEÓRICO
Es importante saber que algunos programas se pueden escribir usando for o
while y aveces se requieren saltar algunos pasos o salir del bucle.
2.1 Contenido
• Sentencia break
• Sentencia continue
• Sentencia exit
2.2 Sentencia break

Sintaxis
break;
La proposición "break" permite una salida forzada de las siguientes estructuras

de control:
• do…while
• while
•
for
•
switch
Es muy usada en cada una de las opciones de la estructura switch.
Ejemplo ilustrativo
Realizar una aplicación en C++ que imprima los 6 primeros número pares que
hay entre 1 y 40.
#include <iostream>
#include<conio.h>

void main()
{
int numero, contador;
contador = 0;
numero = 2;
while (numero <= 40)
{
{
contador = contador + 1;
cout << numero << " ";
}
if (contador == 6)
break;
numero = numero + 1;
}
_getch();
}
Resultado
2 4 6 8 10 12
2.3 Sentencia continue

Sintaxis:
continue;
La instrucción “continue" provoca un salto obligatorio a la siguiente iteración

dentro del ciclo de las siguientes ECR:
• do…while
• while
• for
La sentencia dentro de un bucle forzará al programa a finalizar la iteración

actual y a comenzar la evaluación de la siguiente.
Ejemplo ilustrativo
Realizar una aplicación en C++ que sume los números pares comprendidos
entre 1 y 10 inclusive.
#include <iostream>
#include<conio.h>
void main()
{
int i, suma;
suma = 0;
for (i = 1; i <= 10; i++)
{
if (i % 2 != 0) // salta los impares
{
continue;
}
cout << i << " ";

suma = suma + i; // aquí procesa los pares
}
cout << "La suma es : " << suma;
_getch();
}
Resultado
2 4 6 8 10 La suma es: 30
2.4 Sentencia exit

Sintaxis:
exit (código)
▪ Si el código es 0, entonces la aplicación terminará bajo la

denominación de “éxito”
▪ Si el código diferente a 0, entonces la aplicación terminará bajo la

denominación de “fallo”
La función exit se usa para finalizar un programa en C++, justo en el lugar

donde se le invoque.
Ejemplo ilustrativo
#include <iostream>
#include<conio.h>
void main()
{
char caracter;
while (1)
{
cout << "Pulse el caracter S para salir ";
cin >> caracter;
if (caracter == 'S' || caracter == 's')
exit(0);
}
}
Cuando se pulse 0, el programa finaliza.
Ejemplo ilustrativo
Realizar una aplicación en C++ que permita ingresar un conjunto de números

enteros y finalice cuando el usuario digite cero.
#include <iostream>
#include<conio.h>
void main()
{
int contador, numero;
contador = 0;
while (1)
{
cout << "Ingrese el numero 0 para salir ";

cin >> numero;
if (numero == 0)
exit(0);
contador = contador + 1;
}
cout <<"La cantidad de numeros ingresados es : " << contador<<endl;
_getch();
}
Resultado
Cuando se pulsa 0, el programa se finaliza sin imprimir el valor del contador
Matriz de variables

Int N Almacena el número de términos de la
serie
Matriz de entradas, procesos y salidas
Entradas Operaciones y procedimientos Salidas

N for (int i = 1; i <= N; i++) producto
{
if (i % 2 == 0)
producto = producto * (i) / (i + 1);
else
producto = producto * (i + 1) / (i);
}

3.2 Algoritmo
3.3 Código
#include <iostream>
#include<conio.h>
void main()
{
int n;
double N;
double producto = 2.0;
while (true)
{
cout << "Ingrese el valor de N (mayor a 0) : ";
cin >> N;
if (N<=1)
{

continue; // regresamos al while
}
else
{
for (int k = 1; k <= N; k++)
{
if (k % 2 == 0)
producto = producto * (k) / (k + 1);
else
producto = producto * (k + 1) / (k);
}
cout << "Resultado: " << producto << endl;
break; //para salirnos del while
}
}
system("pause");
}
3.4 Resultado
Ingrese el valor de N (mayor a 0) : 0
Resultado: 2.97215
Resuelto 1. Un número a genera una clave de firma digital en base a la
siguiente regla: a + a2 + a3 + a4 = 2mnp
̅̅̅̅̅̅62760, donde mnp
̅̅̅̅̅̅ es un número
natural. Hallar la clave de la firma digital mnp
̅̅̅̅̅̅.
Análsis
Dada la regla a + a2 + a3 + a4 = 2mnp

̅̅̅̅̅̅62760, siendo 𝑠𝑢𝑚𝑎 = a + a2 + a3 + a4 , debe
cumplirse que la suma%100000 == 62760, es decir que, la tarea del programa
es hallar el valor de a para que se cumpla esta igualdad, esto se logra con
repeticiones sucesivas. Finalmente, convertimos suma a cadena de texto y
extraemos la parte que corresponde a la clave
Programa
#include <stdio.h>
#include <iostream>
#include<string>
int main()
{
long long numero;
int a=10;
long long suma;
while (true)
{
suma = 0;
for (int i = 1; i <= 4; i++)
{
suma = suma + pow(a, i);
}

if (suma % 100000 == 62760) break;
a++;
}
cout << "Valor de a: "<<a<<endl;
cout << "Numero: " << suma<<endl;
//la clave
string cadena = to_string(suma);
cout <<"Clave: "<<cadena.substr(1,3)<<endl;
}
Resultado
Valor de a: 123
Numero: 230762760
Clave: 307
Propuesto 1. La exponencial de un número real a se puede aproximar con la
serie:
∞
𝑎
𝑎𝑘 𝑎2 𝑎3 𝑎4 𝑎𝑘
𝑒 =∑ = 1+𝑎 + + + +⋯+ +⋯
𝑘! 2 3! 4! 𝑘!
𝑘=0
Elabore un programa en C++ que permita hallar el valor de 𝑒 𝑎 si se tienen como

datos, n y a. No olvide verificar que k no debe ser mayor a 20, tampoco
negativo. En la solución, considere una estructura de repetición infinita y debe
parar cuando correponda con la instrucción break.
Recuerde que la aplicación deberá realizar todas las validaciones necesarias.
Ejemplo 1: Ejemplo 2:
Ingrese n: 71 Ingrese n: 10
Ingrese n: 15 Ingrese a: 2.1
Ingrese a: 1.2 El resultado de 𝑒 𝑎 será:
El resultado de 𝑒 𝑎 será: 8.1661
3.320117
Propuesto 2. La asociación de vinicultores piuranos han adquirido un puesto de ventas

en un mercado central, ellos tienen como política fijar un precio inicial al vino por
marca, A y B, y además los tienen clasificados como seco 1 y semiseco 2. Cuando
se realiza la venta de un producto, ésta es de una sola marca y clasificación, la
cantidad no debe ser ni menor a 12 ni mayor a 30 vinos. Se requiere determinar
cuánto de dinero se recaudó por las ventas al final del día. Sabiendo que, al
momento de la venta:
• Si el producto es de marca A, se le cargan 1.5 soles al precio inicial cuando es

de clase ; y 2.0 soles si es de clase 2.
• Si el producto es de marca B, se rebajan 1.2 soles cuando es de clase 1, y 0.5
soles cuando es de clase 2. Realice un algoritmo para determinar la ganancia
obtenida y represéntelo mediante diagrama de flujo, pseudocódigo y diagrama
N/S.

• Las ventas terminan cuando se ingresa la marca S, inmediatamente se imprime
un resumen de la cantidad de vinos que se vendió, monto final vendido y la
ganancias del día.
• El programa debe validar el ingreso del marca, clase y cantidad, y precio inicial
(mínimo 18 soles y máximo 25).
Propuesto 3. Los términos de la suceción son: 5000/17 4999/17 4991/23 4964/35
4900/53 4775/77, ... Encuentre el último término positivo, indique cuantos
térrminos tiene la sucesión, e imprima los terminos. Cada término tiene la
500−𝑖 3
forma:
17−6𝑖
6 INVESTIGACIÓN
7 EVALUACIÓN

Capítulo 17: Gráficos con
caracteres
Importante: Los ejercicios que se resuelven a continuación obran en la hoja de

ejercicios número 7, semestre 2019-2 UPC. En la solución de cada uno de ellos,
evitamos hacer uso de la instrucción: Console::SetCursorPosition
Ejercicio 1. Escriba un programa en C++ que permita ingresar un número entero

positivo (N), menor que 10, y luego imprima un cuadrado relleno de lado N.
Programa Resultado
#include<iostream> Lado del cuadrado
: 8
void main() ********

********
{ ********
int *N = new int; ********
********
int *i = new int; int *j = new int; ********
while (true) ********
********
{
cout << "Lado del cuadrado : ";cin >> *N;
if (*N > 0 && *N < 10) break;
for (*i = 1; *i <= *N; *i += 1)
for (*j = 1; *j <= *N; *j += 1)
cout << "*";
cout << endl;

positivo (N), menor que 10, y luego imprima un triángulo rectángulo relleno de N filas.
Programa Resultado
#include<iostream> Lado del
triángulo : 7
void main() *
**
{ ***
int *N = new int; ****
*****
int *i = new int; int *j = new int; ******
while (true) *******
cout << "Lado del triangulo : ";cin >> *N;
if (*N > 0 && *N < 10) break;
for (*i = 1; *i <= *N; *i += 1)
for (*j = 1; *j <= *i; *j += 1)
cout << "*";
cout << endl;

positivo (N), menor que 10, y luego nos permita imprimir un triángulo relleno de N
filas formado por un carácter que se ingrese como dato.
Forma1
Programa Resultado
#include <iostream>
void main()
{

int *N=new int; Ingrese un caracter: x
xxxxxxxx
int *i = new int; int *j = new int; xxxxxxx
xxxxxx
char caracter; xxxxx
xxxx
while (true) xxx
xx
{ x
cout << "Ingrese un número: ";
cin >> *N;
if (*N < 10 && *N>0) break;
cout << "Ingrese un caracter: ";
cin >> caracter;
for (*i = 1; *i <= *N; *i+=1)
for (*j = 1; *j <= *N + 1 - *i; *j+=1)
cout << caracter;
cout << endl;
Forma2
Programa Resultado
#include <iostream> Ingrese un n·mero: 8
Ingrese un caracter: k
using namespace std; kkkkkkkk
void main() kkkkkkk
kkkkkk
{ kkkkk
kkkk
int *N=new int; kkk
kk
int *i = new int; int *j = new int;
k
char caracter;
while (true)
cout << "Ingrese un número: ";

cin >> *N;
if (*N < 10 && *N>0) break;
cout << "Ingrese un caracter: ";
cin >> caracter;
for (*i = 1; *i <= *N; *i+=1)
for (*j = *N; *j >= *i; *j-=1)
cout << caracter;
cout << endl;
Ejercicio 4. Realice una aplicación en C++ que solicite el ingreso de un número entero,
positivo y menor a 10 (N) y muestre, al centro de la pantalla, un cuadrado de lado N.
Programa: primero el cuadrado
Para pensar en una solución sencilla hagamos el grafico en una matriz de N*N,
en este caso N vale 5.
i\j 1 2 3 4 5
1 * * * * * N=5
2 * *
3 * * i=1 i=5
4 * * j=1 j=5
5 * * * * *
#include <iostream>
void main()
{
int *N=new int;
char *caracter = new char;
while (true)
{
cout << "Ingrese un número: ";cin >> *N;
if (*N > 0 && *N < 10) break;
}
cout << "Ingrese un caracter: "; cin >> *caracter;

for (*i = 1; *i <= *N; *i+=1)
{
for (*j = 1; *j <= *N; *j+=1)
{
if (*i == 1 || *i == *N|| *j == 1 || *j == *N)
{
cout << *caracter;
}
else
{
cout << " ";
}
}
cout << endl;
}
}
Resultado
Ingrese un n·mero: 8
Ingrese un caracter: q
qqqqqqqq
q q
q q
q q
q q
q q
q q
qqqqqqqq
Programa: cuadrado centrado

#include <iostream>
void main()
{
int *N = new int;
int *x = new int; int *y = new int;
while (true)
{
cout << "Ingrese un número: ";cin >> *N;
if (*N > 0 && *N < 10) break;
}
cout << "Valor de x: "; cin >> *x;
cout << "Valor de y: "; cin >> *y;
//x espacios hacia abajo
for (*i = 1; *i < *x; *i+=1)
{
cout << endl;
}
for (*i = 1; *i <= *N; *i+=1)
{
//y espacios a la derecha
for (*j = 1; *j < *y; *j += 1)
{

cout << " ";
}
for (*j = 1; *j <= *N; *j+=1)
{
if (*i == 1 || *i == *N|| *j == 1 || *j == *N)
{
cout << *caracter;
}
else
{
cout << " ";
}
}
cout << endl;
}
}
Resultado
Valor de x: 5
Valor de y: 8
Ingrese un caracter: X
qqqqqqqq
q q
q q
q q
q q
q q
q q
qqqqqqqq
Ejercicio 5. Realice una aplicación en C++ que solicite el ingreso de un número

enteros, positivo y menor a 10 (N) y muestre, al centro de la pantalla, un cuadrado de
lado N y la diagonal principal de este.
Programa
Nos limitaremos hacer el grafico, centrarlo requiere usar el procedimiento

seguido en la solución del Ejercicio 3.
i\j 1 2 3 4 5 N=5 i j
1 * * * * * i=1 i=5 1 1
2 * * * j=1 j=5 2 2
3 * * * 3 3
4 * * * 4 4
5 * * * * * … …
i=j

#include <iostream>
void main()
{
int *N=new int;
while (true)
{
cout << "Ingrese un número: "; cin >> *N;
if (*N > 0 && *N < 10) break;
}
for (*i = 1; *i <= *N; *i+=1)
{
for (*j = 1; *j <= *N; *j+=1)
{
if (*i == 1 || *i ==*N || *j == 1 || *j == *N || *j == *i)
{
cout << "*";
}
else
{
cout << " ";
}
}
cout << endl;
}
}
Resultado
* * * * * * * *
* * *
* * *
* * *
* * *
* * *
* * *
* * * * * * * *
Ejercicio 6. Realice una aplicación en C++ que solicite el ingreso de dos números
enteros, positivos y menores a 10 (N) y muestre, al centro de la pantalla, la siguiente
figura.

Análisis
i\j 1 2 3 4 5 N=5 i j
1 * i=1 i=5 5 1
2 * * j=1 j=5 6 2
3 * * 7 3
4 * * 8 4
5 * * * * * 9 5
6 * *
7 * * Patrón i-j=4
8 * * Predicción i-j=n-1
9 *
Programa
#include <iostream>
void main()
{
int *N = new int;
int *x = new int; int *y = new int;
while (true)
{
cout << "Ingrese un número: "; cin >> *N;
if (*N > 0 && *N < 10) break;
}
cout << "Valor de x: "; cin >> *x;
cout << "Valor de y: "; cin >> *y;
//x espacios hacia abajo
for (*i = 1; *i < *x; *i += 1)
{
cout << endl;
}
for (*i = 1; *i <= 2**N-1; *i += 1)
{
//y espacios hacia la derecha
for (*j = 1; *j < *y; *j += 1)
{
cout << " ";
}
for (*j = 1; *j <= *N; *j += 1)
{
if ((*i == *N) || (*j == 1 && *i<*N) || (*j == *N && *i>*N)
|| (*i==*j) || (*i - *j == *N - 1))
{
cout << *caracter << " ";
}
else
{
cout << " ";
}
}

cout << endl;
}
}
Resultado
Ingrese un n·mero: 8
Valor de x: 3
Valor de y: 5
Ingrese un caracter: o
o
o o
o o
o o
o o
o o
o o
o o o o o o o o
o o
o o
o o
o o
o o
o o
o
Ejercicio 7. Realice una aplicación en C++ que solicite el ingreso de un número entero
positivo y menor a 10 (N) y muestre, de izquierda a derecha N triángulos rectángulos.
Análisis
Una matriz para N=3
i\j 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
1 * * *
2 * * * * * *
3 * * * * * *
4 * * * * * *
5 * * * * * * * * * * * * * * *

Expresiones lógicas para la condición
Verticales Horizontal inferior Diagonal
j= 1 8 15 i=5 j= 1 8 15 j%7=1
j%7==1 2 9 16 j%7=2
j%7=1 3 10 17 j%7=3
j%7=2 j%7=i
j%7=3
j%7=4
j%7=5
i= 5 && j%7>=1 && j%7<=5
Programa
#include <iostream>
void main()
{
int *c = new int;
while (true)
{
cout << "Cantidad de triangulos entre 1 y 7: "; cin >> *c;
if (*c > 0 && *c <=7) break;
}
for (*i = 1; *i <=5; *i += 1)
{
for (*j = 1; *j <= 5**c+(*c-1)*2; *j += 1)
{
if (*j%7==1 || *j%7==*i || (*i==5 && *j%7>=1 && *j % 7<=5))
//Verticales j%7==1, Diagonales *j%7==*i
{
cout <<"*";
}
else
{
cout << " ";
}
}
cout << endl;
}
}
Resultado
Cantidad de triángulos entre 1 y 7: 6
* * * * * *
** ** ** ** ** **
* * * * * * * * * * * *
* * * * * * * * * * * *
***** ***** ***** ***** ***** *****

Ejercicio 8. Realice una aplicación en C++ que solicite el ingreso de un número entero
positivo y menor a 10 (N) y muestre, de izquierda a derecha N cuadrados.
Análisis
Una matriz para N=3

i\j 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
1 * * * * * * * * * * * * * * *
2 * * * * * *
3 * * * * * *
4 * * * * * *
5 * * * * * * * * * * * * * * *
Expresiones lógicas para la condición

Verticales Horizontal superior Horizontal inferior
j= 1,8,15 i=1 i=5
j%7==1
j%7=1 j%7=1
j= 5,12,19 j%7=2 j%7=2
j%7=5 j%7=3 j%7=3
j%7=4 j%7=4
j%7=5 j%7=5
i= 1 && j%7>=1 && j%7<=5 i= 5 && j%7>=1 && j%7<=5

Programa
#include <iostream>
void main()
{
int *c = new int;
while (true)
{
cout << "Cantidad de triangulos entre 1 y 7: "; cin >> *c;
if (*c > 0 && *c <= 7) break;
}
for (*i = 1; *i <= 5; *i += 1)
{
for (*j = 1; *j <= 5 * *c + (*c - 1) * 2; *j += 1)
{
if (*j % 7 == 1 || *j % 7 == 5 || (*i == 1 && *j % 7 >= 1 &&
*j % 7 <= 5) || (*i == 5 && *j % 7 >= 1 && *j % 7 <= 5)) //Verticales j%7==1,
Diagonales *j%7==*i
{
cout << "*";
}
else
{
cout << " ";
}
}
cout << endl;
}
}

Resultado
Cantidad de cuadrados entre 1 y 7: 5
***** ***** ***** ***** *****
* * * * * * * * * *
* * * * * * * * * *
* * * * * * * * * *
***** ***** ***** ***** *****
positivo (N), menor que 10, y luego imprima un triángulo de N filas formado por
dígitos del 1 hasta N.
Programa Resultado
#include<iostream> Ingrese un número: 8
using namespace std; 1
void main() 12
{ 123
int *N = new int;
1234
while (true) 12345
{ 123456
cout << "Ingrese un número: "; 1234567
cin >> *N; 12345678
if (*N > 0 && *N < 10) break;
}
for (*i = 1; *i <= *N; *i += 1)
{
for (*j = 1; *j <= *i; *j += 1)
{
cout << *j;
}
cout << endl;
}
}
positivo (N), menor que 10, y luego nos permita imprimir un triángulo de N filas formado
por dígitos del 1 hasta N.
Ejemplo:
1 2 3 4 5 6 7 8 9
1 1
2 1 2 1
3 1 2 3 2 1
4 1 2 3 4 3 2 1
5 1 2 3 4 5 4 3 2 1

Análisis
• Hay N filas
• Por cada filas hay tres bucles: el primero para pintar blancos, el segundo
para pintar los números ascendentes y el tercero en donde los números
descienden
Programa Resultado
#include<iostream> Cantidad de filas
: 6
void main() 1
121
{ 12321
1234321
int *N = new int;
123454321
int *i = new int; int *j = new int; 12345654321
while (true)
cout << "Cantidad de filas : ";cin >> *N;
if (*N > 0 && *N < 10) break;
for (*i = 1; *i <= *N; *i += 1)
for (*j=1; *j<*N-*i+1; *j+=1)
cout << " ";
for (*j = 1; *j <= *i; *j += 1)
cout << *j;
for (*j = *j-2; *j >= 1; *j -= 1)
cout << *j;
cout << endl;

Ejercicio 11.Elabora un programa en C que solicite un número entero positivo menor a 11

y que luego nos imprima en la consola el rombo mostrado, tal como se aprecia en el
ejemplo adjunto.
Análisis
• Hay una figura superior de N filas y una figura inferior de

• Por cada filas hay tres bucles: el primero para pintar blancos, el segundo
para pintar los números ascendentes y el tercero en donde los números
descienden
Programa
#include<iostream>
void main()
{
int *N = new int;
while (true)
{
cout << "Cantidad de filas : ";cin >> *N;
if (*N > 0 && *N < 10) break;
}
//Parte de superior
for (*i = 1; *i <= *N; *i += 1)
{
for (*j=1; *j<=*N-*i; *j+=1)
{
cout << " ";
}
for (*j = 1; *j <= *i; *j += 1) //Numeros ascendente
{
cout << *j;
}
for (*j = *j-2; *j >= 1; *j -= 1)
{
cout << *j;
}
cout << endl;
}
//Parte inferior
for (*i = 1; *i <= *N-1; *i += 1)
{
for (*j = 1; *j <= *i; *j += 1)
{
cout << " ";
}
for (*j = 1; *j <= *N-*i; *j += 1) //Numeros ascendente
{
cout << *j;
}
for (*j = *j - 2; *j >= 1; *j -= 1)
{
cout << *j;
}
cout << endl;

}
}
Resultado
Cantidad de filas: 9
1
121
12321
1234321
123454321
12345654321
1234567654321
123456787654321
12345678987654321
123456787654321
1234567654321
12345654321
123454321
1234321
12321
121
1
Ejercicio 12. Elabora un programa en C que solicite un número entero positivo

menor a 11 y que luego nos imprima en la consola el rombo mostrado, tal como se aprecia
en el ejemplo adjunto.
Ejemplo:
Ingrese un número entre 1 y 5: 5
1
123
12345
1234567
123456789
1234567
12345
123
1
Análisis
- Hay dos triángulos de números

Programa
#include <iostream>
void main()
{
int *N = new int;
int *i = new int;
int *j = new int;
while (true)
{
cout << "Ingrese un número entre 1 y 5: "; cin >> *N;
if (*N > 0 && *N <= 5) break;
}
for (*i = 1; *i <= *N; *i+=1)

{ //blancos
for (*j = 1; *j <= *N - *i; *j+=1)
{
cout << " ";
}
//numeros
for (*j = 1; *j <= 2 * *i - 1; *j+=1)
{
cout << *j;
}
cout << endl;
}
//INFERIOR
for (*i = 1; *i <= *N; *i+=1)
{ //blancos
for (*j = 1; *j <= *i; *j+=1)
{
cout << " ";
}
//numeros
for (*j = 1; *j < 2 * (*N - *i); *j+=1)
{
cout << *j;
}
cout << endl;
}
}
Ejercicio 13. Elabore un programa en C que solicite un número entero en el rango

de 2 al 10 y que luego nos imprima en la consola la figura mostrada en el ejemplo adjunto.
Recuerde que el programa deberá realizar todas las validaciones necesarias.

Ejemplo:
Ingrese un número menor o igual a 5: 6

Ingrese un número menor o igual a 5: 5
5 5
54 45
543 345
5432 2345
543212345
5432 2345
543 345
54 45
5 5
Programa
#include <iostream>
void main()
{
int *N = new int;
int *i = new int;
int *j = new int;
int *k = new int;
while (1)
{
cout << "Ingrese un número menor o igual a 5: "; cin >> *N;
if (*N <= 5) break;
}
int tmp = *N; //usaremos la variable tmp en memoria estatica

//PARTE SUPERIOR
for (*i = 1; *i <= *N; *i+=1)
{ //numeros descendientes
for (*k = 1; *k <= *i; *k+=1)
{
cout << *N;
*N = *N - 1;
}
*N = tmp;
//blancos
for ( *j = 2 * *N - *i; *j > *i + 1; *j-=1)
{
cout << " ";
}
*N = tmp;
//numeros ascendientes
for (*k = *N - *i + 1; *k <= *N; *k+=1)
{
if (*k == 1)
continue; //EL la última fila se repite los unos, otra
forma puede escribir *N-1 filas y completar sólo la linea *N
cout << *k;
}
cout << endl; //Aquí termina la línea, se escribe los números línea
a línea
}
//PARTE INFERIOR

for (*i = 2; *i <= *N; *i += 1)
{ //números descendientes
*N = tmp;
for (*k = *N; *k >= *i; *k -= 1)
{
cout << *N;
*N = *N - 1;
}
*N = tmp;
//blancos
for (*j = 1; *j < 2 * *i - 2; *j += 1)
{
cout << " ";
}
*N = tmp;
//números ascendientes
for (*k = *i; *k <= *N; *k += 1)
{
cout << *k;
}
cout << endl;
}
}
Ejercicio 14. Realice una aplicación en C++ que solicite el ingreso de un número
entero, positivo y menor a 10 (N) y muestre, al centro de la pantalla, un cuadrado de lado
N.
Ejemplo:
Ingrese un n·mero menor o igual a 5: 20
Ingrese un n·mero menor o igual a 5: 5
123454321
2 2
3 3
4 4
5 5
6 6
7 7
6 6
5 5
123454321
Programa
#include <iostream>
void main()
{
int *N = new int;
int *i = new int;
int *j = new int;
int *k = new int;
while (1)
{
cout << "Ingrese un número menor o igual a 5: "; cin >> *N;
if (*N <= 5) break;
}

//primera fila
for (size_t j = 1; j < *N; j++)
{
cout << j;
}
for (size_t j = *N; j > 0; j--)
{
cout << j;
}
cout << endl;
//medio
int t = 2;
for (size_t i = 0; i < 2 * *N - 2; i++)
{
for (size_t j = 0; j < 2 * *N; j++)

{
if (j == 0 || j == 2 * *N - 2)
{
cout << t;
}
else cout << " ";
}
if (i < *N) t++;
else t--;
cout << endl;
}
//última fila
for (size_t j = 1; j < *N; j++)
{
cout << j;
}
for (size_t j = *N; j > 0; j--)
{
cout << j;
}
cout << endl;
}
Ejercicio 15. Elabora un programa en C++ que solicite un número entero positivo
menor a 10 y que luego nos imprima en la consola el rombo mostrado, tal como se aprecia
en el ejemplo adjunto.
Ejemplo:
Ingrese un n·mero entre 1 y 5: 20
Ingrese un n·mero entre 1 y 5: 5
A
ABC
ABCDE
ABCDEFG
ABCDEFGHI
ABCDEFG
ABCDE
ABC
A

Programa
#include <iostream>
void main()
{
int *N = new int;
int *i = new int;
int *j = new int;
while (true)
{
cout << "Ingrese un número entre 1 y 5: "; cin >> *N;
if (*N > 0 && *N <= 5) break;
}
for (*i = 1; *i <= *N; *i += 1)

{ //blancos
for (*j = 1; *j <= *N - *i; *j += 1)
{
cout << " ";
}
//numeros
for (*j = 1; *j <= 2 * *i - 1; *j += 1)
{
cout << char(*j+64);
}
cout << endl;
}
//INFERIOR
for (*i = 1; *i <= *N; *i += 1)
{ //blancos
for (*j = 1; *j <= *i; *j += 1)
{
cout << " ";
}
//numeros
for (*j = 1; *j < 2 * (*N - *i); *j += 1)
{
cout << char(*j+64);
}
cout << endl;
}
}
Ejercicio 16. Examen parcial – programación I – 20192

Pregunta 3

cantidad: 8
A
BAB
CBABC
DCBABCD
EDCBABCDE
FEDCBABCDEF
GFEDCBABCDEFG
HGFEDCBABCDEFGH
GFEDCBABCDEFG
FEDCBABCDEF
EDCBABCDE
DCBABCD
CBABC
BAB
A
#include <iostream>
#include <string>
int main()
{
int N;
cout << "cantidad : "; cin >> N;
for (int i = 1; i < 2 * N; i++)
{
int t = N;
for (int j = 1; j < 2 * N; j++)
{
if (i + j >= N + 1 && j - i <= N - 1 && i - j <= N - 1 && i +
j <= 3 * N - 1) cout << char(t + 64);
else cout << " ";
if (j < N) t--;
else t++;
}
cout << endl;
}
}
Ejercicio 17. Rombo de lado N

cantidad: 8
*
* *
* *
* *
* *
* *
* *
* *
* *
* *
* *
* *
* *
* *
*

#include <iostream>
#include <string>
int main()
{
int N;
cout << "cantidad : "; cin >> N;
for (int i = 1; i < 2 * N; i++)
{
for (int j = 1; j < 2 * N; j++)
{
if (i + j == N + 1 || j - i == N - 1 || i - j == N - 1 || i +
j == 3 * N - 1) cout << "*";
else cout << " ";
}
cout << endl;
}
}

Capítulo 18:
Punteros y parámetros de
funciones
1 PROBLEMA
Implementar una función en un programa que calcule el área y el perímetro
de una circunferencia, dado el radio. El programa realiza varios cálculos y
termina cuando el valor de radio ingresado es cero.
programa.

Idetifica:

Se requiere que la función que resuelve el problema regrese dos valores a la vez
a la función principal, eso sin punteros no es posible.

procedimientos
Radio ¿? área, perímetro
¿?
propuesto?
• ¿Cómo se escribe una función que regresa dos valores en C++?
• ¿Cómo soluciona el problema enunciado sin escribir una función?
2 REPASO TEÓRICO
Para guardar un dato en la memoria de la computadora, se usa un espacio de
memoria estática o dinámica, el espacio de memoria se asiga a una variable

que depende del tipo de dato que deseamos guardar, entre: enteros,
decimales, caracteres, cadenas, etc. El tipo define el tamaño en bytes del
espacio.
Todo espacio de memoria en la zona estática o dinámica tiene una dirección,
esta dirección se puede guardar en una variable especial que se llama puntero
o direccion.
Los punteros se usan para acceder a un espacio de memoria asignado a una

variable a través de la dirección de la variable. Sabiendo la dirección de ese
espacio se sabe el valor que allí se almacena.
Puntero en para manejar memoria estatica:
Para separar un espacio de memoria estática se usa una variable, si queremos

saber su dirección declaramos una variable de tipo puntero.
Dirección Variable
&precio Precio
0010BD48 120
int *ptr;
int precio;
ptr = &precio; //apuntamiento
ptr es una variable puntero declarada en la memoria estática cuyo valor es la

direccion de la variable precio.
*ptr guarda el valor de una variable a la que apunta ptr (en este caso,
*ptr==precio). La variable ptr guarda la dirección de la variable precio (en este
caso, ptr==&precio).
Dirección Variable
&*ptr *ptr
0110AB52 0010BD48
Puntero para manejar memoria dinámica:
Para separar un espacio en la memoria dinámica se usa el operador new. El

manejo de memoria estática con punteros es diferente que el manejo de
memoria dinámica.
Forma1 Forma2
int *precio; int * precio =new
precio =new int; int;
La memoria dinámica se manipula con punteros, sin embargo la memoria
estática se puede manipular con o sin punteros.

La dirección del espacio de memoria es precio y el valor es *precio. Con Int
*precio, se crea una variable puntero en la memoria estática y con new se
separa el espacio en la memoria dinámica.
2.1 Contenido
• Gestión de espacio en memoria estática

• Gestión de espacio en memoria dinámica
• Argumenos y parámetros de una función
2.2 Gestión de espacio en memoria estática
• Declaremos la variable Y en la memoria estática.
int Y;
• Declaremos la variable de tipo puntero ptrEntero en la memoria estática.
int * ptrEntero;
Donde:
Tipo Operador Variable puntero

de
indirección
int * ptrEntero
Importante: mientras que la variable Y almacenará cualquier valor de tipo

entero, la segunda ptrEntero almacenará la dirección del espacio de memoria
que se asignó a Y.
• Para apuntar a la variable Y con la variable de tipo puntero ptrEntero se

usa el operador de dirección &.
ptrEntero=&Y;
Luego:
Dirección del espacio de memoria de Valor del espacio de memoria de la

la variable Y a la cual apunta el variable Y a la cual apunta el puntero
puntero
ptrEntero *ptrEntero
• La dirección de la variable Y se imprime así:
cout<<&Y;
• Obtener un valor de la variable con el puntero: El valor de la variable y a

la que apunta el puntero se obtiene con el operador de indirección *, por
ejemplo:
int numero=*ptrEntero
Es decir, si Y=20, prtEntero=&Y, entonces *prtEntero es igual a 20.

• Direccion y valor de un espacio de memoria mediante puntero: Si se
declara una variable de tipo puntero: int *ptrEntero, el valor de la variable
(espacio de memoria) al cual apunta el puntero lo tiene *ptrEntero y la
direccion del espacio de memoria lo tiene ptrEntero.
• Modificar el valor de una variable N usando el puntero * ptrEntero:
después de apuntar a la variable N, cualquier valor que le asignemos a
*ptrEntero será asignado también a la variable N.
Es decir:
si *ptrEntero=50, entonces N=50.
si *ptrEntero=320, entonces N=320.
2.3 Gestión de espacio en memoria dinámica

La memoria dinámica siempre se gestiona con punteros. Las variables de tipo
puntero siempre se declaran en la memoria estática, y con el operador new
separamos el espacio correspondiente en la memoria dinámica.
• Declaramos una variable de tipo puntero (dirección) en la memoria estática.
int *numero;
• Separamos un espacio de memoria dinámica con el operador new.
numero=new int;
• También podemos separar un espacio en memoria dinámica y asignarlo al
puntero en una sola línea de código.
int *numero=new int;

2.4 Parámetros de una función
2.4.1 Definición de una función
tipo funcion(tipo variable1, tipo &variable2, tipo *variable3);
2.4.2 Implementación de una función

tipo funcion(tipo variable1, tipo &variable2, tipo *variable3){
…
return algo;
• El paso del parámetro variable1 de la función es por valor.

• El paso del parámetro &variable2 de la función es por dirección, se usa
cuando la variable proviene de un espacio en memoria estática.
• El paso del parámetro *variable3 de la función es por dirección, se usa
cuando la variable proviene de un espacio en memoria dinámica o estática.
2.4.3 Llamar a una función

void main(){
tipo tmp= función(arg1, arg2, arg3);
Los argumentos de la función son: arg1, arg2, arg3.

Matriz de variables

int radio Almacena el valor del radio
double area Almacena el valor del área del círculo
double perimetro Almacena el valor del perímetro de la
circunferencia

Radio areaYperimetro(int radio); area,
perimetro
areaYperimetro(int radio) area=3.1416*pow(radio, 2);
perimetro=2 * 3.1416*radio;
3.2 Con parámetros por valor
Declaramos las variables área y circunferencia como globales.
#include<iostream>
float area, circunferencia;
void areaYperimetro(int radio)
{
area = 3.1416*pow(radio, 2);
circunferencia = 2 * 3.1416*radio;
}
void main()
{
int radio;
while (true)
{
cout << endl<<"Radio de la circunferencia: ";
cin >> radio;
if (radio <= 0)
{
continue;
}
else
{
areaYperimetro(radio);
cout << "-------- RESULTADOS ----------" << endl;
cout << "Radio : " << radio << endl;

cout << "Area : " << area << endl;
cout << "Circunferencia : " << circunferencia << endl;
}
}
system("pause");
}
Resultado
Radio de la circunferencia: 15
-------- RESULTADOS ----------
Radio : 15
Area : 706.86
Circunferencia : 94.248
Radio de la circunferencia: -8
-------- RESULTADOS ----------
Radio : 40
Area : 5026.56
3.3 Con parámetros por referencia
Declaramos la variable radio, area, circunferencia en la función principal, luego
en la función areaYperimetro(r, &A, &C) para recibir el valor del radio, la
direccion de la variable area y la direccion de circunferencia.
#include<iostream>
void areaYperimetro(int r, float &A, float &C)
{
A = 3.1416*pow(r, 2);
C = 2 * 3.1416*r;
}
void main()
{
int radio;
float area, circunferencia;
while (true)
{
cout << endl << "Radio de la circunferencia: ";
cin >> radio;
if (radio <= 0)
{
continue;
}
else
{
areaYperimetro(radio, area, circunferencia);
}
}
system("pause");
}

Resultado
-------- RESULTADOS ----------
Radio: 20
Area: 1256.64
Circunferencia: 125.664
-------- RESULTADOS ----------
Radio: 35
Area: 3848.46
3.4 Con parametros de indirección: memoria estática

En la función principal, declaramos las variables locales radio, area y
circunferencia, además los punteros ptrArea, ptrCircunferencia.
#include<iostream>
void areaYperimetro(int r, float *A, float *C)
{
*A = 3.1416*pow(r, 2);
*C = 2 * 3.1416*r;
}
void main()
{
int radio;
float area, circunferencia, *ptrArea, *ptrCircunferencia;
ptrArea = &area;
ptrCircunferencia = &circunferencia;
while (true)
{
cin >> radio;
if (radio <= 0)
{
continue;
}
else
{
areaYperimetro(radio, ptrArea, ptrCircunferencia);
}
}
system("pause");
}

Resultado
-------- RESULTADOS ----------
Radio : 15
Area : 706.86
-------- RESULTADOS ----------
Radio : 50
Area : 7854
3.5 Parámetro de indirección: memoria dinámica

Los espacios de la memoria dinámica se manejan con punteros. En la función
principal, separamos los espacios y asignamos sus direcciones a los punteros
area y circunferencia, en la funcion areaYperimetro recibimos dichas
direcciones.
Programa
#include<iostream>
void areaYperimetro(int r, float *A, float *C)
{
*A = 3.1416*pow(r, 2);
*C = 2 * 3.1416*r;
}
void main()
{
int radio;
float *area = new float;
float *circunferencia=new float;
while (true)
{
cin >> radio;
if (radio <= 0)
{
continue;
}
else
{
areaYperimetro(radio, area, circunferencia);
cout << "Area : " << *area << endl;
cout << "Circunferencia : " << *circunferencia << endl;
}
}
system("pause");
}
Resultado

-------- RESULTADOS ----------
Radio: 16
Area: 804.25
-------- RESULTADOS ----------
Radio: 30
Area: 2827.44
Resuelto 1. Un número combinatorio proporciona el número de
combinaciones posibles de N elementos tomados en grupos de K elementos,
aquí no importa el orden en el que se forman los grupos. El número de
combinaciones se calcula con la siguiente fórmula:
𝑵!
𝒄𝒐𝒎𝒃𝒊𝒏𝒂𝒄𝒊𝒐𝒏𝒆𝒔(𝑵, 𝑲) =
𝑲! (𝑵 − 𝑲)!
Por ejemplo:
Si tenemos N=5 estudiantes y quisiéramos formar grupos de K=3 estudiantes,

entonces: Combinatorio = 5! / (3! * 2!) = 120 / (6 * 2) = 10
Escriba un programa que utilizando funciones calcule y muestre el valor del
número combinatorio, si se tienen como datos N y K.
Análisis
Un problema puede resolverse de diferente manera usando funciones. Una

funcion puede recibir valores o direcciones mediante parámetros: por valor, por
referencia por dirección & (las variables provienen de memoria estática), por
referencia por indirección * (las variables provienen de memoria dinámica o
estática),. Nuestra solución requiere una función que calcule el factorial de un
número.
Programa
Parámetros por referencia con indirección

#include<iostream>
int calculaFactorial(int *Num)
{
int factorial = 1;
for (int i = 1; i <= *Num; i++)

{
factorial = factorial * i;
}
*Num = 100; //modificando los valores de las variables N, K y temporal
return factorial;
}
void main()
{
int N, K, combinaciones;
int *ptrN, *ptrK;
ptrN = &N;
ptrK = &K;
while (true)
{
cout << "Valor de N: ";
cin >> N;
cout << "Valor de K: ";
cin >> K;
if (K>N)
{
continue;
}
else
{
int temporal = N - K;
int *ptrTemporal;
ptrTemporal = &temporal;
combinaciones = calculaFactorial(ptrN) /
(calculaFactorial(ptrK)*calculaFactorial(ptrTemporal));
cout << "El numero de combinaciones será : " <<
combinaciones<<endl;
cout << "\nLos nuevos valores de N, K y temporal" << endl;

cout << "Nuevo valor de N: " << N<<endl;
cout << "Nuevo valor de K: " << K << endl;
cout << "Nuevo valor de temporal: " << temporal << endl;
break;
}
}
system("pause");
}
Valor de N: 5
Valor de K: 9
Valor de N: 5
Valor de K: 3
El número de combinaciones será: 10
Los nuevos valores de N, K y temporal

Nuevo valor de N: 100
Nuevo valor de K: 100
Nuevo valor de temporal: 100

Propuesto 1. Una fabricante de juguetes produce artículos con claves (1, 2, 3, 4, 5
y 6). Se requiere un algoritmo para calcular los precios de venta, para esto hay que
considerar lo siguiente:
• Costo de producción = materia prima + mano de obra + gastos de fabricación.
• Precio de venta = costo de producción + 45 % de costo de producción.
• El costo de la mano de obra se obtiene de la siguiente forma: para los productos
con clave 3 o 4 se carga 75 % del costo de la materia prima; para los que tienen
clave 1 y 5 se carga 80 %, y para los que tienen clave 2 o 6, 85 %.
• Para calcular el gasto de fabricación se considera que si el artículo que se va a
producir tiene claves 2 o 5, este gasto representa 30 % sobre el costo de la
materia prima; si las claves son 3 o 6, representa 35 %; si las claves son 1 o 4,
representa 28 %.
• La materia prima tiene el mismo costo para cualquier clave.
Propuesto 2. Realice un algoritmo que determine el sueldo semanal que hay que
pagar a N trabajadores considerando que se les descuenta 5% de su sueldo si ganan
entre 0 y 200 soles. Se les descuenta 7% si ganan más de 200 pero menos de 300, y
9% si ganan más de 300 pero menos de 450. Los datos son horas trabajadas, sueldo
por hora y nombre de cada trabajador. Los descuentos se van a un fondo de apoyo,
que se devolverá al finalizar el mes. Para cada empleado, se imprime su sueldo y su
desuento. Al final, se imprime el reporte de todo lo pagado por la empresa y
ahorrado en el fin de semana.
6 INVESTIGACIÓN
7 EVALUACIÓN

Capítulo 19:
Memoria dinámica
PROBLEMA
Una ecuación cuadrática es una ecuación de la forma a𝑥 2 + bx + c = 0,
donde a, b, y c son números reales.
Ejemplo
9𝑥 2 + 6x + 10 = 0 a = 9, b = 6, c = 10
3𝑥 2 − 9x = 0 a = 3, b = -9, c = 0
−6𝑥 2 + 10 = 0 a = -6, b = 0, c = 10
Un método para hallar los valores de x (son dos valores), en este tipo de
ecuación es usando la fórmula cuadrática:
−𝑏 ± √𝑏 2 − 4𝑎𝑐
𝑥=
2𝑎
Desarrollar un programa para solucionar este tipo de ecuaciones. Crear una
función para hallar los dos valores de x y y retornarlos al programa principal.

• ¿Cuál crees qué es el problema principal aquí?
• ¿Cuál es su análisis del problema?
Idetifique:
Análisis y propuesta de solución

El problema puede ser resuelto usando dos funciones, una que regrese el primer
valor X1 y otra que regrese X2. Dada que la solución tiene dos valores {X1, X2},
se requiere de una función que regrese dos valores a la vez. Sin embargo, toda
función regresa un solo valor, en este caso debemos desarrollar un programa
que utilice dos punteros para apuntar a dos espacios de memoria dinámica en
los que se almacenen estos valores.

procedimientos
A, B, C ¿? X1, X2
¿?
• ¿Cómo implementar una función que regrese dos valores a la vez?
• ¿Cómo separar espacios de memoria dinámica?
• ¿Cómo liberar los espacios de memoria que ya no se usen?
REPASO TEÓRICO
2.1 Contenido
• Tipos de memoria en la computadora
• Las zonas de una memoria física
• Asignación de la dirección de memoria estática a un puntero
• Asignación de la dirección de memoria dinámica a un puntero
• Liberación de memoria dinámica
• NULL
2.2 Tipos de memoria

Existen 3 tipos de memoria:
Memoria estática: Los objetos son creados al comenzar el programa y

destruidos sólo al finalizar. Mantienen la misma localización en memoria
durante todo el transcurso del programa. (Ej. Variables globales)
Memoria automática: Los objetos son creados al entrar en el bloque en que

están declarados, y se destruyen al salir del bloque. Se trata de un proceso
dinámico pero manejado de modo automático por el compilador. (Ej.
Funciones)
Memoria dinámica: En este caso tanto la creación como destrucción de los
objetos está en manos del programador. El medio para manejar este tipo de
memoria que otorga el sistema operativo, es el puntero.
2.3 Las zonas en una memoria física

Cuando el sistema operativo carga un programa para ejecutarlo y lo
convierte en proceso, le asigna cuatro espacios lógicos en memoria principal:
zona estática (texto, datos), zona dinámica (o heap) y la zona que corresponde
a la pila.
Esta zona dinámica es la que va a contener los datos dinámicos, la cual,

a su vez, en cada instante de la ejecución tendrá partes asignadas a los mismos
y partes libres que fragmentarán esta zona, siendo posible que se agote si no se
liberan las partes utilizadas.

La pila también varía su tamaño dinámicamente, pero la gestiona el
sistema operativo, no el programador.
Texto del Programa

Zona Estática
Datos Estáticos
Límite de la Zona
Estática
Zona dinámica
(Heap)
Límite de la
Pila
Pila
Puntero de la
Pila (Stack
pointer)
Figura 1. Zonas de la memoria física (adaptado del curso de Programación I, UPC 2018-II)
2.4 Asignación de la dirección de memoria estática a un

puntero
El puntero prtA guarda la dirección del espacio de memoria o variable A.
int A;
int * ptrA;
ptrA = &A
2.5 Asignación de la dirección de memoria dinámica a

un puntero
Un puntero es una variable que guarda la direccion de una variable o un
espacio de memoria estática o dinámica.
Formas Separar Liberar

Forma 1 New Delete
Forma 2 Malloc Free
El puntero nombrePuntero guarda la dirección de un espacio de memoria

dinámica separado con el operador new.

New: permite reservar memoria dinámicamente y asignar su dirección a una
variable de tipo puntero.
Sintaxis
TipoDato *nombrePuntero; //zona estática
nombrePuntero = new TipoDato; //zona dinámica
Manera 1 Manera 2
int *variableA; int *variableA = new int;
variableA = new int;
Ejemplo ilustrativo 1: Asignarle la dirección de un espacio de memoria dinámica

a un puntero, luego en ese espacio asignarle 40 e imprimirlo por pantalla.
#include<iostream>
#include<conio.h>
void main()
{
int *A;
A = new int; //reservando espacio
*A = 40; //asignando un valor al espacio reservado
cout << "Dirección del dato: " << A << endl;
cout << "Valor del dato : " << *A << endl;
getch();
}
Dirección del dato: 0010BD48
Valor del dato : 40
2.6 Liberación de memoria dinámica

Delete: permite liberar la memoria reservada con new. Siempre que exista un
new debe existir un delete correspondiente. Una vez liberada la memoria ya no
se podrá acceder a ella por lo que es necesario que se libere en caso que ya
no se necesite.
Sintaxis Ejemplo
delete nombrePuntero; delete variableA;
Ejemplo ilustrativo 2: Asignarle la dirección de un espacio memoria dinámica de

tipo int a un puntero, luego en ese espacio asignarle 40 e imprimirlo por pantalla,
luego borrar el espacio asignado y volver a imprimir la dirección y su valor.
#include<iostream>
#include<conio.h>
void main()
{
int *A;
A = new int;
*A = 40;

delete A;
getch();
}
Dirección del dato: 014B8B60
Valor del dato: 40
Dirección del dato: 014B8B60
Valor del dato: -572662307
2.7 NULL
NULL es una constante que se aplica, especialmente, a los punteros para indicar
que estos no apuntan a ningún lugar.
Sintaxis Manera 1 Manera 2
TipoDato *nombrePuntero; int *pA; int *pA = NULL;
nombrePuntero = NULL; pA = NULL;
No olvide de asignar un espacio de memoria (new o malloc) al puntero antes
de utilizarlo.
Ejemplo ilustrativo 3: Estudiar el código, ¿hay errores?

#include<iostream>
#include<conio.h>
void main()
{
int *A;
A = NULL; //puntero no apunta a ningun lugar ó no tiene espacio reservado
*A = 40;
getch();
}
Dirección del dato: 056712B8
Valor del dato : 40
Ejemplo ilustrativo 4: Estudiar el código, ¿hay errores?

#include<iostream>
#include<conio.h>
void main()
{
int *A;
A = NULL; //puntero no apunta a ningun lugar ó no tiene espacio reservado
*A = 40;
getch();
}

Error en *A = 40;
2.8 La importancia de Null al momento de declarar

Cuando declaramos variables, es recomendable inicializarlas para eliminar
posibles errores. Por ejemplo, cuando declaramos int A; es posible que el valor
de A sea 256 o cualquier otro número, no necesariamente comienza con un
valor de 0. Para evitar estos errores por lo general después de declarada la
variable la inicializamos con un valor, ejemplo A = 10.
Situación similar se da con los punteros. Al declarar int *pA; el valor de pA puede
ser cualquier cosa, inclusive puede ser una dirección de memoria que no nos
corresponde, por lo que, si intentamos acceder a dicha memoria obtendremos
un error. Es por esta razón que es importante inicializar el valor del puntero y
colocamos inmediatamente el valor que nos otorga New o Malloc que puede
ser una dirección de memoria o NULL.
Con new Con malloc

pA = new int; pA = (int*) malloc(sizeof(int));
Ejemplo ilustrativo 5: Apuntando a NULL y separando espacio en memoria

dinámica con malloc
#include<iostream>
#include<conio.h>
void main()
{
int *A;
A = NULL; //Similar a cuando una variable se inicia en 0
//A = new int; //reservando espacio
A = (int*)malloc(sizeof(int)); //reservando espacio y tomando la dirección
*A = 40;
*A = 80;
cout << "Dirección del dato: " << *A << endl;
getch();
}
Dirección del dato: 00411E90

Valor del dato : 40
Dirección del dato: 00411E90
Dirección del dato: 80
Ejemplo ilustrativo 6: Apuntando a NULL y separando espacio en memoria

dinámica con new
#include<iostream>
#include<conio.h>
void main()
{

int *A;
A = NULL; //Similar a cuando una variable se inicia en 0
//A = (int*)malloc(sizeof(int)); //reservando espacio
*A = 40;
*A = 80;
cout << "Dirección del dato: " << *A << endl;
getch();
}
Dirección del dato: 00A87BD8

Valor del dato : 40
Dirección del dato: 00A87BD8
Ejemplo ilustrativo 7: apuntando a otro espacio sin liberar es espacio de

memoria dinámica utlizada.
#include<iostream>
#include<conio.h>
void main()
{
int *A;
*A = 40;
cout << "\nApuntando a otra dirección sin liberar la memoria" << endl;
*A = 80;
cout << "Nueva dirección del dato: " << A << endl;
cout << "Nuevo valor del dato :: " << *A << endl;
getch();
}
Dirección del dato: 008944F0

Valor del dato : 40
Apuntando a otra dirección sin liberar la memoria

Nueva dirección del dato: 008944C0
Nuevo valor del dato : 80
Ejemplo ilustrativo 8: apuntando a otro espacio después de liberar es espacio

de memoria dinámica utilizada.
#include<iostream>
#include<conio.h>
void main()
{
int *A;

*A = 40;
delete A;
A = NULL;
cout << "\nApuntando a otra dirección después de liberar la memoria" <<
endl;
*A = 80;
cout << "Nuevo valor del dato : " << *A << endl;
getch();
}
Dirección del dato: 00FD8AA0

Valor del dato : 40
Apuntando a otra dirección despuÚs de liberar la memoria

Nueva dirección del dato: 00FD8770
Nuevo valor del dato : 80
2.9 La importancia de NULL al utilizar delete
• Cuando el puntero ya no sea usado durante la ejecución del programa,
liberábamos la memoria utilizando del comando delete. El problema
surge que ahora la variable puntero ya no apunta al espacio de memoria
y tampoco existe memoria reservada para esta variable.
• Sin embargo la variable puntero aún contiene la dirección de memoria

previamente asignada por lo que si alguien realiza la siguiente operación:
if (puntero != NULL)
printf(“puntero tiene datos”);
• Se imprimirá que aún tiene datos para dicha variable cuando esto ya no
es cierto.
• Es por esta razón que es recomendable colocar NULL al puntero después

de un delete o free.
Ejemplo ilustrativo 9: Despues de eliminar el espacio con delete, aparentemente

el puntero sigue apuntando al mismo espacio de la memoria dinámica, lo cual
no es cierto. De ahí que en la salida del programa se puede observar el valor de
la dirección es la misma pero el valor es otro.
#include<iostream>
#include<conio.h>
void main()
{
int *A;

*A = 40;
delete A;
cout << "\nInformacion después de liberar la memoria" << endl;
cout << "Nuevo valor del dato : " << *A << endl;
getch();
}
Dirección del dato: 05A659F8

Valor del dato : 40
Informacion despuÚs de liberar la memoria

Nueva dirección del dato: 05A659F8
Nuevo valor del dato : -572662307
Ejemplo ilustrativo 10: Después de liberar el espacio, al puntero le asignamos

NULL. De ahí que en la salida del programa, la dirección es NULL = 00000000.
#include<iostream>
#include<conio.h>
void main()
{
int *A;
*A = 40;
delete A;
A = NULL;
cout << "\nInformacion después de liberar la memoria" << endl;
//cout << "Nuevo valor del dato : " << *A << endl;
getch();
}

Valor del dato : 40
Informacion después de liberar la memoria

Nueva dirección del dato: 00000000
SOLUCIÓN DEL PROBLEMA

Matriz de variables

int A, B, C Almacena el valor del coeficiente A, B y C
respectivamente
double X1 Almacena el valor de la primera raíz
double X2 Almacena el valor de la segunda raíz

A, B, C hallaRaiz(A, B, C, X1, X2); X1, X2
hallaRaiz(int a, int b, int c,
double *x1, double *x2)
3.2 Código
#include<iostream>
#include<conio.h>
void hallaRaiz(int a, int b, int c, double *x1, double *x2)
{
//Asignamos los resultados a cada uno de los punteros
double discriminante = pow(b, 2) - 4 * a*c;
if (discriminante>0)
{
*x1 = (-b - sqrt(discriminante)) / (2 * a);
*x2 = (-b + sqrt(discriminante)) / (2 * a);
}
}
void main()
{
int A, B, C;
double *X1 = new double; //reservando espacio
double *X2 = new double; //reservando espacio
//Leyendo datos
cout << "Coeficiente A: ";
cin >> A;
cout << "Coeficiente B: ";
cin >> B;
cout << "Coeficiente C: ";
cin >> C;
//Enviamos las variables A, B, C y los punteros X1 y X2

hallaRaiz(A, B, C, X1, X2);
cout << "Primera raíz : " << *X1 << endl;
cout << "Primera raíz : " << *X2 << endl;
//liberando la memoria dinámica
delete X1;
delete X2;
getch();
}
3.3 Resultados
Coeficiente A: 3
Coeficiente B: 2
Coeficiente C: -8
Primera raíz : -2
Primera raíz : 1.33333

EJERCICIOS RESUELTOS
Propuesto 1. Dada la ecuación cúbica de la forma x3+ax2+bx+c=0, sus tres
raíces reales mediante el metodo de Cardano se calculan de la siguiente
manera :
Se halla:
𝑎2 −3𝑏 2𝑎3 −3𝑎𝑏+27𝑐 𝑅
𝑄= ,𝑅= , 𝜃 = 𝑎𝑟𝑐𝑐𝑜𝑠 ( )
9 54 √𝑄3
• Si R2<Q3, entonces la ecuación tiene tres raíces reales:

𝜃 𝑎
𝑥1 = −2√𝑄𝑐𝑜𝑠 ( ) −
3 3
𝜃 + 2𝜋 𝑎
𝑥2 = −2√𝑄𝑐𝑜𝑠 ( )−
3 3
𝜃 − 2𝜋 𝑎
𝑥3 = −2√𝑄𝑐𝑜𝑠 ( )−
3 3
• En caso contrario, R2≥Q3 la ecuación tiene una raíz real y dos complejas:
Escribir un programa que calcule las raíces de la ecuación, en el caso que éstas
sean reales.
Análisis
Primero que todo hay que verificar que la ecuación tenga raíces reales para lo
cual hallamos el valro de R y Q. Luego, hallamos el ángulo 𝜃.
Código
#include<iostream>
void lecturaDatos(float *a, float *b, float *c)

{
cout << "Valor de a: "; cin >> *a;
cout << "Valor de b: "; cin >> *b;
cout << "Valor de c: "; cin >> *c;
}
void hallaQRT(float *a, float *b, float *c, float *Q, float *R, float *T) {
*Q = (pow(*a, 2) - 3 * *b)/9.0;
*R = (2 * pow(*a, 3) - 3 * *a**b + 27 * *c) / 54.0;
*T = acos(*R / pow(*Q, 1 / 3.0));
}
void main()
{
float *a = new float;
float *b = new float;
float *c = new float;
float *Q = new float;
float *R = new float;
float *T = new float;
float *x1 = new float;

cout << "Raices de la ecuacion de la forma x3+ax2+bx+c=0" << endl;
cout << "----------------------------------------------------" << endl;
lecturaDatos(a,b,c);
hallaQRT(a,b,c, Q, R,T);
if (pow(*R, 2) < pow(*Q, 3)) {
*x1 = -2 * sqrt(*Q)*cos(*T / 3) - *a / 3.0;
*x2 = -2 * sqrt(*Q)*cos((*T+2*3.1416)/ 3.0) - *a / 3.0;
*x3 = -2 * sqrt(*Q)*cos((*T - 2 * 3.1416) / 3.0) - *a / 3.0;
}
else
{
cout << "La ecuación tiene una raíz real y dos complejas " << endl;
}
cout << "RAICES : " << endl;
cout << "x1 = " << *x1 << endl;
cout << "x2 = " << *x2 << endl;
cout << "x3 = " << *x3 << endl;
}
Resultado
Raíces de la ecuación de la forma: x3+ax2+bx+c=0

----------------------------------------------------
Valor de a: -2
Valor de b: -8
Valor de c: 0
RAICES:
x1 = -1.68956
x2 = 4.11843
x3 = -0.428852
EJERCICIOS PROPUESTOS
Propuesto 1. Dada la ecuación cúbica de la forma x3+ax2+bx+c=0, sus tres
raíces se calculan mediante el Método de Cardano, de la siguiente manera:
Se halla:
𝑎2 −3𝑏 2𝑎3 −3𝑎𝑏+27𝑐 𝑅
𝑄= ,𝑅= , 𝜃 = 𝑎𝑟𝑐𝑐𝑜𝑠 ( )
9 54 √𝑄3
• Si R2<Q3, entonces la ecuación tiene tres raíces reales:

𝜃 𝑎
𝑥1 = −2√𝑄𝑐𝑜𝑠 ( ) −
3 3
𝜃 + 2𝜋 𝑎
𝑥2 = −2√𝑄𝑐𝑜𝑠 ( )−
3 3
𝜃 − 2𝜋 𝑎
𝑥3 = −2√𝑄𝑐𝑜𝑠 ( )−
3 3
• En caso contrario, R2≥Q3 tenemos una raíz real y dos complejas:

Se halla:
𝑄
1 ,𝐴 ≠ 0
𝐴
𝐴 = −𝑠𝑔𝑛(𝑅) [|𝑅 | + √𝑅 2 − 𝑄 3 ] , 𝐵 = {
3
0, 𝐴 = 0
Entonces la raíz real y las dos complejas conjugadas son:
𝑎
𝑥1 = (𝐴 + 𝐵) −
3
1 𝑎 √3
𝑥2 = − (𝐴 + 𝐵) − + 𝑖 (𝐴 − 𝐵)
2 3 2
1 𝑎 √3
𝑥3 = − (𝐴 + 𝐵) − − 𝑖 (𝐴 − 𝐵)
2 3 2
Escribir un programa que calcule las raíces de la ecuación.
INVESTIGACIÓN
Resuelva cada uno de los ejercicios propuestos y elabore un mapa conceptual
de los aspectos más importantes del uso de la memoria dinámica.
EVALUACIÓN

Capítulo 20:
Arreglo unidimensional
Vector, arreglo, formación a un lugar de almacenamiento continuo es correcto.
Pudiendo ser unidimensonal (recta), bidimensional (plano), tridimensional
(cubo), etc. Implementar este tipo de estructuras nos permite manipular los datos
con facilidad.
1 PROBLEMA PROPUESTO
Se desea registrar el peso de varios estudiantes del primer grado de un colegio
para el control de su dieta alimenticia, para lo cual se desea calcular el:
• Promedio de peso
• Moda el peso
• El mayor peso
• El menor peso
• Desviación estándar DE
∑|𝑋 − µ|2
𝐷𝐸 = √
𝑁
Para ello deberá elaborar un programa en C++ que solicite la cantidad de

estudiantes y el peso de cada estudiante.

• ¿Cuál es su análisis del problema?
Idetifique:

Si tendríamos que registrar los datos de dos o tres estudiantes serían suficientes
dos o tres variables (una para cada dato), sin embargo los datos pueden ser
tantos que se requiera una variable especial que almacene todos los datos a la
vez, es decir una variable de tipo vector. Cuando los datos del vector son
muchos se recomienda almacenarlos en memoria dinámica..


procedimientos
tmpPeso ¿? Promedio, moda, mayor, menor,
desviación
10,12,10,12 ¿? Promedio= 11, moda= 10, mayor=
12, menor= 10.
propuesto?
• ¿Cómo se define y usa un vector de espacios en memoría dinámica en
C++?
• ¿Cuáles son los algoritmos para calcular el promedio, mayor, menor,
moda y desviación estándar de un conjunto de datos en un vector?
2 REPASO TEÓRICO
2.1 Contenido
• Declaración de una variable vector en memoria estática o en memoria

dinámica
• Pasando un vector de dinámico a una función
• Liberar la memoria dinámica de un vector
2.2 Array, formación, alineación, vector o matriz

Decir array, formación, alineación, vector unidimensional para referirnos a un
conjunto de objetos continúos organizados por un criterio, es correcto, ejm.
Fisicamente podemos pensar en un conjunto de personas esperando turno para
ingresar a una sala de cine (criterio: número de boleto).
De la misma manera que, decir array, formación, alineación, vector

bidimensional para referirnos a un conjunto de objetos continuos organizados
por dos criterios, es correcto, ejm. el conjunto de butacas en la sala de cine
(criterios: código de fila y código de columna).
A un array, formación, alineación, vector bidimensional se le conoce como
matriz.

2.3 Declaración de una variable vector.
En memoria estática En memoria dinámica
int peso[10]; int *peso = new int[cantidad];
El tamaño del vector peso es 10 y el El tamaño del vector es cantidad y

tmaño estará predefinido desde que puede ser leído previamente desde el
se declara. Posteriormente, el teclado. Posteriormente, cantidad se
tamanio ya no se puede cambiar puede modificar, es decir la cantidad
hasta que termine de ejecutarse el de espacios separados pueden
programa. aumentar o disminuir cuando el
programa está en ejecución.
Ejemplo ilustrativo
#include<iostream>
void main()
{
int t = 10;
int *lista = new int[t];
for (int i = 0; i < t; i++)
{
lista[i] = pow(i , 2);
}
for (int i = 0; i <t; i++)
{
cout << lista[i] << " ";
}
cout << "\nModificando el tamanio del vector :" << endl;
t = 20;
lista = new int[t];
for (int i = 0; i < t; i++)
{
lista[i] = pow(i, 3);
}
for (int i = 0; i < t; i++)
{
cout << lista[i] << " ";
}
}
2.4 Pasando un vector dinámico a una función V1
Recibido mediante una variable estática
Llamar a la función Función

void main() void llenarVector(int vector[], int t)
{ {
int cantidad = 10; Random r;
//definir el vector dinámico //ingresando datos al vector
peso vector
int *peso = new int[cantidad]; for (int i = 0; i < t; i++)
//llenar vector con un {
procedimiento

llenarVector(peso, cantidad); vector[i] = 20 +
imprimirDatos(peso, cantidad); r.Next(40);
system("pause>NULL"); }
} }
Observe bien el formato de los Observe los formatos de los
argumentos que se envían parámetros que se reciben (variable
estática)
2.5 Pasando un vector dinámico a una función V2
Recibido mediante una variable dinámica

void main() void llenarVector(int *vector, int t)
{ {
int cantidad = 10; Random r;
//definir el vector dinámico //ingresando datos al vector
peso vector
int *peso = new int[cantidad]; for (int i = 0; i < t; i++)
//llenar vector con un {
procedimiento vector[i] = 20 +
llenarVector(peso, cantidad); r.Next(40);
imprimirDatos(peso, cantidad); }
system("pause>NULL"); }
}
Observe bien el formato de los Observe los formatos de los parámetros
argumentos que se envían que se reciben (variable dinámica)
2.6 Liberar la memoria dinámica de un vector
Si separamos un vector de memoria dinámica, entonces también habrá que
liberarla cuando finalice el programa de la siguiente manera:
Separamos memoria Liberamos memoria

int *peso = new int[cantidad]; delete []peso;
Análisis
Matriz de variables

int tmpPeso Valor temporal del peso que se usa para lectura
int peso[ ] Conjunto de pesos
double promedio Promedio de los pesos
int moda Moda de los pesos, es decir el valor que más se
repite
int mayor Valor del peso mayor
int menor Valor del peso menor
float desviacion Desviacion estándar de los datos

peso[ ] llenarVector(peso, cantidad); Promedio, moda,
mostrarDatos(peso, cantidad); mayor, menor,
promedio= calculaPromedio(peso, cantidad);
desviación

hallaModa(peso, cantidad, mod, rep);
mayor= hallaMayor(peso, cantidad);
menor= hallaMenor(peso, cantidad);
tmpPeso void llenarVector(int vector[], int
tamanio){}
void mostrarDatos(int vector[], int
tamanio){}
double calculaPromedio(int vector[], int
tamanio){}
int hallaMayor(int vector[], int tamanio){}
int hallaMenor(int vector[], int tamanio){}
void hallaModa(int vector[], int tamanio, int
&moda, int &repeticion){}
10,12,10,12 Promedio 11,
moda 10, mayor
12, menor 10.
Código
En la función principal main declaramos el vector unidimensional peso

para separar espacios en la memoria dinámica con el operador new, leemos la
cantidad de estudiantes en la variable cantidad y llamamos a la función
llenaVector(peso, cantidad) pasándole como argumento la variable vector
peso, además de la cantidad. La función llenaVector(int vector[ ], int t) recibe
como parámetros en la variable vector las direcciónes del vector peso, la
cantidad de datos en el parámetro t; luego llena los espacios de memoria
dinámica con números aleatorios que van desde 20 hasta 60. Teneniendo el
vector con datos se crean funciones para realizar todas las operaciones que nos
den los resultados que se pide.
Por otro lado, llamamos a la función hallaModa(peso, cantidad, mod,

rep) enviándole el vector de pesos, la cantidad, además de las variables mod
y rep. Recibimos la dirección de la variable mod con el parámetro &moda y la
variable rep en el parámetro &repetición; esto nos permitirá implementar un
procedimiento que simule la función que regresa dos valores.
#include<iostream>
#include<string>
#include<ctime>
void llenarVector(int vector[], int t)
{
srand(time(NULL));
//ingresando datos al vector vector
for (int i = 0; i < t; i++)
{
vector[i] = 20 + rand() % 40;
}
}
void mostrarDatos(int vector[], int t)
{
for (int i = 0; i < t; i++)
{
cout << vector[i] << " - ";
}
cout << endl;

}
double calculaPromedio(int vector[], int t)

{
double suma = 0.0;
for (int i = 0; i < t; i++)
{
suma = suma + vector[i];
}
return suma / t;
}
int hallaMayor(int vector[], int t)
{
int mayor = 0;
for (int i = 0; i < t; i++)
{
if (mayor < vector[i]) mayor = vector[i];
}
return mayor;
}
int hallaMenor(int vector[], int t)
{
int menor = vector[0];
for (int i = 0; i < t; i++)
{
if (menor > vector[i]) menor = vector[i];
}
return menor;
}
void hallaModa(int vector[], int t, int &moda, int &repeticion)

{
for (int i = 0; i < t; i++)
{
int cp = 0;
for (int j = 0; j < t; j++)
{
if (vector[i] == vector[j]) cp++;
}
if (repeticion < cp)

{
repeticion = cp;
moda = vector[i];
}
}
}
float desviacionEstandar(int vector[], int t, float &p)
{
float S;
for (int i = 0; i < t; i++)
{
S += pow(abs(vector[i] - p),2);
}
return sqrt(S) / t;
}
void main()
{
int cantidad, mod, rep = 0;
cout << "Cantidad de estudiantes : ";
cin >> cantidad;
int *peso = new int[cantidad];

//llenar vector con un procedimiento
llenarVector(peso, cantidad);
//Mostrar datos del vector peso con un procedimiento
mostrarDatos(peso, cantidad);
//Calculamos el promedio con la una función
float prom = calculaPromedio(peso, cantidad);
cout << "El promedio es: " << prom << endl;
//Encontramos la moda y la cantidad que se repite con un procedimiento,
por eso enviamos las variables mod y rep y recibimos sus direcciones en la
memoria estática.
hallaModa(peso, cantidad, mod, rep);
cout << "Moda es " << mod << " y se repite " << rep << " veces" << endl;
//imprimiendo el mayor
cout << "El mayor es: " << hallaMayor(peso, cantidad) << endl;
//imprimiendo el mayor
cout << "El menor es: " << hallaMenor(peso, cantidad) << endl;
//Desviación estandar
cout << "Desviacion estándar: " << desviacionEstandar(peso, cantidad,
prom) << endl;
//liberar la memoria dinámica
delete[]peso;
}
Resultados
Cantidad de estudiantes : 10
52 - 31 - 51 - 29 - 44 - 46 - 27 - 33 - 22 - 28 -
El promedio es: 36.3
Moda es 52 y se repite 1 veces
El mayor es: 52
El menor es: 22
Desviacion estándar: 3.26818
Resuelto 1 Hacer un programa que calcule la nota de un estudiante en una
prueba de 10 preguntas de opciones múltiples [A,B,C,D]. Cada pregunta se
evalúa con dos puntos. Debe inicializar un arreglo con las respuestas
correctas. El programa debe mostrar el nombre del estudiante, el arreglo de
respuestas correctas y el arreglo de respuestas del alumno y la nota del
alumno.
Análisis
Crearemos dos arreglos paralelos de caracteres, uno para las respuestas

correctas y otro para las respuestas que el estudiante va marcando.

código
#include<iostream>
#include<string>
void leeRespuestas(char *respuestaEstudiante)
{
for (int i = 0; i <= 9; i++)
{
cout << "Respuesta marcada " << i << ": ";
cin >> respuestaEstudiante[i];
// convierte a mayusculas elementos de respuestaEstudiante
respuestaEstudiante[i] = toupper(respuestaEstudiante[i]);
}
}
int calculaNota(char *respuestaEstudiante, char *respuestaCorrecta)
{
int tmpnota;
for (int i = 0; i <= 9; i++)
{
if (respuestaEstudiante[i] == respuestaCorrecta[i])
{
tmpnota = tmpnota + 2;
}
}
return tmpnota;
}
void muestraRespuestas(char *respuestaEstudiante, char *respuestaCorrecta)
{
for (int i = 0; i <= 9; i++)
{
cout << "\t" << respuestaCorrecta[i] << "\t" <<
respuestaEstudiante[i] << endl;
}
}
void main()
{ // Inicializa el array
char respuestaCorrecta[] = { 'A','C','D','D','B','C','D','A','B','C' };
char respuestaEstudiante[10];
string nombre;
int nota=0;
cout << "Ingrese nombre del estudiante : " << endl;
getline(cin,nombre);
cout << "Ingrese el array de respuestas [A, B, C, D]: " << endl;
// Lee array respuestaEstudiante
leeRespuestas(respuestaEstudiante);
// Muestra el nombre del estudiante
cout << "\nEstudiante : " << nombre << endl;
// muestra los dos arreglos respuestas
muestraRespuestas(respuestaCorrecta, respuestaEstudiante);
// calcula la nota del estudiante
nota = calculaNota(respuestaCorrecta, respuestaEstudiante);
cout << "\nNota = " << nota << endl;
}

Propuesto 1. Hacer un programa que permita ordenar alfabeticamente
una lista de nombres de tamaño N considerado constante. El tamaño
máximo de las cadenas considérela 20. Puede usar las funciones strcmp y
strcpy.
Propuesto 2. Llenar dos vectores, el primero con los dni de los estudiantes
que reprobaron programacion I, el segundo con los dni de los estudiantes
que reprobaron Matemática basica. Se pide crear otro arreglo formado por
los dni de los estudiantes que reprobaron ambas materias. Mostrar el arreglo
resultante ordenado ascendentemente.
Propuesto 3. En un vector de N elementos numéricos llamado venta, se

requiere ir sumando y mostrando cada elemento y su posición, siempre y
cuando su mayor se ecuentre entre el valor del primer elemento y el que
está al centro. Finalmente, muestre la suma. Cada elemento es generado
aleatoriamiente y no debe ser menor a 500.
Ejemplo:
Cantidad de estudiantes: 20
749 - 502 - 971 - 759 - 570 - 535 - 629 - 908 - 797 - 792 - 917 - 613 - 940 - 708 - 843
- 942 - 573 - 764 - 539 - 514 -
Primer elemento: 749
Elemento del centro: 917
0: 749 - 3: 759 - 7: 908 - 8: 797 - 9: 792 - 10: 917 - 14: 843 - 17: 764
Propuesto 4. Escribir un programa para pasar los elementos de un vector

A o un vecto B, y del vector B al vector A. Imprimir los datos iniciales y finales
de ambos vectores.
Propuesto 5. Teniendo un vector de N números generados

aleatoriamente (todos diferentes), realice lo siguiente:
• Imprimir el elemento mayor y su posición.

• Mostrar la suma de los elementos almacenados en las posiciones pares
a excepción del que está en el centro.
• Imprimir los elementos mayores de 80 y menores de 120, imprimir la
cantidad.
• Imprimir la cantidad de elementos que esisten en el vector y son múltiplos
de 7.
• Imprimr los elementos del vector de forma inversa.
• Imprimir el vector ordenado descendentemente.

6 INVESTIGACIÓN
de los aspectos más importantes del uso arreglos unidimensionales. Resuelva los
ejercicios usando memoria dinámica.
7 EVALUACIÓN

Capítulo 21:
Matrices
1 SITUACIÓN PROBLEMATICA
Una empresa automotriz tiene cinco agencias y cuenta con la información
acerca de las ventas mensuales en soles de automóviles logradas el año
pasado por cada una de éstas. A partir de esta información la empresa
construyó la siguiente matriz ventas:
Mes\Agencia agencia 1 agencia 2 agencia 3 agencia 4 agencia 5
enero 20 40 21 21 19
febrero 12 12 16 12 12
marzo 12 28 12 17 12
… … … … … …
diciembre 13 45 27 45 45
Se le solicita a usted que elabore un programa en C++ que permita lo siguiente:
• Registrar la información de las ventas por mes de cada una de las

agencias.
• Mostrar en pantalla el resumen de ventas de cada agencia.
• Mostrar el total de ventas por mes
• Mostrar el total de ventas agencia
• Mostrar el promedio de ventas en julio
• Mostrar el promedio de ventas en la agencia 3.
• Mostrar el número de la agencia que tuvo mayores ventas en el mes de
julio.
• Indicar en qué mes se registraron las menores ventas del año para cada
una de las agencias.

Idetifique:

1.3 Análisis del problema y propuesta de solución
Si fueran dos o tres conjunto de datos, serían suficientes dos o tres vectores
unidimensionales, sin embargo la cantidad de datos pueden ser muchos, lo que
requiere una variable de tipo matriz, en este caso podríamos definirlos por mes.
Dado que los datos en una matriz suelen ser muchos, se recomienda usar
memoria dinámica.

procedimientos
nombre, sexo, ¿? nombre, sexo, nacimiento,
nacimiento, edad, edad, peso, dirección
peso, dirección
propuesto?
• ¿Cómo crear una matriz de espacios en memeoria dinámica?
• ¿Cómo pasar los datos de una matriz a una función y como recibirlos?
• ¿Cuáles son los algoritmos básicos para operar en una matriz?
2 REPASO TEÓRICO
A una matriz también se les denomina array, formación, alineación o vector
bidimensional.
2.1 Contenido
• Declaracion de una variable matriz en memoria estática o en memoria

dinámica.
• Pasando una matriz dinámica a una función
• Liberar la memoria dinámica de una matriz
2.2 Declaracion de una variable matriz en memoria

estática o en memoria dinámica.
En memoria estática En memoria dinámica
double matriz[12][5]; double **matriz;
int cf=10, cc=15;
matriz = new double*[cf];
for (size_t i = 0; i < cf; i++)
{
matriz[i] = new double[cc];
}
El tamaño de la matriz es 12 filas por La cantidad de filas de la matriz es cf y
5 columnas y estará predefinido la cantidad de columnas es cc, estos
desde que se declara la variable valores pueden ser leídos desde el
matriz. Posteriormente ya no se teclado y asignado en cualquier

puede modificar, es decir el momento. Posteriormente se puede
tamaño será el mimso hasta que modificar, es decir las dimensiones de los
termine de ejecutar el programa. espacios separados pueden variar
(aumentar o disminuir) mientras se
ejecute el programa.
2.3 Paso de una matriz dinámica a una función
//crear void registrarDatos(int &cFi, int cCol,
double **matriz; double **mat)
int cf, cc; {
//Creando el vector srand(time(NULL));
matriz = new double*[cf]; //recorrido filas
//Creando el vector de vectores for (int i = 0; i < cFi; i++)
for (size_t i = 0; i < cf; i++) {
{ //recorrido de columnas
matriz[i] = new for (int j = 0; j < cCol; j++)
double[cc]; {
} mat[i][j] = 50000 + rand() %
//llamar 30000;
registrarDatos(cf, cc, matriz); }
}
}
Una matriz es un vector de vectores Observe los formatos de los
Observe los formatos de los parámetros que se reciben
argumentos que se envían
2.4 Liberar la memoria dinámica de una matriz

Si separamos memoria dinámica y la dirección los asignamos a un puntero de
punteros, entonces tambien habrá que liberar la memoria cuando finalice el
programa.
Separamos memoria Liberamos memoria

double **matriz; for (int i = 0; i < cf; i++)
int cf, cc; {
matriz = new double*[cf]; delete[] matriz[i];
for (size_t i = 0; i < cf; i++) }
{ delete[] matriz;
matriz[i] = new
double[cc];
}
Matriz de variables

int cc Cantidad de meses
int cf Cantidad de agencias
matriz double Recaudación por cada agencia


procedimientos
Cc, cf, matriz cargaDatos(); VentaPorMes
mostrarDatos(); VentaTotal
void cargaDatos(){}
void mostrarDatos(){}
3.2 Código
#include<iostream>
#include<ctime>
//Registramos numeros aleatorios entre 50000 y 80000 que representaran
nuestras ventas
void registrarDatos(int &cFi, int cCol, double **mat) {
srand(time(NULL));
for (int i = 0; i < cFi; i++) //recorrido filas
{
for (int j = 0; j < cCol; j++) //recorrido de columnas
{
mat[i][j] = 50000 + rand() % 30000;
}
}
}
//Imprimimos todos los datos resgistrados recorriendo para cada mes
todas las agencias
void imprimirDatos(int &cFi, int cCol, double **mat) {
for (int i = 0; i < cFi; i++)
{
cout << "Mes " << i+1<<": ";
for (int j = 0; j < cCol; j++)
{
cout << mat[i][j] << "\t";
}
cout << endl;
}
}
//Imprimimos los totales para cada mes
void sumaFilas(int &cFi, int cCol, double **mat) {
{
int suma = 0;
{
suma += mat[i][j];
}
cout << "Mes " << i+1 << " venta es : " << suma << endl;
}
}
//Imprimimos los totales para cada agencia
void sumaColumnas(int &cFi, int cCol, double **mat) {
//Encabezado

{
cout << "Agencia " << j + 1 << "\t";
}
cout << endl;

{
int suma = 0;
{
suma += mat[i][j];
}
cout<< suma << "\t\t";
}
cout << endl;
}
//Imprimimos el promedio de ventas de un mes específico
void sumaUnaFila(int &nf, int &cCol, double **mat)
{
int suma = 0;
{
suma += mat[nf][j];
}
cout << "Mes " << nf +1<< " promedio es : " << suma/cCol <<
endl;
}
//Imprimimos el promedio de ventas de una agencia específica
void sumaUnaColumna(int &nc, int &cFil, double **mat)
{
int suma = 0;
for (int i = 0; i < cFil; i++)
{
suma += mat[i][nc];
}
cout << "Agencia " << nc+1 << " promedio es : " <<
(double)suma/cFil << endl;
}
//Imprimimos la agencia que tiene la mayor venta en de mes específico

void hallaMayorEnFila(int &nf, int &cCol, double **mat)
{
int mayor = mat[nf][0];
int nAgencia=0;
{
if (mayor<mat[nf][j])
{
mayor = mat[nf][j];
nAgencia = j;
}

}
cout << "Mes " << nf+1 << " Mayor venta: " << mayor << "
corresponde a la agencia "<<nAgencia+1<<endl;
}
//Imprimimos el mes que tiene la menor venta para cada agencia
void menorDeCadaColumna(int &cFi, int cCol, double **mat) {
{
int menor = mat[0][j];
int mes;
{
if (menor>mat[i][j])
{
menor = mat[i][j];
mes = i;
}
}
cout << "Agencia: " << j+1 << " Menor: " << menor <<"
corresponde al mes:"<<mes+1 <<endl;
}
}
//Liberamos los espacios de memoria dinámica
void liberaMemoriaMatriz(int &cf, double **matriz)
{
for (int i = 0; i < cf; i++)
{
delete[] matriz[i];
}
delete[] matriz;
}
//Función principal
void main()
{
double **matriz;
int cf, cc;
do {
cout << "Ingrese el número de filas : ";
cin >> cf;
} while (cf > 12 || cf <0);
do {
cout << "Ingrese el numer de columnas : ";
cin >> cc;
} while (cc > 10 || cc < 0);
{
}
//Registrar la información de las ventas por mes de cada una de
las agencias
registrarDatos(cf, cc, matriz);

//Mostrar en pantalla el resumen de ventas de cada agencia
imprimirDatos(cf, cc, matriz);
//Mostrar ventas por mes
cout << "\nVENTAS TOTALES POR MES" << endl;
sumaFilas(cf, cc, matriz);
//Mostrar ventas por semana
cout << "\nVENTAS TOTALES POR AGENCIA" << endl;
sumaColumnas(cf, cc, matriz);
cout << "\nPROMEDIOS" << endl;
//Mostrar el promedio de ventas en julio
int nf = 6;
sumaUnaFila(nf, cc, matriz);
//Mostrar el promedio de ventas en la agencia 3.
int nc = 2;
sumaUnaColumna(nc, cc, matriz);
//Mostrar el número de la agencia que tuvo mayores ventas en el
mes de julio.
hallaMayorEnFila(nf, cc, matriz);
//Mes se registraron las menores ventas del año para cada una de
las agencias.
menorDeCadaColumna(cf, cc, matriz);
system("pause");
}
Resuelto 1 El Gerente de una empresa de taxis que tiene a su cargo 20

conductores desea registrar de cada uno de ellos la cantidad de pasajeros
que ha transportado durante los 6 días que laboran. Solicita escribir un
programa en C++ que permita realizar lo siguiente:
• Genere aleatoriamente la cantidad de pasajeros transportados (un

valor entre 1 y 25) diariamente por cada conductor. Esta información
será almacenada en una matriz.
• Imprima la matriz generada.
• Determine e imprima para cada conductor, el total de pasajeros
transportados durante la semana.
• Determine e imprima para cada día, el promedio de pasajeros
transportados.
• Determine e imprima el día o días en que se registró el mayor número
total de pasajeros transportados.
Para la solución del problema debe hacer uso de funciones.

Análisis
?
Programa
#include<iostream>
#include<ctime>
//Crear los espacios de memoria dinámica
//el parámetro en la función es **&matriz
void creaMemoriaMatriz(int &cf, int &cc, double **&matriz)
{
while(true) {
cout << "Ingrese el cantidad de conductores : ";
cin >> cf;
if (cf > 10 && cf < 20) break;
}
while (true) {
cout << "Ingrese el cantidad de dias : ";
cin >> cc;
if (cc > 3 && cc <= 6) break;
}

{
}
}
//Liberamos los espacios de memoria dinámica
void liberaMemoriaMatriz(int &cf, int &cc, double **matriz)
{
for (int i = 0; i < cf; i++)
{
delete[] matriz[i];
}
delete[] matriz;
}
//Registramos numeros aleatorios entre 50000 y 80000 que representaran nuestras

ventas
void registrarDatos(int &cFi, int cCol, double **mat) {
Random a;
for (int i = 0; i < cFi; i++) //recorrido filas
{
for (int j = 0; j < cCol; j++) //recorrido de columnas
{
mat[i][j] = a.Next(25);
}
}
}
//Imprimimos todos los datos resgistrados recorriendo para cada mes todas las
agencias
void imprimirDatos(int &cFi, int cCol, double **mat) {

cout << "\n Cantidad diaria de pasajeros transportados por un conductor :
"<<endl;
{
cout << "Conductor " << i + 1 << ": ";
{
cout << mat[i][j] << "\t";
}
cout << endl;
}
}
//Imprimimos los totales para cada mes
void sumaFilas(int &cFi, int cCol, double **mat) {
{
int suma = 0;
{
suma += mat[i][j];
}
cout << "Conductor " << i + 1 << " transportado es : " << suma <<
endl;
}
}
//Imprimimos los promedio para cada dia
void promedioColumnas(int &cFi, int cCol, double **mat) {
//Encabezado
{
cout << "Dia " << j + 1 << "\t";
}
cout << endl;

{
int suma = 0;
{
suma += mat[i][j];
}
cout << suma/cFi << "\t\t";
}
cout << endl;
}
void diasMayorTransporte(int &cFi, int cCol, double **mat) {

//Hallando la mayor cantidad de pasajeros transportados por día
int may = mat[0][0];
{
int suma = 0;
{
suma += mat[i][j];
}
if (may < suma) may = suma;

}
//Imprimimos los días mas pasajeros se trasportó
cout << "La cantidad de pasajeros que mas se trasnportó es: " <<may<<endl;
{
int suma = 0;
{
suma += mat[i][j];
}
if (may == suma) cout<<"\tDia : "<<(j+1);
}
}
void main()
{
double **matriz;
int cf, cc;
creaMemoriaMatriz(cf, cc, matriz);
//Registrar la información de las ventas por mes de cada una de las

agencias
registrarDatos(cf, cc, matriz);
//Mostrar en pantalla el resumen de ventas de cada agencia
imprimirDatos(cf, cc, matriz);
//Mostrar ventas por mes
cout << "\nTOTAL TRANSPORTADO POR CADA CONDUCTOR EN LA SEMANA" << endl;
sumaFilas(cf, cc, matriz);
//Mostrar ventas por semana
cout << "\nTRANSPORTE PROMEDIO POR DIA" << endl;
promedioColumnas(cf, cc, matriz);
//Dias que mas se trasnporto
diasMayorTransporte(cf, cc, matriz);
liberaMemoriaMatriz(cf, cc, matriz);
}
Propuesto 1. Escriba una función que muestre los elementos de la
diagonal secundaria de una Matriz.
1 2 8 2 6
6 9 8 5 4
6 2 9 6 5
1 8 8 4 7
5 2 4 2 8
Propuesto 2. Escriba una función que compruebe si una matriz es

identidad
1 0 0 0 0
0 1 0 0 0
0 0 1 0 0

0 0 0 1 0
0 0 0 0 1
Propuesto 3. Escriba una función que compruebe si una matriz es

Escalar.
3 0 0 0 0
0 3 0 0 0
0 0 3 0 0
0 0 0 3 0
0 0 0 0 3
Propuesto 1 Escriba una función que compruebe si una matriz es la
Transpuesta de otra.
A=
2 6 7
1 9 0
3 5 6
AT=
2 1 3
6 9 5
7 0 6
Propuesto 2 Escriba una función para obtener la matriz transpuesta de

cualquier matriz de orden M x N.
Propuesto 3 Escriba una función que compruebe si una matriz es
simétrica
1 -1 3
-1 2 4
3 4 7
Propuesto 4 Escriba una función que compruebe si una matriz tiene una
triangular superior.
1 6 -2
0 4 3
0 0 5
Propuesto 5 Realice un subprograma que compruebe si una matriz tiene

una triangular inferior.
1 0 0
3 2 0
-8 4 9

Propuesto 6 Realice un programa para simular el movimiento de una
ficha de un tetris representada por una matriz. Al apretar flecha a la
derecha en le teclado, la matriz va girando secuencialmente hacia la
derecha de 1 hasta 5. Tenga en cuenta que la gráfica de la ficha puede
ser otra. Se recomienda dos matrices.
1 2 3
x x x x x
x x x
x x x x x x x x x x x
x x x
x x x x x
4 5
x x x x
x x
x x x x x x
x x
x x x x
6 INVESTIGACIÓN
de los aspectos más importantes del uso arreglos unidimensionales.
7 EVALUACIÓN

Capítulo 22:
Registros con structs
1.1 Enunciado
Escribir un programa para almacenar los datos de un estudiante usando un
vector.
- dni
- nombre
- sexo
- fecha de nacimiento
- edad
- peso
- dirección
Ejemplo:
dni nombre sexo nacimiento edad peso dirección

12154548 Albertina F 10/10/2005 13 50.2 Av. Universitaria 1455
Idetifique:
• ¿Cuál será el algoritmo que respresenta la solución?
Se requiere almacenar datos de diferente tipo en un mismo vector, pero eso no
es posible.
En un vector de notas, todos los datos son de tipo entero
Índice 0 1 2 3 4
notas 14 12 20 14 9
En un vector de códigos, todos los datos son de tipo carácter
Índice 0 1 2 3 4
códigos A Y N R W

En un vector de nombres, todos los datos son de tipo cadena
Índice 0 1 2 3 4
nombres Juan Luis Maria Brigitte Julia
Sin embargo, en caso que se requiera de un vector que almacene datos de una
persona, se observa que estos son de diferente tipo
Indice 0 1 2 3 4
Dato 16702558 Juan Manuel M 25 68.56
Se require de un tipo de vector especial al que llamaremos registro, para ello se

hará uso de struct, en el que los índices se transforman en campos y cada
campo puede ser de diferente tipo. Un struct nos permite administrar un
conjunto de datos de diferente tipo (registro).
Un registro es un vector en los que los datos pueden ser de diferente tipo.
Campo DNI nombres Sexo edad peso

Dato 16702558 Juan Manuel M 25 68.56
Preguntas que salen a la vista:
• ¿Cuál sería el formato de una variable u objeto para almacenar un

conjunto de datos de diferente tipo?
• ¿Cómo se gestionan los datos de diferente tipo?

procedimientos
nombre, sexo, ¿? nombre, sexo, nacimiento,
nacimiento, edad, edad, peso, dirección
peso, dirección
propuesto?
• ¿Cómo se define y usa un vector para almacenar datos de diferente
tipo?
• ¿Cómo se define un vector dinámico de registros?
2.1 Contenido
• Declaración de un struct
• Acceso a los elementos de un struct
• Structs anidados
• typedef: alias de un tipo struct

• Vector dinámico de estructuras
2.2 Declaración de una struct

Recuerde que un vector permite almacenar un conjunto de datos y todos de un
mismo tipo. Sin embargo, se puede usar un struct, para almacenar un registro
cuyos datos son de diferente tipo.
Se declara de la siguiente manera:
Manera 1 Manera 2
struct { struct Tarjeta {
long long num_tarjeta; long long num_tarjeta;
char tipo_cuenta; char tipo_cuenta;
float saldo; float saldo;
} cliente1, cliente2; };
void registraCuenta()
{
Tarjeta cliente1, cliente2;
}
La estructura no tiene nombre. El nombre de la estructura es Tarjeta. Se
Directamente se han creado los crea dos registros cliente1 y cliente2
registros cliente1 y cliente2
Ejemplo: creación de registros de tipo struct
Struct sin nombre Struct con nombre

struct struct Persona
{ {
int Dni; int Dni;
string nombre; string nombre;
char sexo; char sexo;
string fecha; string fecha;
int edad; int edad;
double peso; double peso;
string direccion; string direccion;
} estudiante; };
estudiante.Dni = 12154548; Persona estudiante;
estudiante.Dni = 12154548;
2.3 Acceso a los atributos de un struct
Struct Asignación de valores a los campos de
struct
struct void main()
{ {
char inicial; persona.inicial = 'J';
int edad; persona.edad = 20;
float nota; persona.nota = 7.5;
} persona; }
El acceso al campo edad se hace
mediante persona.edad

2.4 Structs anidados
Estructura anidada Acceso a los campos
struct Nacimiento void main()
{ {
int dia; datosPersona persona;
int mes; persona.inicial = 'I';
int anio; persona.diaNac.mes = 8;
}; persona.nota = 7.5;
struct datosPersona cout << "La nota es " <<
{ persona.nota;
char inicial; system("pause>NULL");
Nacimiento diaNac; }
float nota;
};
2.5 typedef: alias de un tipo struct
Con tipo struct Con tipo entero
typedef struct Libro { typedef int AliasEntero;
} AliasLibro;
El nombre del struct es Libro El alias de int es AliasEntero
El alias de Libro es AliasLibro AliasEntero nota1, nota2;
AliasLibro libro1, libro2;
Libro libro3;
Ejemplo 1: con typedef, podemos definir el nombre de un struct, además

podemos definir el alias de un struct.
Variable con el nombre del struct Variable con el alias del struct
typedef struct Persona typedef struct Persona
{ {
int Dni; int Dni;
int edad; int edad;
}; } aliasPersona;
//Nombre del struct es Persona //Nombre del struct es Persona
Persona estudiante; Persona estudiante;
estudiante.Dni = 12154548; estudiante.Dni = 12154548;
Ejemplo 2: con typedef se crea una variable del tipo nombre o del alias.
Struct con nombre y alias Struct con nombre y alias

typedef struct Persona typedef struct Persona
{ {
int Dni; int Dni;

int edad; int edad;
} datosPersona; } datosPersona;
Persona estudiante; datosPersona estudiante;
estudiante.Dni = 12154548; estudiante.Dni = 12154548;
2.6 Vector dinámico de registros
Luego que se crea un struct se puede crear un vector de registros para gestionar
los datos de una tabla, donde cada fila es un registro.
Fuera del main Dentro del main

using namespace std; using namespace std;
typedef struct typedef struct
{ {
char inicial; char inicial;
int edad; int edad;
float nota; float nota;
} datosPersona; } datosPersona;
int tam=50;
datosPersona *personas = new
datosPersona[tam];
void main() void main()
{ { int tam=50
system("pause"); datosPersona *personas;
} personas = new
datosPersona[tam];
system("pause");
}
Matriz de variables

int dni Almacena el dni del estudiante
string nombre Almacena el nombre del estudiante
char sexo Almacena el sexo del estudiante
string fecha Almacena la fecha del estudiante
int edad Almacena la edad del estudiante
double peso Almacena el peso del estudiante
string dirección Almacena la dirección del estudiante

procedimientos
dni, nombre, sexo, cargaDatos(); dni, nombre, sexo,
fecha, edad, peso, mostrarDatos(); fecha, edad, peso,
dirección dirección
void cargaDatos(){}

void mostrarDatos(){}
3.2 Código
Versión 1, sin funciones
#include<iostream>
#include<string>
#include<ctime>
typedef struct Persona
{
int Dni;
string nombre;
char sexo;
string fecha;
int edad;
double peso;
string direccion;
} datosPersona;
void main()
{
Persona estudiante; //con el NOMBRE de la estructura
//datosPersona estudiante; //con el ALIAS de la estructura
estudiante.nombre = "Albertina";
estudiante.sexo = 'F';
estudiante.fecha = "10/10/2005";
estudiante.edad = 13;
estudiante.peso = 50.2;
estudiante.direccion = "Av. Universitaria 1455";
//Impresión de datos
cout << "Datos del registro : " << endl;
cout<<"DNI\t: "<<estudiante.Dni << endl;
cout<<"Nombre\t: "<<estudiante.nombre<<endl;
cout<<"Sexo\t: "<<estudiante.sexo <<endl;
cout<<"Fecha\t: "<<estudiante.fecha<<endl;
cout<<"Edad\t: "<<estudiante.edad<<endl;
cout<<"Peso\t: "<<estudiante.peso<<endl;
cout<<"Dirección\t: "<<estudiante.direccion<<endl;
system("pause");
}
Versión 2, con funciones, variable registro por defecto
#include<iostream>
#include<string>
#include<ctime>
struct
{
int Dni;
string nombre;

char sexo;
string fecha;
int edad;
double peso;
string direccion;
} estudiante;
void cargaDatos()
{
}
void mostrarDatos()
{
cout << "DNI\t: " << estudiante.Dni << endl;
cout << "Nombre\t: " << estudiante.nombre << endl;
cout << "Sexo\t: " << estudiante.sexo << endl;
cout << "Fecha\t: " << estudiante.fecha << endl;
cout << "Edad\t: " << estudiante.edad << endl;
cout << "Peso\t: " << estudiante.peso << endl;
cout << "Dirección\t: " << estudiante.direccion << endl;
}
void main()
{
cargaDatos();
mostrarDatos();
system("pause");
}
Versión 3, creando variable registro

#include<iostream>
#include<string>
#include<ctime>
struct Persona
{
int Dni;
string nombre;
char sexo;
string fecha;
int edad;
double peso;
string direccion;
};
Persona estudiante; //variable global

void cargaDatos()
{
}
void mostrarDatos()
{

cout << "DNI\t: " << estudiante.Dni << endl;
cout << "Nombre\t: " << estudiante.nombre << endl;
cout << "Sexo\t: " << estudiante.sexo << endl;
cout << "Fecha\t: " << estudiante.fecha << endl;
cout << "Edad\t: " << estudiante.edad << endl;
cout << "Peso\t: " << estudiante.peso << endl;
cout << "Dirección\t: " << estudiante.direccion << endl;
}
void main()
{
cargaDatos();
mostrarDatos();
system("pause");
}
Versión 4, variable registro en memoria din ámica

Recuerde liberar memoria si es que la separó usando punteros.
#include<iostream>
#include<string>
#include<ctime>
struct Persona
{
int Dni;
string nombre;
char sexo;
string fecha;
int edad;
double peso;
string direccion;
};
Persona *estudiante = new Persona;
//Persona estudiante;

void cargaDatos()
{
estudiante->Dni = 12154548;
estudiante->nombre = "Albertina";
estudiante->sexo = 'F';
estudiante->fecha = "10/10/2005";
estudiante->edad = 13;
estudiante->peso = 50.2;
estudiante->direccion = "Av. Universitaria 1455";
}
void mostrarDatos()
{

cout << "DNI\t: " << estudiante->Dni << endl;
cout << "Nombre\t: " << estudiante->nombre << endl;
cout << "Sexo\t: " << estudiante->sexo << endl;
cout << "Fecha\t: " << estudiante->fecha << endl;
cout << "Edad\t: " << estudiante->edad << endl;
cout << "Peso\t: " << estudiante->peso << endl;
cout << "Dirección\t: " << estudiante->direccion << endl;
}
void main()
{
cargaDatos();
mostrarDatos();
system("pause");
}
Resuelto 1. Crear un vector de registros, a cada registro le corresponde: dni,
nombre, sexo, fecha de nacimiento, edad, peso y dirección.
Análisis
• Usando una matriz5 podemos almacenar la cantidad de autos vendidos por

tienda en los últimos cinco meses, aquí todos los datos son de tipo entero:
mes\tienda tienda 1 tienda 2 tienda 3

abril 2 2 1
mayo 1 3 2
junio 1 2 2
julio 2 3 1
agosto 2 2 2
5 El tema de matrices se verá detalladamente en la siguiente guía.

• Sin embargo en este caso solo se requiere de una matriz que almacene
datos del mismo tipo, una matriz es suficiente. Cuando se requiere
almacenar datos en donde por cada fila, los datos son de diferente tipo, se
requiere un vector de estructuras6. Cada fila es un dato del nuevo vector,
cada fila o dato es una estructura por lo que se pude concluir que un vector
de estructuras es una tabla.
fila\campo dni nombres sexo edad peso

0 16702558 Mariana F 24 58.22
1 14705558 Julia F 26 60.5
2 33702791 Juan Manuel M 20 68.88
• Recuerde que una fila es un registro de datos de diferente tipo.

Algunas de las cuestiones que debemos resolver son:
¿Cómo crear un vector de registros o filas de datos?
¿Cómo almacenar una fila de datos (en una sola variable, como si fuera
un solo dato) en una posición de un vector estático o dinámico?
¿Cómo crear un vector de registros, filas o estructuras en C++?
código
#include<iostream>
#include<string>
#include<ctime>
struct persona
{
int Dni;
string nombre;
char sexo;
string fecha;
int edad;
double peso;
string direccion;
};
int cantidad=4;
//persona estudiante[4]; //En memoria estática
persona *estudiante = new persona[cantidad]; //En memoria dinámica
void cargaDatos()
{
for (int i = 0; i < cantidad; i++)
{
6Un vector de estructuras es una tabla en donde cada fila es un elemento, cada fila es
una estructura

cout << "Dni : ";
cin>>estudiante[i].Dni;
cin.get(); //antes de leer frase
cout << "Nombres : ";
getline(cin, estudiante[i].nombre);
cout << "Sexo : ";
cin>>estudiante[i].sexo;
cout << "Fecha : ";
cin>>estudiante[i].fecha;
cout << "Edad : ";
cin>>estudiante[i].edad;
cout << "Peso : ";
cin>>estudiante[i].peso;
cout << "Direccion : ";
getline(cin, estudiante[i].direccion);
}
}
void mostrarDatos()
{ cout << "Datos del vector de la fila : " << endl;
cout << "DNI\t " << "Nombre\t " << "Sexo\t " << "Fecha\t " <<
"Edad\t " << "Peso\t " << "Dirección\t " <<endl;
{
cout << estudiante[i].Dni <<"\t " << estudiante[i].nombre
<< "\t " << estudiante[i].sexo << "\t " << estudiante[i].fecha << "\t
" << estudiante[i].edad << "\t " << estudiante[i].peso << "\t " <<
estudiante[i].direccion << endl;
}
}
void main()
{
cargaDatos();
mostrarDatos();
}
Resuelto 2. Genere caracteres numéricos de diferentes colores que

representen alienígenas en el espacio, estos alienígenas se mueven de
izquierda a derecha y viciversa respetando un ancho de 80 lugares en la
consola.
Análisis
El ancho de la consola es de 80 pixeles. Se requiere generar caracteres

numéricos y ubicarlos aleatoriamente, borrarlos, moverlos en una posición y
luego volver a pintarlos. Para simular el movimiento de un carácter el algoritmo
general es: borrar, mover, pintar.

Código
#include<iostream>
#include<string>

typedef struct {
int x;
int y;
int color;
int vy;
int vx;
int tipo;
} Alien;
void gotoXY(int x, int y) {
}
void cargaAliens(Alien *vec, int tamanio)
{ //Cargamos el vector con todos los aliens necesarios
Random ra;
for (int i = 0; i < tamanio; i++)
{
vec[i].x = ra.Next(2, 80);
vec[i].y = ra.Next(2, 30);
vec[i].color = ra.Next(1, 15);
vec[i].tipo = ra.Next(0, 9);
vec[i].vx = ra.Next(1, 3);
vec[i].vy = ra.Next(1, 3);
}
}
void dibujaAlien(Alien oa) {
gotoXY(oa.x, oa.y);
Console::ForegroundColor = ConsoleColor(oa.color);
cout << oa.tipo;
}
void borraAlien(Alien oa) {

gotoXY(oa.x, oa.y);
Console::ForegroundColor = ConsoleColor(oa.color);
cout << " ";
}
void cambiaAlienH(Alien &oa) {

if (oa.x < 4 || oa.x>79) oa.vx = -1 * oa.vx;
oa.x = oa.x + oa.vx;
}
void trasladaAliens(Alien *vec, int tamanio) {

for (int i = 0; i < tamanio; i++)
{
borraAlien(vec[i]);
cambiaAlienH(vec[i]);
dibujaAlien(vec[i]);
}
}
void main()
{
int tamanio = 30;
Alien *lista1 = new Alien[tamanio];

cargaAliens(lista1, tamanio);
while (true)
{
trasladaAliens(lista1, tamanio);
_sleep(100);
}
}
Resultado
7 5
Propuesto 1. Elabore el programas en C++ que permita gestionar los
datos de stock de una tienda de comestibles, la información a coleccionar
será: nombre del producto, precio, cantidad en stock. La tienda dispone de
10 productos distintos. El programa debe ser capaz de:
❖ Dar de alta un producto nuevo.

❖ Buscar un producto por su nombre.
❖ Modificar el stock y precio de un producto dado.
Propuesto 2. Elabore el programas en C++ que permita gestionar las

notas de una clase de 20 alumnos de los cuales sabemos el nombre y la nota.
El programa debe ser capaz de:
• Buscar un alumno.
• Modificar su nota.

• Realizar la media de todas las notas.
• Realizar la media de las notas menores de 5.
• Mostrar el alumno que mejores notas ha sacado.
• Mostrar el alumno que peores notas ha sacado.
Propuesto 3. Un fila de entre 10 a 20 de alienígenas malvados de

diferentes colores, uno tras otro están en la parte superior del espacio
represntado por la consola. Una nave salvadora representada por más de 3
caracteres se mueve de izquierda a derecha en la parte inferior de la
pantalla en retén para repeler inmediatamente el ataque. Programe la
impresión de los alienígenas en la consola y el movimiento de la nave en
forma horizontal manipulado por las respectivas teclas direccionales
(izquierda y derecha).
Propuesto 4. Una cierta cantatidad de alienígenas malvados de

diferentes colores, se mueven en diferentes direcciones en el espacio
representado por la consola. Una nave salvadora representada por más de
3 caracteres se mueve de izquierda a derecha en la parte inferior de la
pantalla en retén para repeler inmediatamente el ataque. Programe el
movimiento de traslación de los alienígenas y el movimiento de la nave
horizontal y vertical manipulado por las respectivas teclas direccionales
(izquierda, derecha, arriba, abajo).
6 INVESTIGACIÓN
de los aspectos más importantes del uso arreglos unidimensionales.
7 EVALUACIÓN

Capítulo 23:
Funciones dentro de structs
1 SITUACION PROBLEMATICA
1.1 Enunciado
Simular el rebote (caída y regreso) indefinido de un balón. Use un objeto o
registro que represente el balón, cuyos campos sean las posiciones en el eje X y
Y de la consola.

Idetifique:
• ¿Cuál será el algoritmo que respresenta la solución?

Se require de un struct compuesto por campos y funciones que permitan
gestionar la posición en X y Y del objeto que represente el balón.
En una matriz, con X recorremos las las filas y Y las columnas matriz(X, Y). En la
consola con X recorremos las columnas y con Y las filas consola(X, Y). En la
solución de este ejercicio, implementamos la función posicion(X, Y) en el que
intercambiamos la posición X por Y y Y por X, esto nos ayuda a pensar que la
consola es una matriz a la que estamos acostumbrados. Dicho intercambio se
realiza en la Console::SetCursorPosition (Y,X).
Si queremos pintar un punto (X, Y) de una matriz en similar posición en la

consola se tiene que intercambiar X por Y, quedando matriz(X,
Y)=consola(Y,X)
Matriz (i, j) Console::SetCursorPosition(j, i);
0 1 2 3 4 5 6 0 1 2 3 4 5 6
0 0
1 1
2 ☺ 2 ☺
3 3
4 4
5 5

• En la matriz, la carita está en • Para pintarlo en la consola se
el punto (2,3) usa
• En la matriz, i lleva el control Console::SetCursorPosition(3,2)
de filas y j de las columnas • En la consola, i lleva el control
de columnas y j de las filas
1.4 Cuetiones teóricas

❖ ¿Cómo se escriben las funciones dentro de un struct?
❖ ¿Es posible de implementar struct con y sin punteros?
❖ ¿Es posible crear objetos de registros en memoria estática (con y sin
struct) y memoria dinámica?
2 REPASO TEÓRICO
2.1 Contenido
❖ Structs de variables en memoria estática (con y sin punteros)
❖ Structs compuestos por espacios en memoria dinámica
❖ Variable, registro u objetos en memoria estática y dinámica
2.2 Struct compuesto por campos en memoria estática

Un registro es una colección de datos de diferente tipo, en contraposición a un
vector unidimensional donde la colección es de un solo tipo. La implementación
de un struct es una aproximación a la implementación de una clase, endonde
cada atributo o campo puede ser gestionado independientemente usando
funciones.
#include <iostream>
struct Par {
int A, B;
Par() { A = 10; B = 20; }
~Par() {
A = 0; B = 0; //delete A; delete B;
}
int getA() { return A; } // Devuelve el valor de A

int getB() { return B; } // Devuelve el valor de B
void setA(int n) { A = n; } // Asigna un nuevo valor a A
void setB(int n) { B = n; } // Asigna un nuevo valor a B
} par1;
void main() {
cout <<"A por defecto: "<<par1.A << endl;
par1.setA(500);
cout << "A asignado: "<<par1.getA() << endl;
cout << "B por defecto: "<<par1.getB();
}

Resultado
A por defecto: 10
A asignado: 500
B por defecto: 20
2.3 Registro en memoria estática y memoria dinámica

En el ejemplo, los atributos del struct están declarados en memoria estática; los
objetos, variables o registro pueden declararse en memoria estática (con y sin
punteross) y dinámica.
#include <iostream>
#include<string>
struct Par {
string A;
float B;
//COnstructor
Par() {
A = "";
B = 0;
}
//Destructor
~Par() {
delete &A;
delete &B;
}
string getA() { return A; } // Devuelve el valor de A
int getB() { return B; } // Devuelve el valor de B
void setA(string *n) { A = *n; } // Asigna un nuevo valor a A
void setB(float *n) { B = *n; } // Asigna un nuevo valor a B
} par1;
void main() {
string *nombre = new string;
float *peso = new float;
cout << "Nombre : "; cin >> *nombre;

cout << "Peso : "; cin >> *peso;
//Registro en memoria estática sin punteros

par1.setA(nombre); cout << "\nNombre en memoria estática sin punteros: "
<< par1.getA() << endl;
par1.setB(peso); cout << "Peso en memeoria estática sin punteros: " <<
par1.getB() << endl;
//Registro en memoria estática con punteros

Par o1; //un objeto del struct
Par *a1;
a1 = &o1;
a1->setA(nombre);
a1->setB(peso);
cout << "\nNombre con punteros memoria estatica: " << a1->getA() << endl;
cout << "Peso con punteros memoria estatica: " << a1->getB() << endl;
//Registro en memoria dinámica

Par *a2 = new Par;
a2->setA(nombre);
a2->setB(peso);
cout << "\nNombre en memoria dinámica: " << a2->getA() << endl;
cout << "Peso en memoria dinámica: " << a2->getB() << endl;
}
Resultado
Nombre: Lucia
Peso: 50
Nombre en memoria estática sin punteros: Lucia

Peso en memoria estática sin punteros: 50
Nombre con punteros memoria estática: Lucia

Peso con punteros memoria estática: 50
Nombre en memoria dinámica: Lucia

Peso en memoria dinámica: 50
2.4 Struct de punteros y registros en memoria estática y
dinámica
En el ejemplo, los campos del struct pueden ser direcciones en memoria estática
o espacios en memoria dinámica. En este ejemplo, inicialemente los datos se
leen en espacios de la memoria dinámica para que después sean apuntados
desde los campos respectivos del struct. Las variables de registro pueden
declararse en memoria estática (con y sin punteros) y dinámica.
#include <iostream>
#include<string>
struct Par {
//Los campos en memoria estática
string *A;
float *B;
//Los campos en memoria dinámica
//string *A=new string;
//float *B=new float;
//Constructor
Par() {
A = NULL;
B = NULL;
}
//Destructor
~Par() {
delete A;
delete B;
}
string getA() { return *A; } // Devuelve el valor de A
int getB() { return *B; } // Devuelve el valor de B
void setA(string *n) { A = n; } // Asigna un nuevo valor a A
void setB(float *n) { B = n; } // Asigna un nuevo valor a B
} par1;

void main() {
//El registro par1 está en memoria estática
//Los valores de los campos (nombre y peso) serán apuntados desde los
campos del struct
string *nombre = new string;
float *peso = new float;
cout << "Escriba el nombre : "; cin >> *nombre;

cout << "Escriba el peso : "; cin >> *peso;
cout << "Registro en memoria estática : " << endl;

par1.setA(nombre); cout << "\nNombre : " << par1.getA() << endl;
par1.setB(peso); cout << "Peso : " << par1.getB() << endl;
cout << "Registro a1 en memoria estática con puntero: " << endl;
Par o1; //un objeto del struct Par
Par *a1;
a1 = &o1;
a1->setA(nombre);
a1->setB(peso);
cout << "\nNombre : " << a1->getA() << endl;
cout << "Peso: " << a1->getB() << endl;
cout << "Registro a2 en memoria dinámica : " << endl;

Par *a2 = new Par;
a2->setA(nombre);
a2->setB(peso);
cout << "\nNombre : " << a2->getA() << endl;
cout << "Peso : " << a2->getB() << endl;
}
Resultado
Escriba el nombre: Maria
Escriba el peso: 15
Registro en memoria estßtica:
Nombre: Maria
Peso: 15
Registro a1 en memoria estßtica con puntero:
Nombre: Maria
Peso: 15
Registro a2 en memoria dinámica:
Nombre: Maria
Peso: 15
3 SOLUCION DEL PROBLEMA

#include<iostream>
typedef struct Balon {

int px = 20;
int py = 13;
int velocidad = 2;
char letra = char(1);
Balon() {}
~Balon() {}
void setPx(int posx) { px = posx; }
void setPy(int posy) { px = posy; }

void setVelocidad(int vel) { velocidad = vel; }
void setLetra(char le) { letra = le; }
int getPx() { return px; }
int getPy() { return py; }
int getVelocidad() { return velocidad; }
char getLetra() { return letra; }
};
//Si se hace el intercambio de índices i y j, hay que pensar en la consola como
una matriz
void posicion(int x, int y)

{
Console::SetCursorPosition(y, x);
}
void pintaObjeto(Balon o)
{
posicion(o.getPx(), o.getPy());
cout << o.getLetra();
}
void borroObjeto(Balon o)
{
posicion(o.px, o.py);
cout << " ";
}
void main()
{
Random a;
int px = a.Next(10, 20);
int py = a.Next(5, 50);
int direccion = 1;
Balon balon1;
balon1.setPx(px);
balon1.setPy(py);
balon1.setLetra(char(3));
balon1.setVelocidad(3);
pintaObjeto(balon1);
while (true)
{ //borrar
borroObjeto(balon1);
//mover
if (balon1.px < 4 || balon1.px > 20) direccion = -1 * direccion;
balon1.px += balon1.velocidad*direccion;
//pintar
pintaObjeto(balon1);
_sleep(60);
}
system("pause>>NULL");
}
4 PROBLEMAS RESUELTOS
Resuelto 1. Escriba un progtam para gestionar un vector de registros de
tamaño t predefinido (agregar, imprimir y eliminar un registro), cada
registro u pbjeto representa una nave con posición en el eje X y Y. Use
las funciones que permitan gestionar cada campo del struct
correspondiente.

Código
#include<iostream>
struct Nave {
int px = 20;
int py = 13;
};
void agregaObjetoLista(Nave *&_naves, int &_t)

{
Nave nn;
for (size_t i = 0; i < _t; i++)
{
cout << "X: "; cin >> nn.px;
cout << "Y: "; cin >> nn.py;
_naves[i] = nn;
}
}
void pintaListaObjeto(Nave *_naves, int &_t)

{
for (int i = 0; i < _t; i++)
{
cout << _naves[i].px << " " << _naves[i].py << endl;
}
}
void quitaObjetoLista(Nave *_naves, int pos, int &_t)

{
for (size_t i = pos; i < _t - 1; i++)
{
_naves[i] = _naves[i + 1];
}
_t = _t - 1;
}
void main()
{
int t = 5;
cout << "Cantidad de naves: "; cin >> t;
Nave *naves = new Nave[t];
//agrega objetos
agregaObjetoLista(naves, t);
cout << endl;
pintaListaObjeto(naves, t);
//quITA ELEMENTO
int pos; //la ultima posicion es t-1
cout << "\nPosicion del elemento a quitar, menor que " << t << " : "; cin
>> pos;
if (pos < t)
{
quitaObjetoLista(naves, pos, t);
}
cout << endl;
}

Resultado
Cantidad de naves: 3
X: 10
Y: 15
X: 15
Y: 16
X: 10
Y: 18
10 15
15 16
10 18
Posicion del elemento a quitar, menor que 3: 2
10 15
15 16
Resuelto 2. Caída y regreso (rebote) de dos naves.
#include<iostream>
typedef struct Nave {

int px = 20;
int py = 13;
int velocidad = 2;
int color=2;
};
void posicion(int &x, int &y)

{
}
void pintaObjeto(Nave o)
{
Console::ForegroundColor = ConsoleColor(o.color);
cout << o.letra;
}
void borroObjeto(Nave o)
{
cout << " ";
}
void main()
{
Random a;
int px1 = a.Next(10, 20), px2 = a.Next(10, 20);
int py1 = a.Next(5, 50), py2 = a.Next(5, 50);
int color1 = a.Next(1, 15), color2 = a.Next(1, 15);
int direccion1 = 1, direccion2 = 1;
Nave nave1, nave2;
nave1.px = px1;

nave1.py = py1;
nave1.letra = char(3);
nave1.velocidad = 4;
nave1.velocidad = color1;
nave1.px = px2;
nave1.py = py2;
nave1.color = color2;
pintaObjeto(nave1);
pintaObjeto(nave2);
while (true)
{
borroObjeto(nave1);//borrar
//mover
if (nave1.px < 4 || nave1.px > 20) direccion1 = -1* direccion1;
nave1.px += nave1.velocidad*direccion1;
//pintar
pintaObjeto(nave1);
pintaObjeto(nave2);
_sleep(20);
}
}
Resuelto 3. Vector de objetos (cada objeto tiene los campos X y Y),

vector que crece dinámicamente. Los elementos se agregan hasta
que se le asigne 0 al atributo X. Se puede eliminar cualquier objeto del
vector mediante su posición.
#include<iostream>

int X = 20;
int Y = 13;
int velocidad = 2;
char letra = 'A';
};

{
}
{
posicion(o.X, o.Y);
cout << o.letra;
}

{
posicion(o.X, o.Y);
cout << " ";
}
Nave * agregaObjetoLista(Nave *_naves, Nave nn, int &_t)
{
Nave *tmp = new Nave[_t + 1];
for (size_t i = 0; i < _t; i++)
{
tmp[i] = _naves[i];
}
tmp[_t] = nn;
_t++;
return tmp;
}
void pintaListaObjeto(Nave *_naves, int &_t)

{
cout << "\nLista de objetos : ";
for (int i = 0; i < _t; i++)
{
cout << _naves[i].letra << " ";
}
}
Nave * quitaObjetoLista(Nave *_naves, int pos, int &_t)

{
Nave *tmp = new Nave[_t - 1];
for (size_t i = 0; i < pos; i++)
{
tmp[i] = _naves[i];
}
for (size_t i = pos; i < _t - 1; i++)
{
tmp[i] = _naves[i + 1];
}
_t = _t - 1;
return tmp;
}
void main()
{
int t = 0;
Nave *naves; naves = NULL;
//agrega objetos
while (true)
{
Nave on;
cout << "\nX: "; cin >> on.X;
if (on.X == 0) break;
cout << "Y: "; cin >> on.Y;
cout << "Letra: "; cin >> on.letra;
cout << "Velocidad: "; cin >> on.velocidad;
naves = agregaObjetoLista(naves, on, t);
}
//quita ELEMENTO
int pos; //la última posición es t-1
cout << "\nPosicion del elemento a quitar, menor que " << t << " : "; cin
>> pos;
if (pos < t)

{
naves = quitaObjetoLista(naves, pos, t);
}
cout << endl;
}
Resultado
X: 10
Y: 5
Letra: 2
Velocidad: 2
X: 15
Y: 16
Letra: 5
Velocidad: 2
X: 15
Y: 15
Letra: 6
Velocidad: 16
X: 0
Lista de objetos: 2 5 6
Posicion del elemento a quitar, menor que 3: 2
Lista de objetos: 2 5
Propuesto 1. Caída y regreso (rebote) de n objetos o registros, donde n
mayor de 10 y menor de 30.
Propuesto 2. Generar n objetos dentro las 10 primeras filas en movimiento
horizontal de ida y vuelta, debajo de la linea 10 debe moverse una
nave.
Propuesto 3. Generar n objetos dentro de las 10 primeras filas en
movimiento horizontal de ida y vuelta, debajo de la línea 10 debe
moverse una nave y disparar cierta cantidad de balas. El programa
finaliza cuando se hayan disparado todas las balas.
Propuesto 4. Generar n objetos sobre las 10 primeras filas en movimiento
horizontal de ida y vuelta, debajo de la línea 10 debe moverse una
nave y disparar cierta cantidad de balas. El programa finaliza cuando
se hayan disparado todas las balas o todos los objetos hayan sido
alcanzados.
Propuesto 5. Generar n objetos que represenan alienígenas sobre las 10
primeras filas en movimiento horizontal de ida y vuelta, los
estraterrestres disparan a una nave. Debajo de la línea 10 debe
moverse la nave y disparar cierta cantidad de balas para repeler el
ataque. El programa finaliza cuando se hayan disparado todas las

balas de la nave, todos los aliens hayan sido alcanzados o la nave
haya sido alcanzada por 15 veces.
6 INVESTIGACIÓN
de los aspectos más importantes del uso de funciones dentro de los structs.
7 EVALUACIÓN

Capítulo 24:
Introducción a los minijuegos
Resuelto 1. Caída de un objeto con huella
#include <iostream>
#include <conio.h>
{
}
void main()
{
Console::SetWindowSize(60, 30);
int x = 10; //inicio en x
int y = 17; //inicio en y
posicion(x, y);
cout << "*";
while (true)
{
x++;
posicion(x, y);
cout << "*";
_sleep(100);
}
}
Resuelto 2. Caída de un objeto sin huella v1

#include <iostream>
#include <conio.h>
{
}
void main()
{
posicion(x, y);
cout << "*";
while (true)
{ //borra
posicion(x, y);
cout << " ";
//mueve
x++;
posicion(x, y);
//pinta
cout << "*";

_sleep(100);
}
}
Resuelto 3. Caída de un objeto sin huella v2

#include <iostream>
#include <conio.h>
{
}
void borraBala(int &x, int &y)

{
posicion(x, y);
cout << " ";
}
void pintaBala(int &x, int &y)

{
posicion(x, y);
cout << 'X';
}
void main()
{
pintaBala(x, y);
while (true)
{
borraBala(x, y);
x++;
pintaBala(x, y);
_sleep(100);
}
}
Resuelto 4. Rebote de un objeto v1
#include <iostream>
#include <conio.h>
{
}
{
posicion(x, y);
cout << " ";
}

{
posicion(x, y);
cout << 'T';
}
void main()
{
pintaBala(x, y);
while (true)
{
borraBala(x, y);
x++;
if (x == 25) x = 0;
pintaBala(x, y);
_sleep(100);
}
}
Resuelto 5. Rebote de un objeto v2

#include <iostream>
#include <conio.h>
{
}
{
posicion(x, y);
cout << " ";
}

{
posicion(x, y);
cout << '*';
}
void main()
{
int f = 1; //controla la dirección del objeto adelante atrás
pintaBala(x, y);
while (true)
{
borraBala(x, y);
if (x < 3 || x > 23) f = -1 * f;
x += f;
pintaBala(x, y);
_sleep(50);
}

}
Resuelto 6. Structs: rebote de un objeto
#include<iostream>

int px = 20;
int py = 13;
int velocidad = 2;
};

{
}
{
cout << o.letra;
}
{
cout << " ";
}
void main()
{
Random a;
int px = a.Next(10, 20);
int py = a.Next(5, 50);
int direccion = 1;
Nave nave1;
nave1.px = px;
nave1.py = py;
pintaObjeto(nave1);
while (true)
{
//mover
if (nave1.px < 4 || nave1.px > 20) direccion = -1* direccion;
nave1.px += nave1.velocidad*direccion;
pintaObjeto(nave1); //pintar
_sleep(60);
}
}
Resuelto 7. Structs: rebote de dos objetos

#include<iostream>

int px = 20;
int py = 13;
int velocidad = 2;
int color = 2;
};

{
}
{
cout << o.letra;
}
{
cout << " ";
}
void main()
{
Random a;
int px1 = a.Next(10, 20), px2 = a.Next(10, 20);
int py1 = a.Next(5, 50), py2 = a.Next(5, 50);
int color1 = a.Next(1, 15), color2 = a.Next(1, 15);
int direccion1 = 1, direccion2 = 1;
Nave nave1, nave2;
nave1.px = px1;
nave1.py = py1;
nave1.velocidad = color1;
nave1.px = px2;
nave1.py = py2;
nave1.color = color2;
pintaObjeto(nave1);
pintaObjeto(nave2);
while (true)
{
borroObjeto(nave2);
//mover

//pintar
pintaObjeto(nave1);
pintaObjeto(nave2);
_sleep(20);
}
}
Resuelto 8. Pintar enemigos y mover nave

Los enemigos están pintados en la matriz en dos grupos, cada grupo en una fila.
La nave se manipula en la consola (el movimiento vertical se controla en Y y
movimiento horizontal en X.
#include <iostream>
#include <conio.h>
int matriz[20][40] =
{
{ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 },
{ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 },
{ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 },
{ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 },
{ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 },
{ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 },
{ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 },
{ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 },
{ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 },
{ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 },
{ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 },
{ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 },
{ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 },
{ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 },
{ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 },
{ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 },
{ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 },
{ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 },
{ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 },
{ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 },
};
int nave[2][3] = { {0,1,0},{1,1,1} };
void inicializaTablero()
{
Random r;
int i, c1, c2;
c1 = r.Next(8, 20);
c2 = r.Next(8, 30);
//LLENEMOS LA MATRIZ
//el primer grupo esta formado por c1 enemigos
//el primer grupo c2 enemigos
i = 3;
for (int j = 20 - c1 / 2; j < 20 + c1 / 2; j++)
matriz[i][j] = 3;
i = 4;
for (int j = 20 - c2 / 2; j < 20 + c2 / 2; j++)
matriz[i][j] = 4;
}
void dibujaTablero()
{
inicializaTablero();

Console::Clear();
Console::BackgroundColor = ConsoleColor::Black;
Console::ForegroundColor = ConsoleColor::Blue;
for (int i = 0; i < 20; i++)
{
for (int j = 0; j < 40; j++)
{
Console::ForegroundColor = ConsoleColor(matriz[i][j]);
if (matriz[i][j] == 1)
{
cout << (char)219;
}
else if (matriz[i][j] == 2)
{
cout << (char)169;
}
{
cout << (char)42;
}
{
cout << (char)248;
}
{
cout << (char)66;
}
else
{
cout << ' ';
}
}
cout << endl;
}
}

{
}
void pintaNave(int &x, int &y)
{
for (int i = 0; i < 2; i++)
{
for (int j = 0; j < 3; j++)
{
if (nave[i][j] == 1)
{
Console::ForegroundColor = ConsoleColor::DarkYellow;
posicion(i+x, j+y);
cout << char(219);
}
}
}
}
void despintaNave(int &x, int &y)
{
for (int i = 0; i < 2; i++)
{
for (int j = 0; j < 3; j++)

{
{
posicion(i + x, j + y);
cout << ' ';
}
}
}
}
void jugar(int &x, int &y)

{
int tecla;
pintaNave(x, y);
while(1)
{
if (kbhit())
{
tecla = getch();
despintaNave(x, y);
//mueve cuando se aplasta una tecla
switch (tecla)
{
case 75:
if (matriz[x][y-1] == 0)
y--; break;
case 77:
if (matriz[x][y+3] == 0)
y++; break;
}
pintaNave(x, y);
}
_sleep(100);
}
}
void main()
{
Console::SetWindowSize(40, 20); //ancho 40, alto 20
int x = 16;
int y = 20;
dibujaTablero();
jugar(x, y);
}
Resuelto 9. Pintar enemigos, mover nave y disparar a los enemigos desde

la nave.
Los enemigos están pintados en la matriz en dos grupos, cada grupo en una fila.
La nave se manipula en la consola (el movimiento horizontal en la consola se
controla en X y movimiento vertical en Y).
#include <iostream>
#include <conio.h>
int matriz[20][40] =
{

{ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 },
{ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 },
{ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 },
{ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 },
{ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 },
{ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 },
{ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 },
{ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 },
{ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 },
{ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 },
{ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 },
{ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 },
{ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 },
{ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 },
{ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 },
{ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 },
{ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 },
{ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 },
{ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 },
{ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 },
};
int nave[2][3] = { {0,1,0},{1,1,1} };
void inicializaTablero()
{
Random r;
int i, c1, c2;
c1 = r.Next(8, 20);
c2 = r.Next(8, 30);
//LLENEMOS LA MATRIZ
//el primer grupo esta formado por c1 enemigos
//el primer grupo c2 enemigos
i = 3;
for (int j = 20 - c1 / 2; j < 20 + c1 / 2; j++)
matriz[i][j] = 3;
i = 4;
for (int j = 20 - c2 / 2; j < 20 + c2 / 2; j++)
matriz[i][j] = 4;
}
void dibujaTablero()
{
inicializaTablero();
Console::Clear();
Console::ForegroundColor = ConsoleColor::Blue;
for (int i = 0; i < 20; i++)
{
for (int j = 0; j < 40; j++)
{
if (matriz[i][j] == 1)
{
cout << (char)219;
}
{
cout << (char)169;
}
{
cout << (char)42;
}
{
cout << (char)248;
}

{
cout << (char)66;
}
else
{
cout << ' ';
}
}
cout << endl;
}
}

{
}
void pintaNave(int &x, int &y)
{
for (int i = 0; i < 2; i++)
{
for (int j = 0; j < 3; j++)
{
{
posicion(i+x, j+y);
cout << char(219);
}
}
}
}
void despintaNave(int &x, int &y)
{
for (int i = 0; i < 2; i++)
{
for (int j = 0; j < 3; j++)
{
{
posicion(i + x, j + y);
cout << ' ';
}
}
}
}
void trasladaBala(int x, int y)
{
posicion(x,y);
cout << "*";
while (x>3)
{
posicion(x, y);
cout << " ";
x-=1;
posicion(x, y);
cout << "*";
_sleep(10);
}

posicion(x, y);
cout << " ";
}
void jugar(int &x, int &y)
{
int tecla;
pintaNave(x, y);
while(1)
{
if (kbhit())
{
tecla = getch();
despintaNave(x, y);
//mueve cuando se aplasta una tecla
switch (tecla)
{
case 75:
if (matriz[x][y-1] == 0)
y--; break;
case 77:
if (matriz[x][y+3] == 0)
y++; break;
case 'w':
trasladaBala(x, y);
break;
}
pintaNave(x, y);
}
_sleep(100);
}
}
void main()
{
Console::SetWindowSize(40, 20); //ancho 40, alto 20
int x = 16;
int y = 20;
dibujaTablero();
jugar(x, y);
}

Anexo 1:
Crear un proyecto en Visual
C++
Crear un proyecto con la plantilla general de

Visual C++
1.1 Archivo – nuevo – proyecto
1.2 Visual C++ - Proyecto vacío
Datos del proyecto
Nombre : nombre del proyecto
Ubicación : Carpeta donde se guardará el proyecto
Ejemplo ilustrativo

Nombre : prySuma
Ubicación : B:\cmas\
1.3 Archivo origen – agregar - nuevo elemento
1.4 Visual C++-Archivo C++

Datos del archivo *.cpp
Nombre : nombre del archivo *.cpp
Ubicación : Carpeta donde se encuentra el proyecto

previamente creado
Ejemplo ilustrativo
Nombre : suma.cpp
1.5 Ejemplo de un programa

Suma.cpp
#include<iostream>
int main()
{
int a = 10;
int b = 20;
int suma= a + b;
cout << "La suma es: "<<suma;
system("pause");
return 0;
}
Crear un proyecto con la plantilla clr de Visual

C++
2.1 Archivo – nuevo – proyecto
2.2 Visual C++ - Proyecto vacío

Datos del proyecto
Nombre : nombre del proyecto
Ubicación : Carpeta donde se guardará el proyecto
Ejemplo ilustrativo
Nombre : pryResta
2.3 Archivo origen – agregar - nuevo elemento

2.4 Visual C++-Archivo C++
Datos del archivo *.cpp
Nombre : nombre del archivo *.cpp
Ubicación : Carpeta donde se encuentra el proyecto

previamente creado
Ejemplo ilustrativo
Nombre : resta.cpp
2.5 Ejemplo de un programa

resta.cpp
#include<iostream>
int main()
{
int a = 10;
int b = 20;
int resta = a - b;
cout << "La resta es: " << resta;
system("pause");
return 0;
}

Anexo 2:
Operaciones comunes en
vectores
Operaciones en vectores
Las operaciones básicas en un arreglo unidimensional son: imprimir los datos, hallar el
menor o el mayor, hallar promedio, buscar un dato, ordenar los datos, entre otras
operaciones que las podemos implementar en un lenguaje usando funciones o
procedimientos.
En cada uno de los parámetros de las funciones tenemos Vector[ ] esto no varía si lo cambiamos por *Vector, en ambos
casos lo que se recibe es la dirección de un vector, este vector puede estar en memoria dinámica o estática.
#include<iostream>
#include<string>
#include<ctime>
1.1 Llena vector con números aleatorios
void llenaVector(int &tam, double Vector[])
{
srand(time(NULL));
for (int i = 0; i < tam; i++)
{
Vector[i] = 10 + rand() % 11;
}
}
1.2 Imprime datos del vector
void imprimeDatos(int &tam, double Vector[])
{
//Imprimiendo datos
{
cout << Vector[i] << " - ";
}
}
1.3 Halla el promedio en un vector
double calculaPromedio(int &tam, double Vector[])
{
double suma = 0.0;
{
suma = suma + Vector[i];
}
return suma / tam;
}
1.4 Halla el menor de un vector
double hallaMenor(int &tam, double Vector[])
{

double menor = Vector[0];
{
if (menor > Vector[i]) menor = Vector[i];
}
return menor;
}
1.5 Halla mayor de vector
double hallaMayor(int &tam, double Vector[])
{
double mayor = Vector[0];
{
if (mayor < Vector[i]) mayor = Vector[i];
}
return mayor;
}
1.6 Halla la moda
int hallaModa(int &tam, double Vector[])
{
int may = 0, moda = 0;
{
int ct = 0;
for (int j = 0; j < tam; j++)
{
if (Vector[i] == Vector[j]) ct++;
}
cout << Vector[i] << " " << ct << endl;
if (may < ct)
{
may = ct;
moda = Vector[i];
}
}
cout << "Moda: " << moda << " Repeticiones : " << may << endl;
return moda;
}
1.7 Busca dato e imprime su posición

void buscaDato(int &tam, double Vector[])
{
int busca, posicion;
cout << "\nDato que quieres buscar: ";
cin >> busca;
{
if (busca == Vector[i])
{
posicion = i;
break;
}
else posicion = -1;
}
if (posicion == -1) cout << "El dato buscado no está " << endl;
else cout << "El dato buscado esta en la pocisión: " << posicion << endl;

}
1.8 Ordena los datos del vector
void ordenaDatos(int &tam, double Vector[])
{
double temporal;
{
for (int j = 0; j < tam; j++)
{
if (Vector[i] < Vector[j])
{
temporal = Vector[i];
Vector[i] = Vector[j];
Vector[j] = temporal;
}
}
}
}
1.9 Gráfica un histograma
//Grafica histograma
void graficaHistograma(int &tam, double Vector[])
{
{
cout << Vector[i];
for (int j = 0; j < Vector[i]; j++)
{
cout << "*";
}
cout << endl;
}
}
1.10 Formamos dos grupos

void forma2Subgrupos(int &tam, double Vector[])
{
int ntam = tam / 2;
//double grupo[tam] // esto no es posible en la memoria estática
double *grupo1 = new double[ntam];
double *grupo2 = new double[ntam];
int i;
for (i = 0; i < ntam; i++)
{
grupo1[i] = Vector[i];
}
cout << "\nPRIMER GRUPO:" << endl;
cout << "EL menor :" << hallaMenor(ntam, grupo1) << endl;
cout << "EL mayor :" << hallaMayor(ntam, grupo1) << endl;
cout << "EL Promedio :" << calculaPromedio(ntam, grupo1) << endl;
for (int j = 0; j < ntam; j++)

{
grupo2[j] = Vector[j + ntam];
}
cout << "\nSEGUNDO GRUPO:" << endl;
cout << "EL menor :" << hallaMenor(ntam, grupo2) << endl;

cout << "EL mayor :" << hallaMayor(ntam, grupo2) << endl;
cout << "EL Promedio :" << calculaPromedio(ntam, grupo2) << endl;
}
1.11 Función principal
void main()
{
int *tama = new int;
cout << "Tamaño del vector: ";
cin >> *tama;
//crea el vector dinámico
double *Vector = new double[*tama];
llenaVector(*tama, Vector);
imprimeDatos(*tama, Vector);
cout << "\nRESUMEN DE DATOS " << endl;
cout << "El promedio es: " << calculaPromedio(*tama, Vector) << endl;
cout << "Menor : " << hallaMenor(*tama, Vector) << endl;
cout << "Mayor : " << hallaMayor(*tama, Vector) << endl;
cout << "\n--- Repeticiones --- " << endl;
cout << "Moda : \n" << hallaModa(*tama, Vector) << endl;
buscaDato(*tama, Vector);
graficaHistograma(*tama, Vector);
forma2Subgrupos(*tama, Vector);
cout << "\nDatos ordenados----" << endl;
ordenaDatos(*tama, Vector);
imprimeDatos(*tama, Vector);
cout << endl;
//libera vector
delete []Vector;
system("pause");
}

Anexo 3:
Operaciones básicas en
matrices
Operaciones básicas en matrices en C++

#include<iostream>
#include<ctime>
1.1 Crear matriz
//Crear los espacios de memoria dinámica
//el parámetro en la función es **&matriz
void creaMemoriaMatriz(int &cf, int &cc, double **&matriz)
{
while(true) {
cout << "Ingrese el cantidad de conductores : ";
cin >> cf;
if (cf > 10 && cf < 20) break;
}
while (true) {
cout << "Ingrese el cantidad de dias : ";
cin >> cc;
if (cc > 3 && cc <= 6) break;
}

{
}
}
1.2 Liberamos los espacio de memoria de la matriz

//Liberamos la memoria de la matriz
void liberaMemoriaMatriz(int &cf, int **matriz)
{
for (int i = 0; i < cf; i++)
{
delete[] matriz[i];
}
delete[] matriz;
}
1.3 Llena matriz con números aleatorios
//Registramos de numeros aleatorios en la matriz
void registraDatos(int &cFi, int cCol, int **mat) {
srand(time(NULL));

{
{
mat[i][j] = 5 + rand() % 6;
}
}
}
1.4 Imprime datos de la matriz
//Imprimimos datos de la matriz
void imprimeDatos(int &cFi, int cCol, int **mat) {
{
{
cout << mat[i][j] << "\t";
}
cout << endl;
}
}
1.5 Halla posición del mayor de la matriz
//Imprime el mayor de toda la matriz y su posición

void mayorDeLaMatriz(int &cFi, int cCol, int **mat)
{
int valormayor;
int posc, posf;
posc = posf = 0;
valormayor = mat[0][0];
for (int i = 0; i<cFi; i++)
for (int j = 0; j<cCol; j++)
if (mat[i][j]>valormayor)
{
valormayor = mat[i][j];
posc = j;
posf = i;
}
cout << "El mayor valor almacenado en la matriz es : " << valormayor <<
endl;
cout << "El dato se encuentra en fila= " << posf << " columna= " << posc
<< endl;
}
1.6 Halla menor en una fila dada
//Imprime el menor en una fila dada
void hallaMenorDeFila(int &nf, int cCol, int **mat)
{
int menor = mat[nf][0];
int posColumna;
{
if (menor>mat[nf][j])
{
menor = mat[nf][j];
posColumna = j;

}
}
cout << "Fila " << nf << " El menor : " << menor << " está en la columna:
"<<posColumna<<endl;
}
1.7 Halla mayor en una fila dada
//Imprime el mayor de una fila dada
void hallaMayorDeFila(int &nf, int &cCol, int **mat)
{
int mayor = mat[nf][0];
int posColumna;
{
if (mayor<mat[nf][j])
{
mayor = mat[nf][j];
posColumna=j;
}
}
cout << "Fila " << nf << " El mayor : " << mayor << " está en la columna:
" << posColumna << endl;
}
1.8 Halla suma en una fila dada
//Imprime el total de una fila dada

void sumaUnaFila(int &nf, int &cCol, int **mat)
{
int suma = 0;
{
suma += mat[nf][j];
}
cout << "Fila " << nf << " suma es : " << suma << endl;
}
1.9 Halla menor de una columna dada
//Imprime el menor de una columna dada
void hallaMenorDeColumna(int &nc, int &cFil, int **mat)
{
int menor = mat[0][nc];
int posFila;
{
if (menor>mat[i][nc])
{
menor = mat[i][nc];
posFila = i;
}
}
cout << "Columna " << nc << " El menor : " << menor << " está en la fila
"<< posFila<< endl;
}
1.10 Halla el mayor en una columna dada

//Halla el mayor de una columna dada
void hallaMayorDeColumna(int &nc, int &cFil, int **mat)
{
int mayor = mat[0][nc];
int posFila;
{
if (mayor<mat[i][nc])
{
mayor = mat[i][nc];
posFila = i;
}
}
cout << "Columna " << nc << " El mayor : " << mayor << " está en la fila
" << posFila << endl;
}
1.11 Halla suma en una columna dada
//Imprime el total de una columna dada
void sumaDeColumna(int &nc, int &cFil, int **mat)
{
int suma = 0;
{
suma += mat[i][nc];
}
cout << "Columna " << nc << " suma es : " << suma << endl;
}
1.12 Suma cada fila y halla el menor de cada fila
//Imprimimos el total de cada fila y hallamos el menor de cada fila
void sumaDeFilas(int &cFi, int cCol, int **mat) {
{
int suma = 0;
int menor = mat[i][0];
{
suma += mat[i][j];
if (menor>mat[i][j])
{
menor = mat[i][j];
}
}
cout << "Fila " << i << " sumas es : " << suma << " El menor : "
<< menor << endl;
}
}
1.13 Halla promedio de cada columna y halla el mayor
de cada columna
//Imprimimos el promedio de cada columna y hallamos el mayor de cada columna

void promedioDeColumnas(int &cFi, int cCol, int **mat) {
{

int suma = 0;
int mayor = mat[0][j];
{
suma += mat[i][j];
if (mayor<mat[i][j])
{
mayor = mat[i][j];
}
}
cout << "Columna " << j << " promedio es : " << (double)suma /
cFi << " El mayor : " << mayor << endl;
}
}
1.14 Separa espacios para la matriz
//Separa espacios para la matriz
void separaMemoriaMatriz(int &cf, int &cc, int **matriz)
{
for (int i = 0; i < cf; i++)
{
matriz[i]=new int[cc];
}
}
1.15 Uso de las funciones
//Función principal
void main()
{
int cf, cc;
do {
cout << "Ingrese cantidad de filas : ";
cin >> cf;
} while (cf > 10 || cf < 3);
int **matriz = new int*[cf]; //definimos la matriz
do {
cout << "Ingrese cantidad de columnas : ";
cin >> cc;
} while (cc > 10 || cc < 3);
separaMemoriaMatriz(cf, cc, matriz);

registraDatos(cf, cc, matriz);
imprimeDatos(cf, cc, matriz);
cout << "\nSumando filas" << endl;
sumaDeFilas(cf, cc, matriz);
cout << "\nPromedio columnas" << endl;
promedioDeColumnas(cf, cc, matriz);
cout << "\nMayor y su posición " << endl;
mayorDeLaMatriz(cf, cc, matriz);
cout << "\nHalla menor y mayor en una fila" << endl;

int nf = 2;
hallaMenorDeFila(nf, cc, matriz);
hallaMayorDeFila(nf, cc, matriz);
sumaUnaFila(nf, cc, matriz);
cout << "\nHalla menor y mayor en una columna" << endl;
int nc = 2;
hallaMenorDeColumna(nc, cf, matriz);
hallaMayorDeColumna(nc, cf, matriz);
sumaDeColumna(nf, cc, matriz);
liberaMemoriaMatriz(cf, matriz);
}

Anexo 4:
Operaciones en vectores de
registros
Operaciones básicas en vectores de registros

en C++
Algunas operaciones básicas en un vector unidimensional de registros son:
imprimir los datos, hallar el menor o el mayor, hallar promedio, buscar un dato,
ordenar los datos, ect; estos se escriben por comodidad usando funciones o
procedimientos. Algunas de esas operaciones las implementamos a
continuación.
#include<iostream>
#include<string>
#include<ctime>
2.6 Creamos la estructura
struct persona
{
int Dni;
string nombre;
char sexo;
string fecha;
int edad;
double peso;
string direccion;
};
//Creamos el vector de estructuras
int cantidad = 4;
//persona estudiante[4]; //En memoria estática
persona *estudiante = new persona[cantidad]; //En memoria dinámica
2.7 Cargamos los registros en el vector

void cargaDatos()
{
{
cout << "Dni : ";
cin >> estudiante[i].Dni;
cout << "Nombres : ";
getline(cin, estudiante[i].nombre);
cout << "Sexo : ";
cin >> estudiante[i].sexo;
cout << "Fecha : ";
cin >> estudiante[i].fecha;
cout << "Edad : ";

cin >> estudiante[i].edad;
cout << "Peso : ";
cin >> estudiante[i].peso;
cout << "Direccion : ";
getline(cin, estudiante[i].direccion);
}
}
2.8 Imprimimos los registros del vector
void muestraDatos()
{
cout << "Datos del vector de la fila : " << endl;
cout << "DNI\t " << "Nombre\t " << "Sexo\t " << "Fecha\t " <<
"Edad\t " << "Peso\t " << "Dirección\t " << endl;
{
cout << estudiante[i].Dni << "\t " << estudiante[i].nombre
<< "\t " << estudiante[i].sexo << "\t " << estudiante[i].fecha << "\t "
<< estudiante[i].edad << "\t " << estudiante[i].peso << "\t " <<
estudiante[i].direccion << endl;
}
}
2.9 Imprimimos el promedio de peso
void muestraPromedioPeso()
{
cout << "Promedio de peso : " << endl;
int sumaPeso=0;
{
sumaPeso += estudiante[i].peso;
}
cout << "Promedio: "<<(double)sumaPeso / cantidad<<endl;
}
2.10 Imprimimos el nombre del estudiante de mayor

edad
void muestraMayorEdad()
{
cout << "\nMayor edad : " << endl;
int mayor = estudiante[0].edad;
string quien;
{
if (mayor < estudiante[i].edad)
{
mayor = estudiante[i].edad;
quien= estudiante[i].nombre;
}
}

cout << "Mayor: " << mayor << " es "<< quien<<endl;
}
2.11 Imprimimos el nombre del estudiante de menor
edad
void muestraMenorEdad()
{
cout << "\nMenor edad : " << endl;
int menor = estudiante[0].edad;
string quien;
{
if (menor > estudiante[i].edad)
{
menor = estudiante[i].edad;
quien = estudiante[i].nombre;
}
}
cout << "Menor: " << menor << " es " << quien << endl;
}
2.12 Función principal
void main()
{
cargaDatos();
muestraDatos();
muestraPromedioPeso();
muestraMayorEdad();
muestraMenorEdad();
system("pause");
}

Anexo 5:
Manejar vectores y matrices
mediante funciones
Pasar una variable, vector o matriz a una

función
1.1 Indicaciones generales
A una variable declarada en la zona estática se les llama variable estática. Por
ejemplo:
int suma, *ptr;
Las variables suma y *ptr son variables estáticas, en la variable suma se
separa un espacio de memoria para almacenar algún valor entero, y en *ptr
también separamos un espacio de memoria estática para almacenar una
dirección de espacio de memoria o variable que estará en memoria estática
como dinámica.
Los variables punteros se definen en la memoria estática y sirven para apuntar
espacios en memoria estatica o dinámica
Una variable de tipo puntero se crea en la zona estática y sirve para

apuntar a un espacio en:
• La zona estática (int tam; int *ptr; ptr = &tam;)
• La zona dinámica (int *num; num = new int;).
Si apuntan a algún espacio en la zona dinámica se le llama variable
dinámica (*num es una variable dinámica).
Los espacios de memoria dinámica siempre se deben liberar después
usarlas con la instrucción delete (delete num;). En este apartado haremos un
estudio resumido de como pasar una variable, vector o matriz a una función
que se ha creado en zona estática y dinámica como argumento y como es que
la función la recibe como parámetro.
Tabla 1. Separación de memoria estática y dinámica
Memoria estática Memoria dinámica
Separando memoria int tam; int *ptr int *num

estática
Apuntando espacion ptr = &tam; num = new int;
variable o espacio de
memoria
1.2 Variable en zona estática sin puntero

En el ejemplo adjunto, pasamos la variable num. Lo recibimos en la variable
numero por valor o por referencia (con dirección &numero, o indirección

*numero). Las variables se reciben según como se envía, o se hace el envío
según como queremos recibirlas. Se cumple que:
1) Si se envía un valor que está en un espacio, éste se puede recibir por

valor. Si envío un 15, entonces lo recibo en la variable numero.
2) Si se envía un valor mediante una variable estática, éste se recibe por
valor. Si envío num (num=15), entonces se recibe en la variable numero.
3) Si se envía un valor mediante una variable estática, éste se recibe por
dirección (referencia). Si envío num (num=15), entonces se recibe la
dirección con la variable &numero.
4) Si se envía la dirección de un espacio de memoria, éste se recibe por
indirección (puntero). Si envío &num (num=15), entonces recibo la
indirección con la variable *numero.
Nos proponemos:
✓ Modificar el valor de la variable num desde la función recibeDatos(int

numero) para ver si cambia o no su valor en la función principal.
✓ Estudiar que dada una manera de enviar el valor o posición de una
variable existe una manera de recibirla.
Parámetro por valor

#include<iostream> void main()
using namespace std; {
void recibeDatos(int numero) int num = 100;
{ recibeDatos(num);
int suma; cout << num; //num 100
suma = numero + 50; system("pause");
cout << suma; }
numero = 200;
}
Parámetro por referencia (por dirección)
void recibeDatos(int &numero) int num = 100;
{ recibeDatos(num);
suma = numero + 50; system("pause");
cout << suma; }
numero = 200;
}
Parámetro por referencia (por indirección)
void recibeDatos(int *numero) int num = 100;
{ recibeDatos(&num);
suma = *numero + 50; system("pause");
cout << suma; }
*numero = 200;
}
1.3 Variable num en zona estática apuntada

Apuntada por valor
void recibeDatos(int numero) int num=100;
{ int *ptr;
int suma; ptr = &num;
suma = numero + 50; recibeDatos(*ptr);
cout << suma<<endl; cout << num; //num 100
numero = 200; system("pause");
} }
Apuntada por referencia (dirección)
void recibeDatos(int &numero) int num=100;
{ int *ptr;
int suma; ptr = &num;
suma = numero + 50; recibeDatos(*ptr);
cout << suma<<endl; cout << num; //num 200
} }
Apuntada por referencia (indirección)
void recibeDatos(int *numero) void main()
{ {
int suma; int num=100;
suma = *numero + 50; int *ptr;
cout << suma<<endl; ptr = &num;
*numero = 200; recibeDatos(ptr);
} cout << num; //num 200
system("pause");
}
1.4 Variable num en zona dinámica
Dinámica por valor7
int filas, columnas; int *num = new int;
void recibeDatos(int numero) *num = 100;
{ recibeDatos(*num);
int suma; cout << *num << endl; //100
suma = numero + 50; cout << num << endl; //dirección
cout << suma << endl; de num
numero = 200; delete num; //libera memoria
} system("pause");
}
7 Si se envía el valor que está en un espacio de memoria, éste se recibe por valor

Dinámica por referencia (dirección)8
void recibeDatos(int &numero) *num = 100;
{ recibeDatos(*num);
suma = numero + 50; cout << num << endl; //dirección
} delete num; //lera memoria
system("pause");
}
Dinámica por referencia (indirección)9

void recibeDatos(int *numero) *num = 100;
{ recibeDatos(num);
suma = *numero + 50; cout << num << endl; //direccion
*numero = 200; delete num; //libera memoria
} system("pause");
}
1.5 Vector num en zona estática
Cuando se envía como argumento el nombre de un vector, el parámetro de una
función que lo recibe es la dirección del vector (nombreVector[ ] ó
*nombreVector).
Agumento en la zona estática por valor

void recibeDatos(int vnum[]) int num[] = { 10,20,30 };
{ recibeDatos(num);
int suma; cout << num[2] << endl; //200
suma = vnum[2] + 50; cout << num << endl; //dirección de num
cout << suma << endl; //80 system("pause");
vnum[2] = 200; }
}
Argumento en la zona estática por referencia (dirección)
8Si se envía el valor que está en un espacio de memoria, éste se recibe por
dirección (referencia)
9 Si se envía la dirección de un espacio de memoria, éste se recibe por
indirección (puntero)

{ recibeDatos(&num[3]);
suma = vnum[2] + 50; cout << num << endl; //dirección de num
vnum[2] = 200; }
}
Argumento en zona estática por referencia (indirección)
void recibeDatos(int *vnum) int num[] = { 10,20,30 };
{ recibeDatos(num);
suma = vnum[2] + 50; cout << num << endl; //direccion de num
vnum[2] = 200; }
}
1.6 Vector num apuntado en zona estática
No es necesario el uso de un puntero para manejar un vector. Solo sirve para
manejar direcciones en la memoria que ocupa el vector. No es posible enviar
como argumento los valores de un vector (*ptr). Sólo se puede enviar la
dirección (ptr).
Vector apuntado en zona estática por valor

{ int *ptr;
int suma; ptr = &num[3]; //ptr = &num[]//ptr = &num
suma = vnum[2] + 50; recibeDatos(ptr);
cout << suma << endl; cout << num[2] << endl; //30
//Direccion X cout << ptr[2] << endl;//200
cout << num << endl; //direccion de num
vnum[2] = 200;
system("pause");
}
}
Vector apuntado en zona estática por referencia (dirección)
Los vectores no se reciben por referencia de dirección
Vector apuntado en zona estática por referencia (indirección)
void recibeDatos(int *vnum) int num[] = { 10,20,30 };
{ int *ptr;
int suma; ptr = &num[3]; //ptr = &num[]//ptr = &num
suma = vnum[2] + 50; recibeDatos(ptr);
//Direccion X cout << num << endl; //direccion de num
vnum[2] = 200; system("pause");
} }
1.7 Vector num en zona dinámica
En zona dinámica por valor
using namespace std; void main()
int filas, columnas; {
void recibeDatos(int vnum[]) int tam = 3;

{ int *num = new int[tam];
int suma; num[2] = 100;
suma = vnum[2] + 50; recibeDatos(num);
vnum[2] = 200; delete[] num;
} system("pause");
}
En zona dinámica por referencia (dirección)
En zona dinámica por referencia (indirección)
using namespace std; void main()
int filas, columnas; {
void recibeDatos(int *vnum) int tam = 3;
{ int *num = new int[tam];
int suma; num[2] = 100;
suma = vnum[2] + 50; recibeDatos(num);
vnum[2] = 200; delete[] num;
} system("pause");
}
1.8 Estructura Persona en zona estática
Una estructura es un tipo de vector que almacena datos de diferente tipo
En la zona estática por valor
#include<string> {
using namespace std; Persona persona;
typedef struct Persona { recibeDatos(persona);
int dni; system("pause");
string nombre; }
double peso;
};
void recibeDatos(Persona p)
{
p.dni = 12451284;
p.nombre = "Juan";
p.peso = 60.78;
cout << p.dni<<endl;
cout << p.nombre<<endl;
cout << p.peso<<endl;
}
En la zona estática por referencia (dirección)
#include<string> {
int dni; cout << persona.dni<<endl;
string nombre; cout << persona.nombre<<endl;
double peso; cout << persona.peso<<endl;
}; system("pause");
void recibeDatos(Persona &p) }
{
p.dni = 12451284;
p.nombre = "Juan";

p.peso = 60.78;
En zona estática por referencia (indirección)

#include<string> {
typedef struct Persona { recibeDatos(&persona);
int dni; cout << persona.dni<<endl;
string nombre; cout << persona.nombre<<endl;
double peso; cout << persona.peso<<endl;
}; system("pause");
void recibeDatos(Persona *p) }
{
p->dni = 12451284;
p->nombre = "Juan";
p->peso = 60.78;
}
1.9 Struct apuntados

No tiene tanta aplicación
1.10 Struct Persona en zona dinámica

Cuando se asigna espacios dinámicos a una variable, no es posible enviarla por
dirección algo asi &persona, dado que en Persona *persona=new Persona, persona
ya es la dirección del espacio de memoria en la zona dinámica.
En la zona dinámica por valor
#include<string> {
using namespace std; Persona *persona=new Persona;
typedef struct Persona { recibeDatos(*persona);
int dni; cout << persona->dni<<endl;
string nombre; //Direccion X
double peso; system("pause");
}; }
void recibeDatos(Persona p)
{
p.dni = 12451284;
p.nombre = "Juan";
p.peso = 60.78;
cout << p.dni<<endl;
cout << p.nombre<<endl;
cout << p.peso<<endl;
}
En la zona dinámica por referencia (dirección)
#include<string> {
typedef struct Persona { recibeDatos(*persona);
string nombre; //12451284
}; }

void recibeDatos(Persona &p)
{
p.dni = 12451284;
p.nombre = "Juan";
p.peso = 60.78;
}

#include<string> {
string nombre; //12451284
}; }
void recibeDatos(Persona *p)
{
p->dni = 12451284;
p->nombre = "Juan";
p->peso = 60.78;
}
1.11 Vector de registros Persona en zona estática

También se pueden crear vectores de estructuras. Se usan las estructuras para
definir un conjunto de datos de diferente tipo. Se puede crear un vector de
estructuras para almacenar un conjunto de datos.
En la zona estática por valor
#include<string> {
using namespace std; Persona persona[3];
int dni; cout << persona[1].dni<<endl;
string nombre; cout << persona[1].nombre<<endl;
double peso; cout << persona[1].peso<<endl;
}; system("pause");
void recibeDatos(Persona p[]) }
{
p[1].dni = 12451284;
p[1].nombre = "Juan";
p[1].peso = 60.78;
}
En la zona estática por referencia (dirección) - NO
#include<string> {
using namespace std; Persona persona[3];
int dni; cout << persona[1].dni<<endl;
string nombre; cout << persona[1].nombre<<endl;
double peso; cout << persona[1].peso<<endl;
}; system("pause");
void recibeDatos(Persona *p) }
{

p[1].dni = 12451284;
p[1].peso = 60.78;
}
1.12 Vector de registros Persona apuntada en la zona
estática
Lo dejamos más adelante, no tiene tanta aplicación para manejar valores de
una estructura pero si para direcciones.
1.13 Vector de struct Persona en la zona dinámica

En la zona dinámica por valor
#include<string> {
using namespace std; int tam = 3;
typedef struct Persona { Persona *persona=new Persona[tam];
int dni; recibeDatos(persona);
string nombre; cout << persona[1].dni<<endl;
double peso; cout << persona[1].nombre<<endl;
}; cout << persona[1].peso<<endl;
void recibeDatos(Persona p[]) system("pause");
{ }
p[1].dni = 12451284;
p[1].peso = 60.78;
}
En la zona dinámica por referencia (dirección) -NO
#include<string> {
using namespace std; int tam = 3;
typedef struct Persona { Persona *persona=new Persona[tam];
int dni; recibeDatos(persona);
string nombre; cout << persona[1].dni<<endl;
double peso; cout << persona[1].nombre<<endl;
}; cout << persona[1].peso<<endl;
void recibeDatos(Persona *p) system("pause");
{ }
p[1].dni = 12451284;
p[1].peso = 60.78;
}

1.14 Matriz num estática
En zona estática por referencia por valor
void recibeDatos(int mnum[4][3]) int num[4][3] = { {1,2,3},{ 3,4,5 },{ 6,7,8
{ },{ 9,10,11 } };
mnum[1][1] = 12451284;
} recibeDatos(num);
cout << num[1][1]<<endl;//12451284
system("pause");
}
En zona estática por referencia (dirección)
No es posible
No es posible
1.15 Matriz num apuntada
No son necesarias, las matrices ya están apuntadas
1.16 Matriz num dinámica

En zona dinámica por referencia por valor
int filas, columnas; filas = 4;
void recibeDatos(int **mnum) columnas = 3;
{ int **num; //crea variable matriz
mnum[1][1] = 12451284; num = new int*[filas]; //asigmamos
} espacios a las filas
void liberarMemoria(int **mnum) for (size_t i = 0; i < filas; i++)
{ {
for (size_t i = 0; i < filas; num[i] = new int[columnas];
i++) }
{
delete[] mnum[i]; recibeDatos(num);
} cout << num[1][1]<<endl;//12451284
delete[] mnum; liberarMemoria(num); //liberamos la
} memoria
system("pause");
}
En zona dinámica por referencia (dirección)
No es posible
No es posible

1.17 Errores y casos especiales en vectores
Importante: Compila porque un vector es un puntero de variables. El primer valor al que
apunta el vector num es a 10. *vnum tiene el primer elemento del vector.
void recibeDatos(int vnum[]) int num[] = {10,20,30};
{ recibeDatos(num);
suma = *vnum + 50; cout << num<<endl; //dirección de num
cout << suma<<endl; //60 system("pause");
*vnum = 200; }
}
No se puede pasar un vector desde la zona estática por referencia (dirección), no compila
porque en C++ no puede existir un vector de referencias.
void recibeDatos(int &vnum[]) int num[] = {10,20,30};
{ recibeDatos(num);
int suma; cout << num[2] << endl;
suma = vnum[2] + 50; cout << num<<endl;
cout << suma<<endl; system("pause");
vnum[2] = 200; }
}

Anexo 6:
Guía rápida de PSeInt
En esta guía rápida abordamos todos los aspectos importantes de la escritura

de pseudocódigo, desde la declaración de variables, manejo de vectores, uso
de funciones del y procedimientos pseudolenguaje y de cración del usaurio.
Declarar variables
Dimension Prec[5], Cant[4,5]
Definir apellido Como Caracter
Secuencial
Proceso ejemploSecuencial
Definir amigo Como Caracter
Escribir "Escriba el nombre"
Leer amigo
Escribir "Hola apreciado ", amigo
FinProceso
Selección simpe
Proceso ejemploSeleccionSimple
Definir edad Como Entero
Escribir "Dame tu edad "
Leer edad
si edad<18 Entonces
Escribir "Usted es menor de edad "
FinSi
FinProceso
Selección doble
Proceso ejemploSeleccionDoble
Definir a, b Como Entero
Escribir "Dame el valor de a "
Leer a
Escribir "Dame el valor de b "
Leer b
si a>b Entonces
Escribir "El número mayor es ", a
SiNo
Escribir "El número mayor es ", b
FinSi
FinProceso
Selección múltiple
Proceso ejemploSeleccionMultiple
Definir numeroDia Como Entero
Escribir "Escriba un número entre 1 y 7";
Leer numeroDia
Segun numeroDia Hacer
1:
Escribir "Is Friday"
2:

Escribir "Is Saturday"
3:
Escribir "Is Sunday"
De Otro Modo:
Escribir "Uf no es fin de semana"
Fin Segun
FinProceso
Para
Proceso ejemploPara
Escribir 'Dame el valor de u '
Leer u
Para n<-1 Hasta u Hacer
Escribir n
FinPara
FinProceso
Mientras
Escribir "dame el valor de u "
Leer u
n=-1
Mientras n!=0 Hacer
Leer n
Fin Mientras
FinProceso
Repetir
Proceso ejemploRepetir
Escribir "Dame el valor de u "
Leer u
n=-1
Repetir
Leer n
Hasta Que n!=0
FinProceso
Funciones
SubProceso resultado <- hallaValor(vala,valb,vald)
FinSubProceso
Leer a
Leer b
Leer c;


FinProceso
Procedimientos
SubProceso hallaValor(vala,valb,vald)
Escribir resultado
FinSubProceso
Leer a
Leer b
Leer c;
discriminante= rc(discriminante)
Escribir "La primera raiz es: "
hallaValor(a, b, discriminante);
Escribir "La segunda raiz es: "
hallaValor(a, b, -discriminante);
FinProceso
Expresiones coloquiales
EXPRESIÓN SIGNIFICADO
X es Y X=Y
x es igual a Y X=Y
X es distinto de Y X<>Y
X es CERO X=0
X es POSITIVO X>0
X es NEGATIVO X<0
X es PAR X MOD 2 = 0
X es IMPAR X MOD 2 = 1
X es MULTIPLO de Y X MOD Y = 0
X es DIVISIBLE por Y X MOD Y = 0
Operadores
Operador Significado Ejemplo
Relacionales
> Mayor que 3>2
< Menor que 'ABC'<'abc'

= Igual que 4=3
<= Menor o igual que 'a'<='b'
>= Mayor o igual que 4>=5
<> Distinto que 'a'<>'b'
Lógicos
&óY Conjunción (y). (7>4) & (2=1) //falso
|óO Disyunción (o). (1=1 | 2=1) //verdadero
~ ó NO Negación (no). ~(2<5) //falso
Algebraicos
+ Suma total <- cant1 + cant2
- Resta stock <- disp - venta
* Multiplicación area <- base * altura
/ División porc <- 100 * parte / total
^ Potenciación sup <- 3.41 * radio ^ 2
% ó MOD Módulo (resto de la división resto <- num MOD div
entera)
Funciones de PSeInt
FUNCIÓN SIGNIFICADO
RC(X) o RAIZ(X) Raíz Cuadrada de X
ABS(X) Valor Absoluto de X
LN(X) Logaritmo Natural de X
EXP(X) Función Exponencial de X
SEN(X) Seno de X
COS(X) Coseno de X
TAN(X) Tangente de X
ASEN(X) Arcoseno de X
ACOS(X) Arcoseno de X
ATAN(X) Arcotangente de X
TRUNC(X) Parte entera de X
REDON(X) Entero más cercano a X
AZAR(X) Entero aleatorio en el rango [0;x-1]
ALEATORIO(A,B) Entero aleatorio en el rango [A;B]
LONGITUD(S) Cantidad de caracteres de la cadena S
MAYUSCULAS(S) Retorna una copia de la cadena S con todos sus
caracteres en mayúsculas
MINUSCULAS(S) Retorna una copia de la cadena S con todos sus
caracteres en minúsculas
SUBCADENA(S,X,Y) Retorna una nueva cadena que consiste en la parte
de la cadena S que va desde la posición X hasta la
posición Y (incluyendo ambos extremos). Las
posiciones utilizan la misma base que los arreglos, por
lo que la primera letra será la 0 o la 1 de acuerdo al
perfil del lenguaje utilizado.

CONCATENAR(S1,S2) Retorna una nueva cadena resulta de unir las
cadenas S1 y S2.
CONVERTIRANUMERO(X) Recibe una cadena de caracteres que contiene un
número y devuelve una variable numérica con el
mismo.
CONVERTIRATEXTO(S) Recibe un real y devuelve una variable numérica
con la representación como cadena de caracteres
de dicho real.

Anexo 7:
Juegos
Resuelto 1 Simular disparos desde una nave

Enunciado
Una nave de moverse (trasladarse) de izquierda a derecha y viceversa, cuando se

pulse la tecla tab debe simular el disparo de una bala. La nave solo cuenta con cierta
cantidad de balas, es decir cuando se terminen las balas ya no podrá disparar.
Código
#include<iostream>
#include<string>
#include<Windows.h>
#include<conio.h>

int dxNave = 3;
int dyNave = 3;
int dybala = 2; //salto de la bala
typedef struct {
int xbala;
int ybala;
int color;
int velocidad; //sleep para la bala
}Bala;
void gotoXY(int x, int y)

{
}
void borraBala(Bala *cacerina, int cual)

{
gotoXY(cacerina[cual].xbala, cacerina[cual].ybala);
cout << " ";
}
void mueveBala(Bala *cacerina, int cual)

{
if (cacerina[cual].ybala > 5) cacerina[cual].ybala = cacerina[cual].ybala -
dybala;
}
void pintaBala(Bala *cacerina, int cual)

{

gotoXY(cacerina[cual].xbala, cacerina[cual].ybala);
Console::ForegroundColor = ConsoleColor(cacerina[cual].color);
cout << "B";
}
void llenaCacerina(Bala *cacerina, int cbalas) {

Random ra;
for (int i = 0; i < cbalas; i++)
{
cacerina[i].velocidad = 20;
cacerina[i].color = ra.Next(4, 15);
}
}
void borraNave(int x, int y)

{
gotoXY(x, y);
cout << " ";
}
void mueveNaveI(int &x, int &y)
{
if (x > 5 ) x = x - dxNave;
}
void mueveNaveD(int &x, int &y)
{
if (x < 60) x = x + dxNave;
}
void mueveNaveT(int &x, int &y)
{
if (y> 5) y = y - dyNave;
}
void mueveNaveA(int &x, int &y)
{
if (y < 30) y = y + dyNave;
}
void pintaNave(int x, int y)
{
gotoXY(x, y);
Console::ForegroundColor = ConsoleColor((int)10);
cout << "N";
}
void main()
{
int tecla;
int cbalas = 10, cual = 0;

Bala *cacerina = new Bala[cbalas];
llenaCacerina(cacerina, cbalas);
int xnave = 10, ynave = 20;
pintaNave(xnave, ynave);
while (true)
{
if (kbhit())

{
borraNave(xnave, ynave);
tecla = getch();
switch (tecla)
{
case 9: //tab
if (cual < 10)
{
cacerina[cual].xbala = xnave;
cacerina[cual].ybala = ynave;
pintaBala(cacerina, cual);
while (true)
{
borraBala(cacerina, cual);
mueveBala(cacerina, cual);
pintaBala(cacerina, cual);
if (cacerina[cual].ybala < 5) break;
_sleep(cacerina[cual].velocidad);
}
cual++;
}
break;
//traslado de la nave por teclado
case 72: //arriba
mueveNaveT(xnave, ynave);
break;
case 80: //abajo
mueveNaveA(xnave, ynave);
break;
case 75: //izquierda
mueveNaveI(xnave, ynave);
break;
case 77: //derecha
mueveNaveD(xnave, ynave);
break;
}
pintaNave(xnave, ynave);
}
_sleep(100);
}
delete[] cacerina;
_getch();
}

Resuelto 2 Juego Alien
Enuciado
Se le solicita implementar la inicialización de un juego en C++ utilizando: Funciones,

matrices, números aleatorios, paso de parámetros por valor o por referencia.
Características del juego:
• El área del juego es una matriz de tamaño 30x30

• Debe haber 5 grupos de alienígenas diferenciados por color y un carácter
cualquiera que representa al grupo.
• La cantidad de elementos en cada grupo es aleatoria en el rango permitido
del área de juego.
• Los dos primeros grupos ocuparán 3 filas cada grupo
• El tercer grupo ocupará una sola fila
• El cuarto y quinto grupo ocuparán 2 filas cada grupo
• La nave defensora es un conjunto de un mismo carácter cualquiera.
• La nave defensora se mueve de izquierda a derecha y viceversa sin salir del
área de juego
• La posición inicial x de la nave se proporcionará desde el teclado, por tanto, x
debe estar validado en el rango: 3 < x < 27 (garantiza que está dentro del área
de juego en horizontal)
• La posición inicial y de la nave se proporcionará desde el teclado, por tanto,
y debe estar validado en el rango 15 < y < 27 (garantiza que está en la parte
mitad de la parte abajo del área del juego observando verticalmente).

Pseudocódigo
pintaMarco(){ pintaAliens(){
} }
generaAliens(){ borraNave(){
} }
pintaAlien(){ saltaNaveI(){
} x--;
} }
saltaNaveD(){ pintaNave(){
x++;
si(tecla==’I’) entonces
saltaNaveD();
}
si (tecla==’D’) entonces
trasladaNave()
saltaNaveD();
{
pintaNave();
borraNave();
}
principal(){
pintaMarco();
Mientras
trasladaNave();
Fin mientras
Diagrama de flujo o modulos
¿?
Código
#include<iostream>
#include <stdlib.h>
#include<conio.h>
#include<time.h>

#define IZQUIERDA 75
#define DERECHA 77
#define FILAS 30
#define COLUMNAS 30
struct Alien {
int x;
int y;
int color;
int caracter;
};
void gotoXY(int x, int y) {
}
void pintaAlien(int &pif, int cf)
{
Alien at;
at.caracter = rand() % 60 + 20;
at.color = rand() % 10 + 3;
int cantidad = rand() % 10 + 10;
at.y = pif;
at.x = 15 - cantidad / 2;
for (int i = at.y; i < at.y+cf; i++)
{
for (int j = at.x; j < at.x+cantidad; j++)
{
gotoXY(j, i);
Console::ForegroundColor = ConsoleColor(at.color);
cout << char(at.caracter);
}
}
pif = pif + cf;
}
void cargaMatriz(int **matriz) {

for (int i = 0; i < FILAS; i++)
{
for (int j = 0; j < COLUMNAS; j++)
{
if (i==0 || i==29 || j==0 || j==29) matriz[i][j] = 1;
else matriz[i][j] = 0;
}
}
}
void pintaMatriz(int **matriz)
{
{
for (int j = 0; j < COLUMNAS; j++)
{
gotoXY(i,j);
cout << char(5);
}
}

}
void pintaNave(int &x, int &y) {

Console::ForegroundColor = ConsoleColor::DarkGray;
gotoXY(x, y);
cout << "W";
gotoXY(x - 1, y + 1);
cout << "WWW";
}
void borraNave(int &x, int &y) {
gotoXY(x, y);
cout << " ";
gotoXY(x - 1, y + 1);
cout << " ";
}
void mueveNaveI(int &x, int &y)
{if(x>3) x = x-2;
}
void mueveNaveD(int &x, int &y)
{
if (x<26) x = x+2;
}
void main() {
srand(time(NULL));
int x;
int y;
do {
cout << "digite la posicion x de la nave : ";
cin >> x;
} while (!(x > 3 && x < 27));
do {
cout << "digite la posicion y de la nave : ";
cin >> y;
} while (!(y > 15 && y < 27));
//matriz de fondo
int **matriz = new int *[FILAS];
{
matriz[i] = new int[COLUMNAS];
}
Console::Clear();
int pif = 5;
cargaMatriz(matriz);
pintaMatriz(matriz);
pintaAlien(pif, 1);
pintaAlien(pif, 2);
pintaAlien(pif, 1);
pintaNave(x,y);
while (1) {
Console::CursorVisible = false;
borraNave(x,y);
if (_kbhit())

{
char tecla = _getch();
switch (tecla)
{
case DERECHA:
mueveNaveD(x,y);
break;
case IZQUIERDA:
mueveNaveI(x, y);
break;
}
}
pintaNave(x, y);
_sleep(50);
}
getch();
}
PROPUESTO
Propuesto 1. Simular disparos (algunos en forma vertical otros en
diagonal) desde una nave, las balas disparadas tienen diferentes colores (se
sugiere que los colores sean asignados a cada bala aleatoriamente). La
nave de moverse (trasladarse) de izquierda a derecha y viceversa, cuando
se pulse la tecla tab debe simular el disparo. La nave solo cuenta con cierta
cantidad de balas, es decir cuando se terminen las balas ya no podrá
disparar.

BIBLIOGRAFÍA
Deitel, P. J. & Deitel, H. M. (2008). Como programar en Java, 6ta edición. Pearson
Educación: México.
C++ con clase (29 de oct. de 19). Obtenido de

http://c.conclase.net/curso/?cap=017#inicio
Laza, R. y García, B. (2008). Metodología y tecnología de la programación.

Pearson Educación: México.
Mañas, J. A. (2010). Java vademécum. Departamento de Ingeniería de Sistemas

Telemáticos, Universidad Politécnica Madrid, España.
Pinales, F. J. & Velásquez, C. E. (2014). Algoritmos resueltos con diagramas de

flujo y pseudocódigo. Aguas Calientes, México: Universidad Autónoma
de Aguascalientes.
UPC (2019). Presentaciones y hojas de práctica del curso de Programación I.

Facultad de Ingeniería, Universidad Peruana de Ciencias Aplicadas.

Cuaderno de C++

Cargado por

Copyright:

Formatos disponibles

Cuaderno de C++

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Cuaderno de C++

Cargado por

Copyright:

Formatos disponibles

Apuntes prácticos de

Abraham Sopla Maslucán

A manera de resumen, expreso que este documento

Para ver una copia de dicha licencia, visite:

Sugerencias para la mejora del documento las

Abraham Sopla Maslucán P á g i n a 4 | 362

Iteraccion del usuario con la consola:

Computadora escribe : dame el valor del ancho

1.2 Cuestiones relacionadas al problema

o Los procesos y/o cálculos

• ¿Cuál es la forma mas adecuada para representar el conjunto de pasos o

Abraham Sopla Maslucán P á g i n a 5 | 362

Entradas Procesos y cálculos Salidas

largo, ancho area

1.4 Cuestiones teóricas

2.2 Algoritmo y sus características

Definición 1: Un algoritmo es un conjunto de pasos a seguir para resolver problema de

Definición 2: Un algoritmo es el proceso de descomponer una tarea en forma

Abraham Sopla Maslucán P á g i n a 6 | 362

Entrada Proceso de datos o Impresión de

Definición 3: Matemáticamente puede pensarse que un algoritmo es una secuencia

Previamiente a la obtención del modelo f(x,y), el analista de sistemas interpretó un

• Debe ser preciso e indicar un orden de realización de cada paso.

2.3 Análisis del problema

Al declarar las variables es importante se tenga en cuenta los nombres de las

Tipo de datos Nombre de las variables con Descripción de cada una

MEPS: Matriz de entrada, proceso y salidas

Abraham Sopla Maslucán P á g i n a 7 | 362

Entradas Procesos y cálculos (instrucciones y Salidas

2.5 Diagrama de flujo de datos

2.5.1 Elementos de un diagrama de flujo de datos

Proceso Representa cualquier tipo de operación que pueda

Conector Sirve para conectar partes de un diagrama en una

Abraham Sopla Maslucán P á g i n a 8 | 362

Indicador de Indica el sentido de ejecución de las operaciones.

Conector Conexión entre dos puntos situados en páginas

subrutina Se puede usar para indicar la llamada a una

Pantalla Se puede utilizar en lugar del símbolo de salida.

Teclado Se puede utilizar en lugar del símbolo de entrada.

2.6 Diagrama de flujo de datos de una estructura secuencial

Abraham Sopla Maslucán P á g i n a 9 | 362

• Es importante destacar la aparición de una condición, cuyo valor es lógico, es

• Es importante destacar la aparición de una condición (cuyo resultado o valor es

Abraham Sopla Maslucán P á g i n a 10 | 362

• En la construcción del diagrama de flujo del algoritmo se indican las acciones

2.8 Diagrama de flujo de datos de estructuras repetitivas

• Inicio: Variable también se le llama contador, inicio es el primero valor de

Abraham Sopla Maslucán P á g i n a 11 | 362

• Hay acciones que se repiten muchas veces, pero la cantidad de repeticiones

También se puede usar mientras en vez de para, ello es importante definir la

Abraham Sopla Maslucán P á g i n a 12 | 362

• En algún momento (dentro de • En el momento que leamos un 0 en la

Estructura repetitiva mientras Ejemplo

Abraham Sopla Maslucán P á g i n a 13 | 362

Estructura repetitiva hacer-mientras Ejemplo

• Hay acciones que se repinten muchas veces, pero la cantidad de repeticiones

3 PASOS PARA ESCRIBIR UN PROGRAMA

3. Diseño del algoritmo

a) Representación del algoritmo

b) Diseño del juego de datos de prueba