Libro de Fundamentos de Programacion Version Final 1

FUNDAMENTOS DE
PROGRAMACIÓN
Autores
© ESCOBEDO BAILÓN, Frank Edmundo
© RUIZ CARRASCO, Kathy Giannina
© VEGA HUERTA, Hugo Froilán
© CHÁVEZ HERRERA, Carlos Ernesto
© BENITO PACHECO, Oscar
Primera Edición Digital: Enero, 2021

Publicación disponible en:
https://www.unheval.edu.pe
Editado por:
ESCOBEDO BAILÓN, Frank Edmundo
Dirección: Carlos Alayza Roel 2392 Dpto. 104
Urb. Fundo Lobatón
Lima – Lima – Lince
Perú
ISBN: 978 – 612 – 00 – 5955 - 5
Derechos Reservados. Prohibida la

reproducción de este Libro Virtual por cualquier
medio total o parcial, sin permiso expreso de los
autores.
ÍNDICE
CAPÍTULO I. ................................................................................. 8
1. ESTRUCTURAS LÓGICAS .......................................................... 8
1.1. Estructuras Lógicas Secuenciales ..................................... 8
1.2. Estructuras Lógicas Selectivas ....................................... 11
1.3. Estructuras Lógicas Repetitivas ..................................... 21
1.3.1. Estructura Mientras (While) ...................................... 22
1.3.2. Ciclo For ................................................................... 25
1.3.3. Ciclo do while ........................................................... 29
CAPÍTULO II............................................................................... 33
2. ARREGLOS ............................................................................ 33
2.1. Arreglos Unidimensionales ............................................. 33
2.2. Arreglos Bidimensionales ............................................... 38
2.3. Cadena de caracteres. .................................................... 41
CAPÍTULO III. ............................................................................ 58
3. PROGRAMACIÓN MODULAR ................................................... 58
CAPÍTULO IV. ............................................................................. 76
4. PROGRAMACIÓN ORIENTADA A OBJETOS .............................. 76
4.1. Definición. ........................................................................ 76
4.2. Definición de clases y objetos. .......................................... 76
4.3. Definición de encapsulamiento. ........................................ 77
4.4. Métodos y atributos. ......................................................... 77
4.5. Creación de clases y objetos en C++................................. 78
4.6. Constructores y destructores. ........................................... 79

4.7. Herencia y polimorfismo. .................................................. 81
4.8. Funciones amigas(Friends)............................................... 82
CAPÍTULO V ............................................................................... 91
5. ESTRUCTURAS ...................................................................... 91
5.1. Definición. ........................................................................ 91
CAPÍTULO VI .............................................................................. 98
6. UNIONES .............................................................................. 98
6.1. Creación de clases y objetos en C++................................. 98
CAPÍTULO VII. ......................................................................... 103
7. ENUMERACIONES ................................................................ 103
7.1. Creación de clases y objetos en C++............................... 103
CAPÍTULO VIII ......................................................................... 108
8. PUNTEROS ............................................................................ 108
8.1. Definición. ...................................................................... 108
8.2. Detalles al crear y usar punteros en C++. ....................... 108
8.3. Los punteros y el ampersand. ......................................... 109
Los apuntadores y el asterisco ............................................... 109
Ejemplo 1. .......................................................................... 110
Ejemplo de punteros (Array Dinámico): .............................. 113
Ejemplo de Punteros (Matriz Dinámica): ............................. 115
Ejemplo de Punteros(Aritmética de Punteros): .................... 117
CAPÍTULO IX ............................................................................ 122
9. ARCHIVOS .......................................................................... 122
9.1. Definición. ...................................................................... 122
9.2. Flujos de archivos. ......................................................... 122
9.3. Tipos de archivos básicos. .............................................. 124

9.3.1. Archivos basados en caracteres .............................. 124
9.3.2. Archivos basados en binarios .................................. 128
CAPÍTULO X ............................................................................. 132
10. MÉTODOS DE ORDENAMIENTO .......................................... 132
10.1. Definición. ................................................................... 132
10.2. Ordenamiento por selección. ........................................ 132
10.3. Ordenamiento por burbuja ........................................ 134
10.4. Ordenamiento por inserción ...................................... 136
10.5. Ordenación Shell. ...................................................... 139
10.6. Ordenamiento HeapSort ............................................ 140
CAPÍTULO XI. ........................................................................... 144
MÉTODO DE SELECCIÓN............................................................ 144
11.1. Definición. ................................................................... 144
Clasificación: ......................................................................... 145
CAPÍTULO XII .......................................................................... 150
12. MÉTODO DE BÚSQUEDA .................................................... 150
12.1. Definición. ................................................................... 150
12.2. Búsqueda Secuencial/Lineal: ..................................... 150
12.3. Búsqueda Binaria. ..................................................... 155
EJERCICIOS PROPUESTOS ........................................................ 158
Métodos de Ordenamiento: Heapsort. (2015). Heapsort. Recuperado

de: http://ordenamientoheapsort.blogspot.com/2015/09/metodos-de-
ordenamiento-los-metodos-de.html .......................................... 168
FUNDAMENTOS DE PROGRAMACIÓN
7
CAPÍTULO I.
1. ESTRUCTURAS LÓGICAS
1.1. Estructuras Lógicas Secuenciales
Definición:
La estructura secuencial está formada por una secuencia de instrucciones
que se ejecutan en orden una a continuación de la otra. Cada una de las
instrucciones están separadas por el carácter punto y coma. No obstante,
en algunos casos nos interesará agrupar en un bloque una serie de
instrucciones, como veremos al explicar las estructuras de selección y de
iteración. (TUTORIOZ, 2020)
El bloque de sentencias se define por el carácter llave de apertura ( { ) para
marcar el inicio del mismo, y el carácter llave de cierre ( } ) para marcar el
final.(TUTORIOZ, 2020)
Ejemplo 1. Realice un programa que permita restar 2 números ingresados

por teclado.
#include<iostream>
using namespace std;
8
int main()
float a,b, resta;
cout<<" Digite el valor de a: "; cin>>a;
cout<<" Digite el valor de b: "; cin>>b;
resta = a - b;
cout<<"\nLa resta es: "<<resta<<endl;
return 0;
}
Ejemplo 2. Realice un programa que permita realizar la multiplicación de

2 numeros ingresados por teclado.
#include<iostream>
int main(){
float a,b, multiplicacion;
multiplicacion = a * b;
cout<<"\nLa multiplicacion es: "<<multiplicacion<<endl;
return 0;
}
Ejemplo 3. Realizar un programa que permita realizar la división de 2

numeros ingresados por teclado.
#include<iostream>
int main(){
float a,b, division;
division = a / b;
9
cout<<"\nLa division es: "<<division<<endl

return 0;
}
Ejemplo 4. Realizar un programa que permita calcular el precio final

(sumar impuesto) de un producto, el precio neto del producto será
ingresado por teclado.
#include<iostream>
int main(){
float precio, precioFinal, Precioconimpuesto;
cout<<"Digite el precio del producto: ";
cin>>precio;
Precioconimpuesto = precio*1.18;
cout<<"\nEl precio Final al aplicar el impuesto es: "<<
Precioconimpuesto;
return 0;
}
Ejemplo 5. Realizar un programa que permita sumar los valores de 2

números ingresados por teclado.
#include<iostream>
int main(){
float a,b, suma;
suma = a + b;
cout<<"\nLa suma es: "<<suma<<endl;
return 0;
}
10
1.2. Estructuras Lógicas Selectivas
Definición:
Joyanes y Zahonero (2007) dice que “Las sentencias condicionales son las
que nos permitirán ejecutar un bloque de código o no, o ejecutar un bloque
de código u otro” (p. 142)
Sentencias If - Else
Para Joyanes y Zahonero (2007) la sentencia condicional if (o “si”) nos
permite ejecutar un bloque de código sólo si se cumple una condición. Caso
contrario se ejecuta el bloque de código contenido luego de la condición
else. La sintaxis es:
if (condicion){
bloque_de_codigo_1;
}else{
bloque_de_codigo_2;
}
Ejemplo 1. Realice un programa para saber si un número ingresado por

teclado es cero o diferente de cero.
#include <iostream>
int main(){
int numero;
cout << "Introduzca un numero: ";
cin >> numero;
if (numero == 0){
cout << "El numero es cero" << endl;
}else{
cout << "El numero es diferente de cero" << endl;
11
}
return 0;
}
Ejemplo 2. Realice un programa para saber si un número es menor a 10.

#include <iostream>
int main(){
int numero;
cout << "Introduzca un numero: ";
cin >> numero;
if (numero < 10){
cout << "El numero es menor que 10" << endl;
}else{
cout << "El numero es igual o mayor que 10" << endl;
}
return 0;
}
Ejemplo 3. Realice un programa para saber si el nombre ingresado por

teclado es frank. En caso sea correcto que imprima en pantalla bienvenido
frank, caso contrario que indique usuario no registrado.
#include <iostream>
int main(){
string nombre;
cout << "Introduzca su nombre: ";
cin >> nombre;
if (nombre == "frank"){
cout << "Bienvenido frank" << endl;
}else{
12
cout << "Usuario no registrado" << endl;

}
return 0;
}
Ejemplo 4. Realice un programa que permita ingresar la nota final del

curso de algoritmos, el programa debe indcar si se aprobo el curso o no.
#include <iostream>
int main(){
float nota;
cout << "Introduzca la nota final del curso: ";
cin >> nota;
if (nota >= 10.5f){
cout << "Felicidades, has aprobado el curso" << endl;
}else{
cout << "Has reprobado el curso" << endl;
}
return 0;
}
Ejemplo 5. Realice un programa que solicite 4 notas por teclado y en base

a su promedio saber si aprobaste o no el curso.
#include <iostream>
int main(){
float nota1, nota2, nota3, nota4, notafinal;
cout << "Introduzca la primera nota del curso: ";
cin >> nota1;
cout << "Introduzca la segunda nota del curso: ";
cin >> nota2;
13
cout << "Introduzca la tercera nota del curso: ";

cin >> nota3;
cout << "Introduzca la cuarta nota del curso: ";
cin >> nota4;
notafinal = (nota1+nota2+nota3+nota4)/4.0f;
if (notafinal >= 10.5f){
cout << "Felicidades, has aprobado el curso" << endl;
}else{
cout << "Has reprobado el curso" << endl;
}
return 0;
}
Sentencias Switch
Joyanes y Zahonero (2007) afirma que “la sentencia switch nos permite,
según el valor de una variable, ejecutar un código, u otro, u otro por
defecto, de una manera muy clara” (p. 146). Su sintaxis es:
switch (variable){
case valor_1: bloque de codigo 1
break;
case valor_2: bloque de codigo 2
break;
...
case valor_n: bloque de codigo n
break;
}
Ejemplo 1. Cree un programa que ingresando el número de la vocal

imprima en pantalla la vocal correspondiente.
#include <iostream>
14

int main(){
int numero;
cout << "Ingrese el numero de la vocal: ";
cin >> numero;
switch (numero){
case 1:{
cout << "La vocal es A" << endl;
break;
}
case 2:{
cout << "La vocal es E" << endl;
break;
}
case 3:{
cout << "La vocal es I" << endl;
break;
}
case 4:{
cout << "La vocal es O" << endl;
break;
}
case 5:{
cout << "La vocal es U" << endl;
break;
}
default:{
cout << "La opcion ingresada no existe" << endl;
break;
}
}
15
return 0;
}
Ejemplo 2. Cree un programa que ingresando el número del mes imprima

en pantalla el mes correspondiente.
#include <iostream>
int main(){
int numero;
cout << "Ingrese el numero del mes: ";
cin >> numero;
switch (numero){
case 1:{
cout << "El mes es enero" << endl;
break;
}
case 2:{
cout << "El mes es febrero" << endl;
break;
}
case 3:{
cout << "El mes es marzo" << endl;
break;
}
case 4:{
cout << "El mes es abril" << endl;
break;
}
case 5:{
cout << "El mes es mayo" << endl;
break;
16
}
case 6:{
cout << "El mes es junio" << endl;
break;
}
case 7:{
cout << "El mes es julio" << endl;
break;
}
case 8:{
cout << "El mes es agosto" << endl;
break;
}
case 9:{
cout << "El mes es septiembre" << endl;
break;
}
case 10:{
cout << "El mes es octubre" << endl;
break;
}
case 11:{
cout << "El mes es noviembre" << endl;
break;
}
case 12:{
cout << "El mes es diciembre" << endl;
break;
}
default:{
17
break;
}
}
return 0;
}
Ejemplo 3. Cree un programa que ingresando el código de carrera imprima

la carrera correspondiente.
#include <iostream>
int main(){
int numero;
cout << "Ingrese el codigo de la carrera: ";
cin >> numero;
switch (numero){
case 1:{
cout << "Ingenieria Electronica y Telecomunicaciones"
<< endl;
break;
}
case 2:{
cout << "Ingenieria Mecanica y Electrica" << endl;
break;
}
case 3:{
cout << "Ingenieria de Sistemas" << endl;
break;
}
case 4:{
cout << "Administracion de empresas" << endl;
break;
18
}
case 5:{
cout << "Ingenieria Ambiental” << endl;
break;
default:{
break;
}
}
return 0;
}
Ejemplo 4. Cree un programa que ingresando el numero del dia de la

semana, imprima en pantalla el dia de la semana correspondiente.
#include <iostream>
int main(){
int numero;
cout << "Ingrese el dia de la semana: ";
cin >> numero;
switch (numero){
case 1:{
cout << "Lunes" << endl;
break;
}
case 2:{
cout << "Martes" << endl;
break;
}
case 3:{
cout << "Miercoles" << endl;
19
break;
}
case 4:{
cout << "Jueves" << endl;
break;
}
case 5:{
cout << "Viernes" << endl;
break;
}
case 6:{
cout << "Sabado" << endl;
break;
}
case 7:{
cout << "Domingo" << endl;
break;
}
default:{
break;
}
}
return 0;
}
Ejemplo 5. Realice un programa que permita ingresar el código de pedido

al comedor. Luego de ello imprima si es desayuno, almuerzo o cena.
#include <iostream>
int main(){
20
int numero;
cout << "Ingrese el codigo del alimento: ";
cin >> numero;
switch (numero){
case 1:{
cout << "Desayuno" << endl;
break;
}
case 2:{
cout << "Almuerzo" << endl;
break;
}
case 3:{
cout << "Cena" << endl;
break;
}
default:{
break;
}
}
return 0;
}
1.3. Estructuras Lógicas Repetitivas
Definición:
Las estructuras repetitivas o iterativas son aquellas en las que las acciones
se ejecutan un número determinado de veces y dependen de un valor
predefinido o el cumplimiento de una determinada acción.
Se llaman problemas repetitivos o cíclicos a aquellos en cuya solución es
necesario utilizar un mismo conjunto de acciones que puedan ejecutar una
21
cantidad específica de veces. Esa cantidad puede ser fija o puede ser
variable.
En general hay 3 formas diferentes de instrucciones de repetición, todas
las cuales son proporcionadas en C++:
1. While
2. For
3. do while
1.3.1. Estructura Mientras (While)
La expresión contenida dentro del paréntesis es la condición probada para

determinar si se ejecuta la instrucción que sigue al paréntesis. La expresión
es evaluada exactamente en la misma manera que la contenida en una
instrucción if-else; la diferencia está en cómo se usa la expresión.
Como se ha visto, cuando la expresión es verdadera (tiene un valor
diferente de cero) en una instrucción if-else, la instrucción que sigue a la
expresión se ejecuta una vez.
En una instrucción while, la instrucción que sigue a la expresión se ejecuta
en forma repetida hasta que la expresión reconozca un valor diferente de
cero.
Considerando este proceso el algoritmo se mostraría:
1. Probar la expresión
2. Si la expresión tiene un valor diferente de cero (verdadero)
a. Ejecutar la instrucción que sigue al paréntesis
b. Regresar al paso 1
De lo contrario
Salir de la instrucción while y ejecutar la siguiente instrucción
ejecutable que sigue a la instrucción while
22
Ejemplo 1
Haremos un programa de un bucle que funcionará hasta que la palabra
cuenta sea menor o igual a 10.
Si nosotros no le asignamos un valor a cuenta este bucle será infinito, sin
embargo, si cuenta inicia con un valor mayor a 10 el bucle nunca sucederá
por eso en el código asignamos el valor de 1.
Y para que el ciclo no lea de nuevo el valor de cuenta que es 1 este debe ir
en aumento sino el bucle sería infinito. En este caso aumentaremos el valor
de cuenta en uno en código sería cuenta=cuenta+1 o cuenta++.
#include <iostream>
int main()
{
int cuenta;
cuenta=1; //inicializa cuenta
while (cuenta<=10)
{
cout<<cuenta<<" ";
23
cuenta++; //incrementa cuenta

}
return 0;
}
Ciclos while Interactivos

La combinación de la introducción de datos interactivos con las capacidades
de repetición de la instrucción while produce programas muy adaptables y
potentes.
Para entender el concepto implicado, haremos un programa, donde una
instrucción while se usa para aceptar y luego desplegar cuatro números
introducidos por el usuario, uno a la vez.
Ejemplo 2
#include <iostream>
#include <iomanip>
int main()
{
const int maxnums=4;
int cuenta;
double num;
cout<< "\nEste programa le pedirá que introduzca "
<<maxnums<<"numeros.\n";
cuenta=1;
while(cuenta<=maxnums){
cout<<"\n Introduzca un número:";
cin>>num;
cout<<"El numero intriducido es "<<num;
cuenta++;
}
24
cout<<endl;
return 0;
}
Resultado
1.3.2. Ciclo For
Esta instrucción realiza las mismas funciones que la instrucción while, pero
usa una forma diferente. En muchas situaciones, en especial aquellas que
usan una condición de cuenta fija, el formato de la instrucción for es más
fácil de usar que su instrucción while equivalente.
La sintaxis de la instrucción for es
Pasaremos a explicar los 3 elementos dentro del paréntesis de la expresión

for, la lista de inicialización consiste de una sola instrucción usada para
establecer el comienzo (valor inicial) de un contador, la expresión contiene
el valor máximo o mínimo que puede tener el contador y determina cuando
se termina el ciclo, y la lista de alteración proporciona el valor de
incremento que se suma o se resta del contador cada vez que se ejecuta el
ciclo.
25
Usaremos el ejemplo que usamos en el ciclo while
Ejemplo 3. Haremos un programa de un bucle que funcionara hasta que

la palabra cuenta sea menor o igual a 10.
#include <iostream>
int main()
{
int cuenta;
for(cuenta=1;cuenta<=10;cuenta++){
cout<<cuenta<<" ";
}
return 0;
}
En la primera instrucción for, la variable contadora se llama cuenta, el valor
inicial asignado a cuenta es 1, el ciclo continúa en tanto el valor en cuenta
sea menor que 10, y el valor de cuenta se incrementa en uno cada vez que
pasa por el ciclo.
26
Ejemplo 4. A continuación, veremos alteración de los elementos del ciclo

for del ejemplo anterior, primero cuando el inicializador está fuera del ciclo
for
#include <iostream>
int main()
{
int cuenta;
cuenta=1;
for(;cuenta<=10;cuenta++){
cout<<cuenta<<" ";
}
return 0;
}
Ejemplo 5. En este caso el inicializador y la instrucción de alteración están

fuera del ciclo for
#include <iostream>
int main()
{
int cuenta;
cuenta=1;
for(;cuenta<=10;){
cout<<cuenta<<" ";
cuenta++;
}
return 0;
}
27
Ejemplo 6. En el siguiente caso todas las expresiones están dentro del for
#include <iostream>
int main()
{
int cuenta;
for(cuenta=1;cuenta<=10;cout<<cuenta<<" ",cuenta++){
}
return 0;
}
En todas las expresiones el programa corre bien, aunque no debería

usarlos, agregar elementos distintos a las variables de control del ciclo y
sus condiciones de actualización dentro de la función for tiende a confundir
su legibilidad y puede introducir efectos indeseados. Mantener “limpia” la
estructura de control del ciclo, como se hizo en el ejemplo principal, es
importante y es una buena práctica de programación.
Ciclos Anidados
Se llama ciclo anidado a situaciones donde un ciclo está dentro de otro ciclo
Ejemplo 7. Crear un ciclo dentro de otro y mostrar los valores de las

varibles I, J (contadores del For)
#include <iostream>
int main()
{
for (int i=1; i<=7; i++) { //inicio del ciclo exterior
cout<<" \i es ahora " <<i<<endl;
for (int j=1; j<=4; j++) //inicio del ciclo interior
cout<<" j=" <<j;
28
} //fin del ciclo interior

return 0;
} //fin del ciclo exterior
El for de j significa que este terminará hasta que llegue a su límite que sería
4 una vez termine el ciclo de j se termina el ciclo de i y vuelve a comenzar
el siguiente ciclo de i.
La salida del programa es

i es ahora 1
j=1 j=2 j=3 j=4
i es ahora 2
j=1 j=2 j=3 j=4
i es ahora 3
j= 1 j=2 j=3 j=4
i es ahora 4
j=1 j=2 j=3 j=4
i es ahora 5
j=1 j=2 j=3 j=4
i es ahora 6
j=1 j=2 j=3 j=4
i es ahora 7
j=1 j=2 j=3 j = 4
1.3.3. Ciclo do while
Los ciclos do-while son una estructura de control cíclica, nos permiten
ejecutar una o varias líneas de forma repetitiva sin necesidad de tener un
29
valor inicial e incluso a veces sin siquiera conocer cuando se va a dar el

valor final.
El ciclo do while es un ciclo de prueba posterior o controlado en la salida,
donde la condición probada se evalúa al final del ciclo. Este tipo de ciclo
siempre se ejecuta al menos una vez. En tanto la condición probada
permanezca verdadera, los ciclos do while continúan ejecutándose.
Nótese que un ciclo do while continúa las iteraciones a través del ciclo
mientras la condición es verdadera y sale del ciclo cuando la condición es
falsa.
El ciclo do while de prueba posterior se crea usando una instrucción do.

Como su nombre implica, esta instrucción permite hacer algunas
instrucciones antes de que sea evaluada una expresión al final del ciclo. La
forma general de la instrucción do de C++ es
Verificaciones de validez
30
La instrucción do es útil en particular para filtrar datos introducidos por el

usuario y proporcionar verificaciones de validación de los datos.
Por ejemplo, suponga que se requiere un operador para introducir un
número de identificación del cliente válido entre los números 1000 y 2999.
Un número que esté fuera de este rango se rechazará y se hará una nueva
solicitud para un número válido.
Ejemplo 8
#include <iostream>
int main()
{
int num_id;
cout<<"Introduzca un numero entre el 1000 y el 2999"<<endl;
do {
cout<< "\nIntroduzca un numero de identificacion: ";
cin>>num_id;
}
while (num_id < 1000 || num_id > 2999);
return 0;
}
31
32
CAPÍTULO II.
2. ARREGLOS
2.1. Arreglos Unidimensionales
Definición:
Un arreglo unidimensional es un tipo de datos estructurado que está
formado por una colección finita y ordenada de datos del mismo tipo. Es la
estructura natural para modelar listas de elementos iguales. Los datos que
se guarden en los arreglos todos deben ser del mismo tipo.
El tipo de acceso a los arreglos unidimensionales es el acceso directo, es
decir, podemos acceder a cualquier elemento del arreglo sin tener que
consultar a elementos anteriores o posteriores, esto mediante el uso de un
índice para cada elemento del arreglo que nos da su posición relativa.
Para implementar arreglos unidimensionales se debe reservar espacio en
memoria.
Los arreglos nos permiten hacer un conjunto de operaciones para manipular
los datos guardados en ellos, estas operaciones son: ordenar, buscar,
insertar, eliminar, modificar entre otras.
Representación de memoria
Los arreglos guardan en memoria la cantidad de espacios que se le indican
en la declaración.
Ejemplo 1. Sea el siguiente arreglo unidimensional donde se va a guardar

5 datos de tipo entero (integer)
x : array[1..5] of integer
En memoria el computador guarda 5 espacios: esto quiere decir en el
arreglo X en la posición 1 guarda 34, en el arreglo X en la posición 2 guarda
22, así hasta la última posición del arreglo X posición 5 guarda 72.
33
X [1]
34
x[2]
22
X [3]
39
X [4]
63
X [5]
72
Declaración de los arreglos unidimensionales: Se declara el tipo del arreglo,

con la palabra reservada TYPE, luego se declara la variable de tipo arreglo,
esto se hace en el bloque de declaración de variables palabra reservada
VAR.
Type
nombre_arreglo= array[x..y]of tipo_dato;
Ejemplo 2.
salarios= array [1…x] of real;
nombre_trabajador=array[1..x] of string;
Nota: El tipo de dato del arreglo puede ser: integer, real, boolean, string
etc.
Variables tipo array
Var
sueldo:salarios;
nombre:nombre_trabajador;
34
Una vez declarados los arreglos procedemos a cargar información en ellos,

para esto usamos estructuras repetitivas la más recomendable por su
facilidad es el for, una vez cargada la información se puede hacer cualquier
operación de cálculo y por último mostramos la información de los arreglos
usando de igual manera la estructura repetitiva for.
Carga de un arreglo, la letra i es el índice o subíndice del arreglo e indica
la posición del arreglo:
for i:=1 to num do

begin
readln(notas[i]);
end;
Mostrar la información de un arreglo, la letra i es el índice o subíndice del

arreglo e indica la posición del arreglo:
for i:=1 to num do

begin
writeln (notas[i]:3:1);
end;
Se han hecho programas que suman una cantidad de números usando dos
variables, una para leer cada número y otra para acumular la suma. Este
enfoque tiene la desventaja de que se pierden los valores de los sumandos.
El uso de arreglos permite calcular la suma de los números con una
cantidad mínima de código y a la vez conservar cada valor, como muestra
el siguiente programa completo: (LP: Pascal)
Program SumaN;
Uses
35
Crt;
Cons
n = 5;
Var
nums: Array[1..n] Of Integer;
s, i: Integer;
Begin
For i:=1 To n Do
Begin
Write('Escriba el número: ');
ReadLn(nums[i]);
s := s + nums[i];
End;
WriteLn('La suma es: ', s);
Nótese el uso de una constante para marcar el tamaño del arreglo; dicha
constante, también sirve para controlar el For. De este modo, sólo se hace
necesario cambiar un número para adecuar el programa a la escala
apropiada.
Ejemplo 3. Dadas n cantidad de notas, calcular e imprimir el promedio de

las notas y todas las notas que fueron mayor a la media calculada.
PROGRAM calificaciones;
USES CRT;
type
listacalificaciones = array[1..n]of real;
VAR
notas:listacalificaciones;
media,suma:real;
num,i:integer;
36
BEGIN
WRITELN ('INTRODUZCA la cantidad de notas a procesar');
READLN (NUM);
Suma: =0;
for i:=1 to num do

begin
readln(notas[i]);
suma: =suma+notas[i];
end;
media: =suma/num;
writeln('la media es:' , media:2:2);
writeln('la lista de calificaciones mayores a la media es:');
for i:=1 to num do
begin
if notas[i]>media then
writeln(notas[i]:3:1);
readln;
end;
Ejemplo 4. Escribir un programa en pascal que rellene un array con 11

números, luego dividirlos entre 3 y mostrarlos por pantalla.
PROGRAM numeros;
USES CRT;
type
arreglonumeros = array[1..11]of real;
VAR
num:arreglonumeros;
i: integer;
numero: real;
37
BEGIN
for i:=1 to 11 do
begin
WRITELN('Introduzca el numero ' , i, ' a dividir');
readln(num[i]);
numero:=num[i]/3;
write('los número resultantes de la división son:' ,numero:2:2);
readln;
end;
2.2. Arreglos Bidimensionales
Zahonero y Joyanes (2007) menciona que los arrays o arreglos

multidimensionales son aquellos que tienen más de una dimensión y, en
consecuencia, más de un índice. Los arrays más usuales son los
unidimensionales y los de dos dimensiones, conocidos también por el
nombre de tablas o matrices. Sin embargo, es posible crear arrays de
tantas dimensiones como requieran sus aplicaciones, esto es, tres, cuatro
o más dimensiones. Un array de dos dimensiones equivale a una tabla con
múltiples filas y múltiples columnas. (pag. 84).
Ejemplo 1. Cree un tablero del juego cruz en raya.

//...
tablero[3][3];
//...
Ejemplo 2. Cree un programa que almacene tres ternas de valores.

#include <iostream>
int main(){
int ternas[3][3] = {1,2,3,4,5,6,7,8,9};
38
return 0;
}
Ejemplo 3. En base al ejercicio anterior haga la impresión de los valores

a través de un bucle.
#include <iostream>
int main(){
int ternas[3][3] = {1,2,3,4,5,6,7,8,9};
for (int i=0;i<3;i++){
for (int j=0;j<3;j++){
cout << ternas[i][j];
}
cout << "\n";
}
return 0;
}
Ejemplo 4. Cree una matriz 8x8 y rellene los valores empezando

0,1,2,3,4,5,6,7;1,2,3,4,5,6,7,8 y así sucesivamente de tal manera que
estos datos se llenen de manera automática a través de un bucle.
#include <iostream>
int main(){
int ternas[8][8];
ternas[i][j] = i+j;
}
}
39

cout << ternas[i][j] << "\t";
}
cout << "\n";
}
return 0;
}
Ejemplo 5. En una tabla de 3x3 rellene con 1 la diagonal principal y todos

los demás valores de 0. Realicé esto a través de un bucle.
#include <iostream>
int main(){
int ternas[3][3];
if(i==j){
ternas[i][j] = 1;
}else{
ternas[i][j] = 0;
}
}
}
cout << ternas[i][j] << "\t";
}
cout << "\n";
}
return 0;
}
40
2.3. Cadena de caracteres.
Definición:
Una cadena en C++ es un conjunto de caracteres (valores de tipo “char”)
terminados con el carácter nulo. Se almacenan internamente en posiciones
consecutivas de memoria.
Estas estructuras reciben un tratamiento especial. Esto debido a su gran
utilidad y su uso continuo. Una cadena se define de la siguiente forma:
char <identificador> [<longitud máxima>];
Un dato a tomar en cuenta es que al declarar a una cadena, tendremos que

reservar una posición (esta posición se reservara para el carácter nulo, de
modo que si queremos almacenar la cadena "ALGORITMOS", tendremos
que declarar la cadena como: char curso[11]; Diez caracteres para
"ALGORITMOS" y uno extra para el carácter '\000'. Al momento de querer
ubicar un carácter en la cadena, se declarará con el número anterior a su
posición. Por ejemplo, el carácter “G” ubicado en la tercera posición de la
cadena “ALGORITMOS”, sería curso[2] y a su vez el carácter “O” sería
curso[3].
La importancia de la cadena de caracteres radica principalmente en la gran
cantidad de información que ellas almacenan y su valor semántico. A
continuación, se mostrará algunas de las operaciones y funciones más
importantes con cadenas; estas funciones están incluidas en string.h (esta
librería presenta más funciones).
Función Strlen
En esta operación participa la función Strlen, la cual devuelve en un valor
entero, la longitud de una cadena de caracteres.
41
Ejemplo 1. El siguiente programa muestra la longitud de la cadena frase.

#include<iostream>
#include<conio.h>
#include<string.h>
int main(){
//String de 50 caracteres
char frase[50];
int longitud;
cout<<"Digite una cadena de caracteres: ";
//Guarda la cadena
cin.getline(frase,50,'\n');
//Se da la longitud a una variable int
longitud= strlen(frase);
//Se muestra la longitud de la cadena
cout<<"la longitud de la cadena es: "<<longitud<<endl;
getch();
return 0;
}
Ejemplo 2. El siguiente programa pedirá al usuario que ingrese una cadena

de caracteres, si supera los 15 caracteres se mostrará la cadena.
#include<iostream>
#include<conio.h>
#include<string.h>
int main(){
//String de caracteres
char caracter[50];
cout<<"Ingrese una cadena de caracteres: ";
//Se guarda la cadena
42
cin.getline(caracter,50,'\n');
//Calcula la longitud de la cadena y si es mayor a 15
if(strlen(caracter)>15){
cout<<caracter;
}
//En caso la cadena no supere los 15 caracteres
else{
cout<<"La cadena no supera los 15 caracteres";
}
getch();
return 0;
}
Ejemplo 3. Se pide un programa que al ingresar una cadena imprima la

misma cadena.
#include<iostream>
#include<conio.h>
#include<string.h>
int main(){
char caracter[50];
int longitud;
//Se da la longitud a una variable entera
longitud= strlen(caracter);
//Se mostrara carácter por carácter a la cadena
for(int i=0;i<longitud;i++){
cout<<caracter[i];
43
}
getch();
return 0;
}
Ejemplo 4. Se pide mostrar en un programa que compare cadenas e

identifique si son iguales o no.
#include<iostream>
#include<conio.h>
#include<string.h>
int main(){
char caracter[50];
char caracter1[50];
//Declaracion de variables enteras
int longitud,longitud1;
cout<<"Ingrese otra cadena de caracteres: ";
//Se guarda la otra cadena
cin.getline(caracter1,50,'\n');
//Se da las longitudes a las variables enteras
longitud1= strlen(caracter1);
//Se calcular si las longitudes son iguales
if(longitud == longitud1){
cout<<longitud<<","<<longitud1<<endl;
cout<<"Estas cadenas tienen igual longitud";
}
44
//En caso no sean iguales

else {
cout<<"Las cadenas tienen longitud diferente";
}
getch();
return 0;
}
Ejemplo 5. Se pide un programa que compare 2 cadenas, y si estas son

iguales se imprimirán las cadenas.
#include<iostream>
#include<conio.h>
#include<string.h>
int main(){
char caracter[50];
char caracter1[50];
//Variables enteras
int longitud,longitud1;
//Se guarda la primera cadena
cout<<"Ingrese otra cadena de caracteres: ";
cin.getline(caracter1,50,'\n');
//Se da las longitudes a las variables enteras.
longitud1= strlen(caracter1);
//Se calcula si las cadenas tienen igual longitud
if(longitud == longitud1){
45
cout<<"Estas cadenas tienen igual longitud"<<endl;
//Se mostrara a la cadena carácter por caracter
for(int i=0;i<longitud;i++){
cout<<caracter[i];
}
cout<<" ";
//Se mostrará a la otra cadena carácter por carácter
for(int j=0;j<longitud1;j++){
cout<<caracter1[j];
}
}
//En caso de que las cadenas presenten longitudes diferentes
else {
cout<<"las cadenas tienen longitudes diferentes";
}
getch();
return 0;
}
Función strcmp
Está dada por la función strcmp(),la cual recibe dos parámetros que serán
dos string, y si son iguales nos devolverá un 0, y si no son iguales devolverá
cualquier otro número.
Ejemplo 1. Un ejemplo al comparar cadenas es el calcular si son iguales.

#include<iostream>
#include<conio.h>
#include<string.h>
46
int main(){
//Se declaran las cadenas
char palabra1[]= "algoritmo";
//Se compara y analiza si las cadenas son iguales
if(strcmp(palabra1,palabra2)==0){
cout<<"Ambas cadenas son iguales";
}
getch();
return 0;
}
Ejemplo 2.
También se puede calcular la ubicación alfabética de una cadena.
#include<iostream>
#include<conio.h>
#include<string.h>
int main(){
char palabra2[]= "programacion";
//Se analiza si la primera cadena es mayor o menor
//alfabeticamente
if(strcmp(palabra1,palabra2)<0){
cout<<palabra1<<" esta alfabeticamente antes de
"<<palabra2;
}
getch();
return 0;
}
47
Ejemplo 3. Al ingresar 2 cadenas analizar cuál es mayor alfabéticamente.

#include<iostream>
#include<conio.h>
#include<string.h>
int main(){
char palabra1[20],palabra2[20];
cout<<"Ingrese una cadena: ";
cin.getline(palabra1,20,'\n');
cout<<"Ingrese otra cadena: ";
cin.getline(palabra2,20,'\n');
if(strcmp(palabra1,palabra2)==0){
cout<<"Ambas cadenas son iguales";
}
//se analiza si la primera cadena es mayor o menor
//alfabeticamente
else if(strcmp(palabra1,palabra2)>0){
cout<<palabra1<<" es mayor alfabeticamente";
}
else{
cout<<palabra2<<" es mayor alfabeticamente";
}
getch();
return 0;
}
Ejemplo 4. Se tienen 2 cadenas, se pide saber cuál es mayor

alfabéticamente y mostrar su longitud.
#include<iostream>
#include<conio.h>
48
#include<string.h>
int main(){
//string de 20 caracteres
char cadena1[20],cadena2[20];
//variables enteras
int longitud1, longitud2;
cin.getline(cadena1,20,'\n');
//Se da la longitud a una variable entera
longitud1= strlen(cadena1);
//Compara si las cadenas son iguales
if(strcmp(cadena1,cadena2)==0){
cout<<"Ambas cadenas son iguales alfabeticamente y en
longitud"; }
//Compara si la cadena1 es mayor a cadena2
else if(strcmp(cadena1,cadena2)>0){
cout<<cadena1<<" es mayor alfabeticamente y su longitud
es "<<longitud1;
}
//Se compara si cadena2 es mayor a cadena1
else{
cout<<cadena2<<" es mayor alfabeticamente y su longitud
es "<<longitud2;
}
getch();
return 0;
}
49
Ejemplo 5. Se calculará si las cadenas son iguales, y si son iguales se

mostrarán las cadenas.
#include<iostream>
#include<conio.h>
#include<string.h>
int main(){
char cadena1[20],cadena2[20];
//Variables enteras
int longitud1, longitud2;
//Se da el valor de las longitudes a variables enteras
//Compara si las cadenas son iguales
if(strcmp(cadena1,cadena2)==0){
for(int i=0; i<longitud1;i++){
//Mostrar cadena
cout<<cadena1[i];
}
//Espaciado
cout<<",";
for(int j=0; j<longitud2;j++){
//Mostrar cadena
cout<<cadena2[j];
}
50
//Se mostrará que las cadenas son iguales

cout<<"las cadenas son iguales";
}
//Compara si la cadena1 es mayor alfabeticamente a cadena2
else if(strcmp(cadena1, cadena2)>0){
cout<<cadena1<<" es mayor alfabeticamente con una
longitud de "<<longitud1;
}
//Caso contrario, la cadena2 es mayor a cadena1
else{
cout<<cadena2<<" es mayor alfabeticamente con una
longitud de "<<longitud2;
}
getch();
return 0;
}
Función strcat
Otra de las funciones más utilizadas, esta función se utiliza para concatenar
cadenas; es decir, juntar las cadenas.
Ejemplo 1. Se añadirá un nombre cualquiera a la cadena “Hola que tal” y

se mostrará al final a la cadena “Hola que tal (Nombre que elegiste).
#include<iostream>
#include<conio.h>
#include<string.h>
int main(){
//declaracion de un string y otro string de 20 caracteres
char cad1[] = "Hola que tal ";
char cad2[20];
51
//Ingresar un nombre
cout<<"Ingrese un nombre: ";
cin.getline(cad2,20,'\n');
//funcion strcat añadire el nombre al final de la primera cadena
strcat(cad1,cad2);
//Se mostrar la frase completa
cout<<"Frase: "<<cad1<<endl;
//Mostraria: Hola que tal (Nombre que elegiste)
getch();
return 0;
}
Ejemplo 2.
Se tiene los nombres y apellidos de una persona. Se deberán juntar tal que
se muestre sus apellidos y nombres, empezando por los apellidos.
#include<iostream>
#include<conio.h>
#include<string.h>
int main(){
//Se declara los apellidos y nombres:
char Apellidos[] = "Perez Ortega ";
char Nombres[]= "Jose Carlos";
//uso de la funcion strcat, la cual colocara
//los nombres despues de los apellidos
strcat(Apellidos, Nombres);
//Resultado final
cout<<"Nombres y Apellidos: "<<Apellidos<<endl;
//Nombres y Apellidos: Perez Ortega Jose Carlos
getch();
return 0;
52
Ejemplo 3. Se declaran las cadenas “Algoritmos” y “Programacion”. Se

tendrá que mostrar la unión de las cadenas y ver si esta tiene una longitud
mayor o menor a 25 caracteres.
#include<iostream>
#include<conio.h>
#include<string.h>
int main(){
char cadena1[] = "Algoritmos ";
char cadena2[]= "Programacion";
int longitud;
//a la cadena2 despues de la cadena1
strcat(cadena1, cadena2);
//se declara a la cadena final
cout<<cadena1<<endl;
//se da el valor de la longitud de la cadena a una variable entera
longitud= strlen(cadena1);
//Calcula si la longitud de la cadena es mayor o menor a 25
caracteres
if(longitud<25){
cout<<"La cadena tiene menos de 25 caracteres";
}
else{
cout<<"la cadena tiene igual o mas de 25 caracteres";
}
//resultado final: Algoritmos Programacion
// La cadena tiene menos de 25 caracteres
53
getch();
return 0;
}
Ejemplo 4. En este ejemplo, se comprobará que la función strcat haya sido

ejecutada correctamente. Esto con la ayuda de la función strlen.
#include<iostream>
#include<conio.h>
#include<string.h>
int main(){
//Se declaran las cadenas:
char cadena1[] = "Algoritmos ";
char cadena2[]= "Programacion";
int longitud1,longitud2;
//se declara a la cadena final
cout<<cadena1<<endl;
//se da el valor de la longitud de las cadenas a una variable entera
//Calcula si la longitud de la cadena final es mayor o menor a la
cadena2
if(longitud1>longitud2){
cout<<"Comprobado, se ejecuto bien la funcion strcat";
}
//en este caso es imposible o no se ejecuto bien la funcion strcat
else{
cout<<"IMPOSIBLE, no se ejecuto bien";
54
}
//resultado final: Algoritmos Programacion
// Comprobado, ejecuto bien la funcion strcat
getch();
return 0;
}
Ejemplo 5. En este ejemplo, se comprobará que la función strcat haya

sido ejecutada correctamente. Esto con la ayuda de la función strcmp.
#include<iostream>
#include<conio.h>
#include<string.h>
int main(){
char cadena1[] = "Programacion ";
char cadena2[]= "Algoritmos";
//Mostrar cadena final
cout<<cadena1;
//Se compara las cadenas con strcmp
//Si la cadena1 es mayor a la cadena2 se comprueba el uso de la
funcion strcat
cout<<" ";
if(strcmp(cadena1,cadena2)>0){
cout<<"Comprobado";
}
//en este caso es imposible o no se ejecuto bien la funcion strcat
else{
55
cout<<"IMPOSIBLE";
}
//Resultado final
//Programacion Algoritmos
//Comprobado
getch();
return 0;
}
56
57
CAPÍTULO III.
3. PROGRAMACIÓN MODULAR
3.1. Definición.
La programación modular está basada en la técnica de diseño descendente,
que como se sabe, consiste en dividir el problema original en diversos
subproblemas que se pueden resolver por separado, para después
recomponer los resultados y obtener la solución al problema. Denominado
también la técnica “Divide y vencerás”.
Ejemplo:
3.2. Subproblema o módulo

Son las partes y el resultado de aplicar la programación modular a un
problema, que se pueden resolver de manera independiente. Que un
módulo sea independiente nos permite, por un lado, concentrarnos en su
resolución olvidándonos del resto del problema, y por otro lado, permite
reutilizar la solución obtenida para otra parte del programa u otro programa
distinto.
Cada módulo se codifica dentro del programa como un subprograma, es
decir, una sección de código independiente que realiza una tarea específica
dentro del programa.
58
3.3. Subrutinas y subprogramas

El concepto de subprograma es una evolución del antiguo concepto de
subrutina, presente en lenguajes como Assembly, Basic o las primeras
versiones de Fortran.
Una subrutina es una sección de código separada del programa principal

que puede ser llamada en un momento dado (llamada a subrutina) y que
una vez acabada su ejecución vuelve al punto donde se realizó la llamada.
Un subprograma hace el papel de un programa. Puede tener una sección

de declaraciones (variables, constantes, etc…) y posee también unos datos
de entrada y de salida. Esto permite que el subprograma sea totalmente
independiente del programa principal.
Definición de subprogramas(funciones):
En un subprograma hay que distinguir dos aspectos fundamentales:
La definición del subprograma: Es la especificación de los parámetros de
entrada y salida y las sentencias del subprograma.
La llamada al subprograma: Es una sentencia que pasa el control del
programa al subprograma. Cuando el subprograma acaba su ejecución, el
control vuelve a la sentencia siguiente a la llamada.
Un subprograma puede pedir o devolver datos. A estos datos se les
denomina parámetros. Los parámetros pueden ser de entrada o de salida.
59
Los parámetros que se incluyen en la definición del subprograma se

denominan parámetros formales, mientras que los que se incluyen en la
llamada se denominan parámetros reales.
3.4. Funciones
Definición
Es indispensable y gracias a ellas es posible realizar la programación
modular. Básicamente, una función es un subprograma que siempre tiene
un parámetro de salida.
Una función se define de la siguiente manera:
Tipo Nombre(lista de parámetros) //Cabecera de la función

{
Declaraciones
Instrucciones
return Valor; //Cuerpo de la función
}
Ejemplo 1: Cree una función que opere la potencia “n” de un número.

#include<iostream>
int potencia(int a, int b){
int c=1;
for(int i=0; i<b; i++){
c*=a;
}
return c;
}
int main(){
60
int a,b,c;
cin>>a; cin>>b;
c=potencia(a,b);
cout<<c;
return 0;
}
Ejemplo 2: Realice una función que devuelva la quinta parte de un

número.
#include<iostream>
float quinta(float a){
float b;
b=a/6;
return b;
}
int main(){
float a,b;
cin>>a;
b=quinta(a);
cout<<b;
return 0;
}
Ejemplo 3: Realice una función que realice la diferencia de cuadrados de

dos números:
#include<iostream>
float dif_cuadrados(float a, float b){
float c;
61
c=(a+b)*(a-b);
return c;
}
int main(){
float a,b,c;
cin>>a; cin>>b;
c=dif_cuadrados(a,b);
cout<<c;
return 0;
}
Ejemplo 4: Realice un programa que reciba como único parámetro una

letra y devuelva la siguiente letra del abecedario.
#include<iostream>
int letra_sig(char a){
int b;
b=a+1;
return b;
}
int main(){
char a,b;
cin>>a;
b=letra_sig(a);
cout<<b;
return 0;
}
Ejemplo 5: Realice una función que reciba como parámetros el valor de

dos catetos y de como resultado la hipotenusa (Valores positivos).
62
#include<iostream>
#include<math.h>
float hipotenusa(float a, float b){
float c;
c=sqrt(a*a+b*b);
return c;
}
int main(){
float a,b,c;
cin>>a; cin>>b;
c=hipotenusa(a,b);
cout<<c;
return 0;
}
Una función, al igual que cualquier otro identificador, sólo se puede utilizar
a partir del momento en que lo declaramos. Para poder utilizar las funciones
en cualquier punto del programa, lo que se hace es declararlas al principio
del programa. La declaración de una función únicamente necesita la
cabecera y se denomina prototipo.
Ejemplo: Prototipo del ejemplo 1

int potencia(int x, int y);
3.5. Parámetros de un subprograma.
Paso por valor: Se coge el valor del parámetro real y se asigna al

parámetro formal. El parámetro formal es, por tanto, una copia del
parámetro real. Se utiliza exclusivamente para parámetros de entrada.
63
Ejemplo:
#include<iostream>
void disminuir(float x){
x-=10;
return;
}
int main(){
float a;
cin>>a;
disminuir(a); //Solo se realiza la subrutina, mas no se producen
cambios en "a"
cout<<a;
return 0;
}
Paso por referencia: El paso de parámetros por referencia une la variable

del parámetro formal con la variable del parámetro real y son tratadas como
una sola variable. Se utiliza para parámetros de entrada/salida. Se
diferencia del paso por valor poniendo el símbolo “&”.
Ejemplo:(con la función anterior)
#include<iostream>
void disminuir(float &x){
x-=10;
return;
}
int main(){
float a;
64
cin>>a;
disminuir(a);
cout<<a;
return 0;
}
3.6. Recursividad.
Un subprograma se denomina recursivo cuando en el cuerpo del

subprograma existe una llamada a sí mismo (Como por ejemplo el
factorial). Cuando únicamente existe una llamada, se denomina
recursividad lineal, si existen varias es una recursividad múltiple.
La recursividad es un método algorítmico alternativo a la iteración.

Cualquier estructura iterativa es posible sustituirla por un subprograma
recursivo y viceversa, aunque en ocasiones esta conversión puede ser
bastante complicada.
La recursividad permite definir ciertos algoritmos de una manera más

sencilla. Normalmente un programa iterativo es más eficiente que uno
recursivo, pero aún así, la versión recursiva puede ser más recomendable
por claridad del código.
Ejemplo 1. Realice una función recursiva que pida al usuario que pulse una
tecla numérica. Si esta es un número se sale de la función, pero si no lo es
vuelve a pedir que se pulse una tecla.
#include<iostream>
void comprobar(char r){
int n=int(r);
if (n>=48 && n<=57){
65
cout<<"Correcto, la tecla pulsada es un numero."<<endl;

}
else{
cout<<"Incorrecto, la tecla pulsada NO es un numero."<<endl;
cout<<"Vuelve a pulsar un numero : ";
cin>>r;
comprobar(r);
}
}
int main(){
char c;
cin>>c;
comprobar(c);
return 0;
}
Ejemplo 2. Realice una función recursiva que repita una frase un cierto
número de veces.
#include<iostream>
void escribir(string frase, int n){
cout<<n<<" : "<<frase<<endl;
n--;
if (n>0) escribir(frase,n);
}
int main(){
string f;
int n=5;
cout << "Escribe una frase. Se repetira 5 veces." << endl;
getline(cin, f);
cout << endl;
66
escribir(f,n);
return 0;
}
Ejemplo 3. Realice la función recursiva del factorial

#include<iostream>
int factorial(int n) {
if(n < 0) return 0;
else if(n>1) return n*factorial(n-1); // Recursividad: n>1
return 1; // Condición para n == 1 y n == 0
}
int main(){
int n,r;
cin>>n;
r=factorial(n);
cout<<n<<"!= "<<r<<endl;
}
Ejemplo 4. Realice la función recursiva para generar los primeros “n”

números de la serie de Fibonacci.
#include<iostream>
int fib(int n){
if(n < 2) return n;
return fib(n-1) + fib(n-2);
}
int main() {
int n;
cin>>n;
fib(n);
67
for(int i =1; i <= n; i++)

cout<<fib(i)<<", ";
return 0;
}
Ejemplo 5. Realice una función que multiplique dos números de manera

recursiva.
#include <iostream>
int producto(int a, int b){
if(a==0 || b==0) return 0;
else return a+producto(a,b-1);
}
int main(){
int a,b,c;
cin>>a; cin>>b;
c=producto(a,b);
cout<<c;
return 0;
}
3.7. Gestión de memoria.
La memoria que utilizan las funciones se gestiona similar a una pila. Cuando
llamamos a un procedimiento, se reserva espacio para las variables locales,
“apilando” estas. Cuando se acaba el procedimiento, las variables son
“desapiladas” y por tanto dejan de existir. En un lenguaje que sólo tenga
gestión de memoria estática, realmente no existen subprogramas ni
variables locales, únicamente subrutinas y variables globales.
68
Ejemplo
int n,s;
void calculo(int x, int &z);
void subcalculo(int xx);
int main(){
n=5; s=3;
calculo(n,s);
}
void calculo(int x, int &z){
int cc;
cc=6;
subcalculo(cc);
return;
}
void subcalculo(int xx){
int dd;
...
return;
}
69
3.8. Traza de programas.
Consiste en representar el valor de ciertas variables seleccionadas de

nuestro programa después de ejecutar cada instrucción.
Ejemplo
//Var globales
Int a, b;
void P(int & c);
int main(){
1) a = 1;
70
2) b = 3;
3) P(a);
4) cout << a << b << endl;
return 0;
}
void P(int & c){
int b;
5) b = 2;
6) c = a + b + 2;
return;
}
Traza a b
1) 1 ? c/a b
2) 1 3 1 ?
3) 1 3 1 2
5) 1 3 5 2
6) 5 3
4) 5 3
3.9. Compilación separada.
Cuando dividimos un problema en distintos módulos, no siempre ha de

corresponder cada módulo a un subprograma. Puede corresponder a todo
un conjunto de subprogramas que estarán agrupados en un fichero
independiente. La principal utilidad de dividir el programa en ficheros
distintos es que se pueden programar y compilar por separado. De esta
manera no hace falta compilar cada vez todo el programa.
Esto se realiza normalmente para programas muy grandes o simplemente

cuando queremos realizar una librería de subprogramas.
71
● Compilación de un programa en un solo fichero:
● Compilación de un programa en varios ficheros:
En C++, cada módulo a compilar por separado consta de dos ficheros, el

primero es un fichero que contiene todas las declaraciones y prototipos de
funciones a utilizar en el programa principal y se denomina fichero de
cabecera. Este fichero tiene extensión .h en lugar de la normal .cpp.
El segundo fichero contiene la definición de todas las funciones. Al inicio del
fichero debe existir una directiva del compilador para incluir el fichero de
cabecera:
#include "Fichero.h"
El programa principal debe incluir también todos los ficheros de cabecera

de los módulos que quiera utilizar. Esto permite que se pueda compilar por
separado del resto, pues en los ficheros de cabecera está toda la
información necesaria para utilizar las funciones de los módulos.
72
Cada vez que se modifique algo del programa y haya que compilar, sólo se
procesarán los módulos que hayan sido modificados.
Ejemplo. Modelo de programa para el cálculo de la combinatoria de m en

n, mediante módulos.
fact.h:
// Fichero de cabecera para calculo de factorial
float fact(int n);
fact.cpp:
//Funciones para el calculo del factorial
#include "fact.h"
float fact(int n){ //Calculo del factorial
float f;
int i;
f = 1;
for(i = 1; i <= n; i++)
{
f = f * i;
}
return f;
}
combinatorio.cpp:
#include <iostream.h> //Programa para el calculo de m sobre n

#include "fact.h"
int main(){
int m, n;
float comb;
cout<<"Introduce los valores de m y n";
cin>>m>>n;
73
comb=fact(m)/(fact(n)*fact(m-n));
cout<<"El resultado es:"<<comb;
return 0;
}
74
75
CAPÍTULO IV.
4. PROGRAMACIÓN ORIENTADA A OBJETOS
4.1. Definición.
Se forma como marco conceptual y conjunto de ideas para poder

comprender el desarrollo de un programa, este se fundamenta en los
objetos, clases y la relación entre objetos.
“La Programación Orientada a Objetos extiende los conceptos
fundamentales de abstracción y encapsulación de los Tipos Abstractos de
Datos (TADs), añadiendo los conceptos de Herencia, Polimorfismo, y
Vinculación Dinámica.” (V. Benjumea y M. Roldan, 2017, pg 167). Este
paradigma surge de la idea de poder una mejor abstracción de la vida
cotidiana. Podemos comprender que de esta manera nosotros podemos
claramente generalizar (Clases) e individualizar (Objetos) una situación.
A continuación, veremos definiciones de conceptos utilizados en POO y

como cual es la forma de implementarse al desarrollar un código en C + +.
4.2. Definición de clases y objetos.
Las clases son abstracciones, datos obtenidos de la realidad, de las cuales

nosotros partimos para generar objetos, esta idea se aclara con la
explicación de que, si tenemos varios autos de diferentes marcas, colores,
modelos y diferentes motores nosotros podemos representar todos los
autos en una clase.
76
(Fuente: Google Imágenes)
4.3. Definición de encapsulamiento.
“En la programación clásica existen datos y procedimientos que actúan

sobre esos datos. No hay una relación aparente entre datos y
procedimientos (funciones) y esta relación se establece de manera más o
menos precisa de acuerdo a la profesionalidad del programador” (Cortijo
Bon, F , s.f.).
Hay aspectos en un objeto estos son:
 Estado interno -> Atributos
 Procedimientos -> Métodos
4.4. Métodos y atributos.
“Los atributos almacenan los valores del estado interno de cada objeto,
considerando que cada objeto tiene un estado interno asociado,
independiente de los otros objetos (V. Benjumea y M. Roldan, 2017, pg.
167). En pocas palabras los atributos son el conjunto de características
sustanciales de cada objeto, podemos tener atributos públicos o privados,
generalmente son privados.
77
“Los métodos son algoritmos especiales definidos por la clase, y se aplican

sobre los objetos, manipulando el estado interno del objeto sobre el que se
aplican” (V. Benjumea y M. Roldan, 2017, pg. 167). Los métodos muestran
acciones que puede realizar los objetos de cada clase, pero tenemos en
cuenta que un objeto de una clase realiza la acción de una manera diferente
a otros objetos de su misma clase, un ejemplo es que un auto deportivo
puede correr a más velocidad que un auto urbano.
Para ejemplificar mejor lo mencionado anteriormente sobre clases, objetos,

atributos y métodos tenemos una imagen que lo ilustra.
4.5. Creación de clases y objetos en C++.
Donde nombre es el identificador que daremos a la clase, en declaración de

atributos declararemos los atributos y en declaración de métodos
declararemos los métodos de la clase (Ver ejemplo).
Ejemplo:
class nombre{
declaracion_de_atributos
declaracion_de_metodos
};
Ahora teniendo ya una definición sencilla podemos aplicarla para tener
una clase de tipo auto, entonces tenemos:
class Auto{
78
private:
string marca;
string modelo:
string color;
int numero_placa;
public:
void Arrancar(void);
void Acelerar(void);
void Frenar(void);
void Girar(void);
};
En la definición anterior tenemos las palabras reservadas private y public,
están nos sirven para representar mejor el encapsulamiento, tomando la
clase Auto nosotros hacemos con la palabra private reservar los atributos,
quiero decir no haciendo que el acceso sea restringido en cambio la palabra
public nos permite que estos métodos puedan en la relación con otros
objetos interactuar. Hay un momento en donde el objeto comienza su
existencia en el programa y uno en el que deja de existir, estos dos actos
se dan mediante el constructor y el destructor.
4.6. Constructores y destructores.
Los constructores se activan en el momento que un objeto es creado, esto

nos permite darle un estado interno según los parámetros ingresados, este
define el estado con las condiciones dadas, parámetros de inicialización.
Los destructores en cambio son todo lo contrario permiten un mejor manejo
de la memoria, pues al “destruir un objeto” este acto libera memoria que
puede reutilizar el programa. La sintaxis es la siguiente para el ejemplo del
Auto:
class Auto{
private:
79
string marca;
string modelo:
string color;
int numero_placa;
public:
Auto(string pm, string pmo, string pc, int pnp);//
Constructor
~Auto();// Destructor
void Arrancar(void);
void Acelerar(void);
void Frenar(void);
void Girar(void);
};
Auto::Auto(string pm, string pmo, string pc, int
pnp){//constructor
marca = pm;
modelo = pmo;
color = pc;
numero_placa = pnp;
}
Hay más conceptos que nos permiten trabajar mejor en la programación

orientada a objetos como lo son Herencia, Polimorfismo y las funciones
amigas, los primeros dos conceptos nos permiten trabajar de una manera
en la cual la eficiencia es mejorada pues nos permite tener una relación
entre clases, como por ejemplo de asociación, agregación y composición.
El último concepto nos permite tener una mejor comunicación entre el
objeto y funciones exteriores a este, se da en algunos casos en los cuales
se quiere manipular los atributos fuera del objeto, entonces la función
amiga(friend) permite esta acción.
80
4.7. Herencia y polimorfismo.
La herencia nos permite que una clase sea heredada de otra, para
ejemplificar mejor es como tener una clase Perro, pero este se deriva de la
clase Animal, entonces entiendo este concepto tenemos en cuenta que una
característica de la herencia es poder jerarquizar mejor las clases según la
problemática a resolver.

Aquí veremos la forma en C++ para implementar el concepto de
Herencia:
class Perro : public Animal{
public:
void Ladrar(void); // Propiedad exclusiva de Perro
};
class Gato : public Animal {
public:
void Maullar(void); // Propiedad exclusiva de Gato
};
Por polimorfismo se entiende que es porque puede adaptarse a diferentes

formas, entonces podemos tener que una clase tenga un método que pueda
variar en acción en la creación de sus objetos.
81
4.8. Funciones amigas(Friends).
Estas funciones no pertenecen a la clase, estas son exteriores, permiten el

manejo de los atributos de las clases de manera exterior a ellas, estas se
declaran con la palabra reservada friend. Un ejemplo que clarifica este
concepto es:
class Clase{
int EnteroPrivado;
public:
void FijaEntero(int N);
friend void FuncionAmiga(Clase &X, int N);
};
void FuncionAmiga(Clase &X, int N)
{
X.EnteroPrivado=N;//Acceso al miembro privado
}
// Si no fuese friend EnteroPrivado no estaría accesible
desde
// fuera de la clase
82
Ejemplos sobre el tema
Ejemplo 1. Cree una clase Persona de la forma:
Solución:
class persona{ // Creando Clase Persona
private:
char nombre[40];
public:
void dormir();
void hablar();
void contar();
void adquirirNombre();
void decirNombre();
};
// Declaración de funciones de la clase
void persona::dormir(){//
cout << "zzzzzzzzz" << endl;
}
void persona::hablar(){
cout << "bla bla bla bla" << endl;
}
void persona::contar(){
cout << "1, 2, 3, 4, 5..." << endl;
}
83
void persona::adquirirNombre(){
cout << "Soy una persona. Ingrese mi nombre: ";
cin >> nombre;
}
void persona::decirNombre(){
cout << "Mi nombre es: " << nombre << endl;
}
Ejemplo 2. Construya una clase llamada Rectángulo que tenga los

siguientes atributos: largo y ancho, y los siguientes métodos: perimetro()
y area():
Solución:
class Rectangulo{
private: //Atributos
float largo, ancho;
public: //Metodos
Rectangulo(float,float); //Constructor
~Rectangulo(); //Destructor
void perimetro();
void area();
};
Rectangulo::Rectangulo(float _largo,float _ancho){
largo = _largo;
ancho = _ancho;
84
}
void Rectangulo::perimetro(){
float _perimetro;
_perimetro = (2*largo) + (2*ancho);
cout<<"El perimetro es: "<<_perimetro<<endl;
}
void Rectangulo::area(){
float _area;
_area = largo * ancho;
cout<<"El area es: "<<_area<<endl;
}
Ejemplo 3. Definir complejos en notación polar, tiendo la parte real e

imaginaria y un método para mostrar notación cis:
Solución:
class Com_Polar{
private:
float modulo;
float argumento;
public:
Com_Polar(float real, float img);
void Imprimir_Datos(){
85
cout << "Notacion CIS -> " << modulo << "cis(" << arg <<
")\n";
}
};
Com_Polar::Com_Polar(float real, float img){
modulo = sqrt(pow(real, 2) + pow(img, 2));
arg = 180 * atan(img/real) * M_PI;
}
void Com_Polar::Imprimir_Datos(){
cout << "Notacion CIS -> " << modulo << "cis(" << arg << ")\n";
}
Ejemplo 4. Del diagrama UML implementa en C++:
Solución:
class persona {
private:
int Identidad;
public:
persona();
void capturarPersona();
void establecerPersona(int);
int obtenerIdentidad();
void imprimirPersona();
};
class estudiante : public persona {
86
private:
int nroCuenta;
public:
estudiante();
void capturarEstudiante();
void establecerEstudiante(int);
int obtenerNroCuenta();
void imprimirEstudiante();
};
persona::persona() {
int p = 0;
establecerPersona(p);
}
void persona::establecerPersona(int p) {
Identidad = p;
}
int persona::obtenerIdentidad() {
return Identidad;
}
void persona::capturarPersona() {
int id = 0;
cout << "Ingrese Identidad: ";
cin >> id;
establecerPersona(id);
}
void persona::imprimirPersona() {
cout <<"\nIdentidad de Persona: " << Identidad;
}
// Funciones de la clase estudiante
estudiante::estudiante() {
int cuenta = 0;
87
establecerEstudiante(cuenta);
}
void estudiante::establecerEstudiante(int c) {
nroCuenta = c;
}
int estudiante::obtenerNroCuenta() {
return nroCuenta;
}
void estudiante::capturarEstudiante() {
int nroC = 0;
cout << "Ingrese número de cuenta: ";
cin >> nroC;
establecerEstudiante(nroC);
}
void estudiante::imprimirEstudiante() {
cout <<"\nNro Cuenta Estudiante: " << nroCuenta;
}
Ejemplo 5. Crear una clase llamada Temperatura que permita inicializar la

temperatura mínima, máxima y actual. Definir una función amiga que
reciba dos objetos de la clase Temperatura y retorne la temperatura
promedio actual.
Solución:
class Temperatura {
88
int minima, maxima, actual;

public:
Temperatura(int min, int max, int act){ minima = min; maxima =
max; actual = act; }
friend int temperaturaMedia(Temperatura t1, Temperatura t2);
};
int temperaturaMedia(Temperatura t1, Temperatura t2){

int pro =(t1.actual + t2.actual)/2;
return pro;
}
89
90
CAPÍTULO V
5. ESTRUCTURAS
5.1. Definición.
Acera (2010) señala que el surgimiento de las estructuras, se debe a la

problemática para expresar diferentes tipos de datos en un array. En la
vida diaria se requieren expresar distintos tipos de datos agrupados, tales
como los datos pertenecientes a un alumno. La creación de un molde con
diferentes tipos de datos da origen a las estructuras.
Joyanes y Zahonero (2007) afirma que “las estructuras son un tipo de datos
definidos por el usuario para encapsular otros tipos de datos” (p. 97), la
sintaxis básica es:
struct nombre_estructura{
tipo1 variable1;
tipo2 variable2;
…
};
Una vez definida la estructura se define una variable del tipo de la
estructura:
91
nombre_estructura dato;
La sintaxis empleada para referenciar los miembros individuales de una

estructura utiliza el operador “.” para acceder a los miembros:
dato.variable1;
Ejercicios sobre el tema
Ejemplo 1. Cree una estructura llamada estudiante con los siguientes

datos: código de alumno, nombre, apellido paterno, apellido materno y
luego cree una variable llamada alumno1 de tipo estudiante.
#include <iostream>
struct estudiante{
int codigo_alumno;
string nombre;
string apellido_paterno;
string apellido_materno;
};
int main(){
estudiante alumno1;
return 0;
}
Ejemplo 2. Cree una estructura llamada trabajador con los siguientes

datos: DNI, nombre, apellido paterno, apellido materno y área de trabajo.
Luego cree una variable llamada colaborador y solicite los datos por teclado.
#include <iostream>
92
struct trabajador{
int DNI;
string nombre;
string area_trabajo;
};
int main(){
trabajador colaborador;
cout << "Ingrese el DNI del trabajador: ";
cin >> colaborador.DNI;
cout << "Ingrese el nombre del trabajador: ";
cin >> colaborador.nombre;
cout << "Ingrese el apellido paterno del trabajador: ";
cin >> colaborador.apellido_paterno;
cout << "Ingrese el apellido materno del trabajador: ";
cin >> colaborador.apellido_materno;
cout << "Ingrese el area de trabajo: ";
cin >> colaborador.area_trabajo;
return 0;
}
Ejemplo 3. Cree una estructura llamada estudiante con los siguientes

datos: código de alumno, nombre, apellido paterno, apellido materno y
luego cree una variable llamada alumno la cual reciba por teclado los datos
para 5 estudiantes.
#include <iostream>
struct estudiante{
int codigo_alumno;
string nombre;
93
};
int main(){
estudiante alumno[5];
for (int i=0; i<5; i++){
cout << "Ingrese el codigo " << i+1 << " : ";
cin >> alumno[i].codigo_alumno;
cout << "Ingrese el nombre " << i+1 << " : ";
cin >> alumno[i].nombre;
cout << "Ingrese el apellido paterno " << i+1 << " : ";
cin >> alumno[i].apellido_paterno;
cout << "Ingrese el apellido materno " << i+1 << " : ";
cin >> alumno[i].apellido_materno;
}
return 0;
}
Ejemplo 4. En base al ejercicio anterior, automatice la impresión de los

datos de cada alumno.
#include <iostream>
struct estudiante{
int codigo_alumno;
string nombre;
};
int main(){
estudiante alumno[5];
for (int i=0; i<5; i++){
94
cout << "Ingrese el codigo " << i+1 << " : ";
cin >> alumno[i].codigo_alumno;
cout << "Ingrese el nombre " << i+1 << " : ";
cin >> alumno[i].nombre;
cout << "Ingrese el apellido paterno " << i+1 << " : ";
cin >> alumno[i].apellido_paterno;
cout << "Ingrese el apellido materno " << i+1 << " : ";
cin >> alumno[i].apellido_materno;
}
system("cls");
for (int j=0; j<5; j++){
cout << "Datos del alumno " << j+1 << " : " << endl;
cout << alumno[j].codigo_alumno << endl;
cout << alumno[j].nombre << endl;
cout << alumno[j].apellido_paterno << endl;
cout << alumno[j].apellido_materno << endl;
system("pause");
system("cls");
}
return 0;
}
Ejemplo 5. Cree una estructura Persona con los siguientes datos: DNI,
nombre, apellido paterno y apellido materno. Luego cree una estructura
Estudiante que contenga a la estructura Persona y agregue los datos código
alumno y promedio de notas. Por último, cree una variable alumno de tipo
Estudiante y solicite la entrada de datos vía teclado.
#include <iostream>
struct Persona{
int DNI;
95
string nombre;
};
struct Estudiante{
Persona dato;
int codigo_alumno;
float promedio_notas;
};
int main(){
Estudiante alumno;
cout << "Ingrese DNI del alumno: ";
cin >> alumno.dato.DNI;
cout << "Ingrese el nombre del alumno: ";
cin >> alumno.dato.nombre;
cout << "Ingrese el apellido paterno del alumno: ";
cin >> alumno.dato.apellido_paterno;
cout << "Ingrese el apellido materno del alumno: ";
cin >> alumno.dato.apellido_materno;
cout << "Ingrese el codigo del alumno: ";
cin >> alumno.codigo_alumno;
cout << "Ingrese el promedio de notas del alumno: ";
cin >> alumno.promedio_notas;
return 0;
}
96
97
CAPÍTULO VI
6. UNIONES
Definición:
La definición de "unión" es similar a la de "estructura", La diferencia entre
las dos es que en una estructura, los miembros ocupan diferentes áreas de
la memoria, pero en una unión, los miembros ocupan la misma área de
memoria. Entonces como ejemplo:
union {
int i;
double d;
} u;
El programador puede acceder a través de "u.i" o de "u.d", pero no de

ambos al mismo tiempo. Como "u.i" y "u.d" ocupan la misma área de
memoria, modificar uno modifica el valor del otro, algunas veces de
maneras impredecibles.
El tamaño de una unión es el de su miembro de mayor tamaño.
Ejemplo de una unión

#include <stdio.h>
#include <string.h>
/*Creamos una union*/
union frases
{
char mensajes[50];
98
char ayudas[50];
char lineas[50];
} palabra;
/*Creamos una estructura*/

struct comparte
{
char mensajes[50];
char ayudas[50];
char lineas[50];
}Sistema;
/*Nótese que la estructura y la union tienen los mismos tipos de datos*/
int main(int argc, char** argv)

{
/*Inicializamos*/
strcpy(palabra.mensajes, "Primer Mensaje");
strcpy(palabra.ayudas, "Una Ayuda");
printf("\nFrases en Union: ");

/*Imprimimos*/
printf("\n1- %s", palabra.mensajes);
printf("\n2- %s", palabra.ayudas);
/*Inicializamos*/
strcpy(Sistema.mensajes, "Primer Mensaje");
strcpy(Sistema.ayudas, "Una Ayuda");
printf("\n\nFrases en Struct: ");
99
/*Imprimimos*/
printf("\n1- %s", Sistema.mensajes);

printf("\n2- %s", Sistema.ayudas);
return 0;
}
Al compilar observamos que, aunque inicializamos los valores al imprimir

se tiene el mismo valor para cada miembro de la estructura union, esto se
debe a que las uniones usan el mismo espacio de memoria para todos los
elementos de la union, siendo del tamaño de su miembro de mayor tamaño,
en este caso 50 bytes. Entonces los tres miembros creados dentro de la
union comparten esos 50 bytes. Entonces el último valor agregado a la
union es el que se tiene.
En la estructura comparte, se reservan 150 bytes de memoria para los tres

miembros, en este caso cada uno es independiente en memoria, así pues
se puede inicializar cada uno o usar como un campo independiente.
Ejemplo 1. Crear una estructura union que contenga un dato entero y otro
flotante, e imprimir las direcciones de ambas variables.
#include <stdio.h>
#include <string.h>
/*Creamos la union*/
union Ejercicio01
{
int tipo1;
float tipo2;
100
} variables;
/*Iniciamos el main*/
int main(int argc, char** argv)

{
cout << "Direccion de memoria de la primera variable: " << &tipo1
<< "\n";
cout << "Direccion de memoria de la segunda variable: " << &tipo2
<< "\n";
cout << "Podemos observar que ocupan la misma posición de memoria."
<< "\n";
return 0;
}
101
102
CAPÍTULO VII.
7. ENUMERACIONES
Las variables enumeradas, enumeraciones o más abreviadamente enum

(palabra reservada), son un tipo especial de variables que tienen la
propiedad de que su rango de valores es un conjunto de constantes enteras
denominadas constantes de enumeración, a cada una de las cuales se le
asigna un valor.
Es un tipo definido por el usuario que contiene un conjunto de nombres,
llamados enumerados, los cuales son constantes enteras.
El objetivo es agrupar constantes simbólicas, las cuales proporcionan más
claridad a nuestros programas
Ejercicios sobre el tema
Ejemplo 1.
#include <iostream>
main(){
enum TipoEleccion {Piedra=3, ladrillo = 5, cemento=2};
TipoEleccion Eleccion; //Definimos Figura de tipo enumerado TipoEleccion
//Revisamos el valor predeterminado que asigna el compilador a los
enumeradores
cout << "Valor de Piedra: " << Piedra << endl;
cout << "Valor de ladrillo: " << ladrillo << endl;
cout << "Valor de cemento: " << cemento << endl;
system("pause"); system("cls");
}
103
Ejemplo 2.
#include <iostream>
main(){
enum Tipofigura {cuadrado, triangulo, circulo,pentagono};
Tipofigura figura;
switch (figura){
case cuadrado: cout << " cuadrados "; break;
case triangulo: cout << " triangulo "; break;
case circulo: cout << " circulo "; break;
case pentagono: cout << " pentagono "; break;
}
enumeradores
cout << "Valor del cuadrado: " << cuadrado << endl;
cout << "Valor del triangulo: " << triangulo << endl;
cout << "Valor del circulo: " << circulo << endl;
cout << "Valor del pentagono: " << pentagono << endl;
system("pause"); system("cls");
}
Ejemplo 3.
#include <iostream>
main(){
enum TipoSemana {lunes=1, martes = 2, miercoles=3, jueves=4,
viernes=5, sabado=6, domingo=7};
TipoSemana Semana;
104

enumeradores
cout << "Valor de lunes: " << lunes << endl;
cout << "Valor de martes: " << martes << endl;
cout << "Valor de miercoles: " << miercoles << endl;
cout << "Valor de jueves: " << jueves << endl;
cout << "Valor de viernes: " << viernes << endl;
cout << "Valor de sabado: " << sabado << endl;
cout << "Valor de domingo: " << domingo << endl;
system("pause");
system("cls");
}
Ejemplo 4.
#include <iostream>
main () {
enum TipoAnio {enero=1, febrero=2, marzo=3, abril=4, mayo=5,
junio=6, julio=7, agosto=8, septiembre=9, octubre=10, noviembre=11,
diciembre=12};
TipoAnio Anio; //Definimos Figura de tipo enumerado TipoEleccion
enumeradores
cout << "Valor de enero: " << enero << endl;
cout << "Valor de febrero: " << febrero << endl;
cout << "Valor de marzo: " << marzo << endl;
cout << "Valor de abril: " << abril << endl;
cout << "Valor de mayo: " << mayo << endl;
cout << "Valor de junio: " << junio << endl;
cout << "Valor de julio: " << julio << endl;
cout << "Valor de agosto: " << agosto << endl;
105
cout << "Valor de septiembre: " << septiembre << endl;

cout << "Valor de octubre: " << octubre << endl;
cout << "Valor de noviembre: " << noviembre << endl;
cout << "Valor de diciembre: " << diciembre << endl;
system("pause");
system("cls");
}
Ejemplo 5.
#include <iostream>
main () {
enum Tipomascota {perro=1, gato=2, conejo=3, raton=4};
Tipomascota mascota;
enumeradores
cout << "Valor de perro: " << perro << endl;
cout << "Valor de gato: " << gato << endl;
cout << "Valor de conejo: " << conejo << endl;
cout << "Valor de raton: " << raton << endl;
system("pause");
system("cls");
}
106
107
CAPÍTULO VIII
8. PUNTEROS
8.1. Definición.
Los punteros o apuntadores son variables que se utilizan para almacenar

direcciones de memoria, puntualmente las direcciones de memoria que
fueron asignadas a variables convencionales en las que se almacenan datos
de distinto tipo.
Vale recordar que a todas las variables en C++ se les asigna un espacio de
memoria en el cual se va almacenar el valor que se le asigne en algún punto
de la aplicación a esa variable, el tamaño de dicho espacio va depender del
tipo de dato que se pretende almacenar en la variable, del compilador y de
la arquitectura del procesador. Cada uno de los espacios de memoria
cuenta con una dirección para identificarlo, esta dirección es por lo general
un número en representación hexadecimal. Es precisamente ese número
correspondiente a la dirección lo que se almacena en un puntero.
Los punteros por muy complejos que se lea, al final solo dependerá de dos
elementos &(ampersand) y *(asterisco).Estos son de gran ayuda al
momento de necesitar valores y estructuras dinámicas, por ejemplo para
crear un array dinámico, con dinámico quiere decir que su tamaño puede
ser establecido en tiempo de ejecución y lo mismo con las matrices (que
en realidad son un array multidimensional).
8.2. Detalles al crear y usar punteros en C++.
El tipo de dato del apuntador debe coincidir con el de la variable cuya

posición en memoria apuntan. En el ejemplo veremos que tanto variable
como apuntador son enteros.
108
Si se quiere usar el apuntador se debe anteponer el asterisco (*) para

indicar que se usará el valor en la posición de memoria apuntada.
De no usar el asterisco el comportamiento sería impredecible. Se usará la
dirección de memoria más no del valor almacenado en ésta.
Después de usar un puntero, especialmente si trabajamos con arreglos o
matrices, es muy recomendable liberar la memoria utilizada con la función
delete.
Un puntero o apuntador puede ser de cualquier tipo de dato, inclusive los
podemos usar con tipos complejos.
A continuación, se definirá formalmente la utilidad del operador & y del
asterisco *.
8.3. Los punteros y el ampersand.
El ampersand es un operador de C++ y es comúnmente utilizado para los

punteros. Este operador permite obtener la dirección de memoria de una
variable cualquiera y es justo esto (la dirección en memoria) lo que utilizan
los punteros para referenciar valores.
Los apuntadores y el asterisco

El asterisco es, por decirlo de alguna forma, el operador por excelencia de
los punteros. Su utilidad radica en que si el valor de dicho apuntador
corresponde a una dirección de memoria, el asterisco nos permite
resolverla y acceder al valor almacenado allí. Viéndolo desde otro enfoque,
un apuntador es únicamente una dirección de memoria (un número) y el
asterisco es el que hace la magia de obtener el valor referenciado por dicha
dirección.
Observe la siguiente imagen de ejemplo, se declara una variable var y se

inicializa directamente en la declaración, esta variable recibe un espacio en
109
memoria para almacenar el valor que se le asigna en la inicialización. Dicho

espacio en memoria tiene su propia dirección para poder ser referenciado.
(Fuente: Google imágenes)
Se puede declarar un puntero para almacenar la dirección de memoria

correspondiente a la variable var, es decir, se puede "apuntar" un puntero
a la variable var. Para declarar un puntero se utiliza la sintaxis para
declaración de variables: calificadores opcionales, modificadores
opcionales, tipo de dato obligatorio y un identificador para el puntero que
también es obligatorio.
El tipo de dato del puntero debe ser obligatoriamente el mismo tipo de dato
de la variable a la que se pretende apuntar, es decir, si se requiere
almacenar la dirección en memoria de una variable de tipo int, entonces el
tipo de dato del puntero también debe ser int. Un puntero se distingue de
otras variables porque en su declaración se utiliza el operador * luego del
tipo de dato y antes del identificador del puntero. Observe a continuación
la declaración de varios punteros:
Ejemplo 1.
#include <iostream>
#include <stdio.h>
int funcion(int valor)
{
110
valor = valor + 10; //Se le suma 10

return valor;
}
int funcionPunteros(int* valor)
{
*valor = *valor + 10; //Se le suma 10 a la posición en memoria
return *valor;
}
int main()
{
int numero = 10;
cout << "Antes de funcion " << numero << "\n";
//n tendrá el valor de 10.
funcion(numero); //Se pasa por valor
cout << "Despues de funcion " << numero << "\n";
cout << "Antes de funcionPunteros " << numero << "\n";
funcionPunteros(&numero);
//Se envía la dirección de memoria y la función resuelve la referencia
cout << "Despues de funcionPunteros " << numero << "\n";
system("pause");
return 0;
}
Como podrás comprobar si ejecutas el código del ejercicio 1 al llamar a

"funcion" sólo enviamos el valor y por ende éste no es modificado por fuera
de la función, con "funcionPunteros" estamos manipulando la posición en
memoria del parámetro recibido (por eso usamos el *) y por ende al
ejecutarla el valor de la variable se modifica. De ese modo ya hicimos el
111
primer ejercicio con punteros en C++ y ya comprendemos el paso por

referencia.
Para nuestro siguiente caso tenemos que tener la versión de TDM-GCC
actualizada, para ver si esta actualizado compilamos este pequeño código
en nuestro dev:
Ejemplo 2.
#include <stdio.h>
int main(void) {
ndif /* == */
#endif /* __STDC_VERSION__ */
#ifdef __cplusplus
printf("Aparentemente compilado con un compilador de C++\n");
# if __cplusplus >= 201103L
printf("Este codigo fue compilado bajo un estandar mayor o igual a
C++11.\n");
# else
printf("Este codigo fue compilado bajo un estandar menor a
C++11.");
# endif /* >= */
#endif /* __cplusplus */
#ifdef __STDC_VERSION__
printf("Aparentemente compatible con __STDC_VERSION__\n");
# if __STDC_VERSION__ == 199901L
printf("Este código fue compilando con el estandar C99.\n");
# elif __STDC_VERSION__ == 201112L
printf("Este codigo fue compilado con el estandar C11.\n");
# else
printf("Este codigo fue compilado con el estandar C94.\n");
# e
#ifdef __STDC__
112
printf("Aparentemente compatible con __STDC__ y los estandares

C89 y C90 ...\n");
#endif /* __STDC__ */
}
Si nos aparece que es compatible pero que este codigo fue compilado bajo
un estandar menor a C++ 11. entonces tendremos que actualizar nuestro
compilador. Para este caso tendremos que entrar Aquí:
https://github.com/jmeubank/tdm-gcc/releases/download/v9.2.0-tdm64-
1/tdm64-gcc-9.2.0.exe
Una vez instalado nuestro nuevo compilador ya podremos continuar con los
ejemplos, dejare link de instalación:
https://www.youtube.com/watch?v=1BudFAPpQ1E
Bueno sin más problemas seguiremos con la explicación.
Ejemplo de punteros (Array Dinámico):

Para este ejercicio retomaré el ejemplo del artículo de arreglos o vectores:
Queremos crear un programa con el cual podamos guardar los títulos y los
autores de diferentes libros sin perder ninguno de ellos. El usuario es el
encargado de suministrar la información de cada libro. En esta ocasión ya
sabemos usar punteros, así que será también el usuario quien nos diga
cuántos libros desea ingresar, ya no necesitamos suponer que sólo
ingresará 5 libros. Veamos:
Ejemplo 1.
#include "iostream"
#include "stdio.h"
#include "string"
int main()
{
113
int cols = 2; //El número de columnas es fijo (sólo título y autor)

string** libros; //Si inicializa la matriz (punteros de punteros)
int tamanio ; //Se inicializa la variable
cout << "Cuantos libros desea ingresar?";
string entrada;
getline(cin, entrada); //Se asigna el valor ingresado
tamanio = stoi(entrada); //Se transforma la entrada en número
libros = new string*[tamanio];//Se asigna el número de filas según el
usuario
cout << "Por favor ingrese la siguiente información de los Libros: \n";
string titulo ,autor;
for(int i = 0; i < tamanio; i++)
{
libros[i] = new string[cols]; //Cada fila contendrá dos columnas
//Notar que cols pudo haber sido ingresada por el usuario también
cout << "\n******* Libro " << i + 1 << "********:\n";
cout << "Titulo: ";
getline(cin,titulo);
cout << "Autor: ";
getline(cin,autor);
libros[i][0] = titulo;
libros[i][1] = autor;
}
//Para liberar la memoria debemos recorrer fila por fila primero.

for (int i = 0; i < tamanio; ++i)
{
delete [] libros[i]; //Cada fila de libros es otro array de punteros
//Por eso son punteros a punteros
}
//Luego de limpiar las columnas, quitamos la fila única que quedó
114
delete [] libros;
system("pause");
return 0;
}
Así entonces tuvimos dos punteros, uno para todos los autores y otro para
todos los títulos. Haciendo uso de ellos pudimos definir la cantidad de libros
a ingresar por medio del usuario, es decir lo hicimos de manera dinámica,
en tiempo de ejecución.
Ejemplo de Punteros (Matriz Dinámica):

Así como lo hicimos con los array, también podemos tener matrices
dinámicas y definir su tamaño, número de filas o número de columnas (o
las dos) según sea necesario.
int tamanio ; //Se inicializa la variable
Para esto se tomará el mismo ejemplo de los libros, pero usando una
matriz, en vez de dos vectores. Tal y como se solucionó en la sección de
matrices veamos:
Ejemplo 1.
#include "iostream"
#include "stdio.h"
#include "string"
int main()
{
int cols = 2; //El número de columnas es fijo (sólo título y autor)
string** libros; //Si inicializa la matriz (punteros de punteros)
cout << "Cuantos libros desea ingresar?";
115
string entrada;
getline(cin, entrada); //Se asigna el valor ingresado
tamanio = stoi(entrada); //Se transforma la entrada en número
libros = new string*[tamanio];//Se asigna el número de filas según el
usuario
cout << "Por favor ingrese la siguiente información de los Libros: \n";
string titulo ,autor;
for(int i = 0; i < tamanio; i++)
{
libros[i] = new string[cols]; //Cada fila contendrá dos columnas
//Notar que cols pudo haber sido ingresada por el usuario también
cout << "\n******* Libro " << i + 1 << "********:\n";
cout << "Titulo: ";
getline(cin,titulo);
cout << "Autor: ";
getline(cin,autor);
libros[i][0] = titulo;
libros[i][1] = autor;
}
//Para liberar la memoria debemos recorrer fila por fila primero.
for (int i = 0; i < tamanio; ++i)
{
delete [] libros[i]; //Cada fila de libros es otro array de punteros
//Por eso son punteros a punteros
}
//Luego de limpiar las columnas, quitamos la fila única que quedó
delete [] libros;
system("pause");
return 0;
}
116
En el ejercicio 1 es el perfecto para aclarar dudas o darse cuenta si

realmente comprendes el concepto de apuntadores y su aplicación para
arrays dinámicos. Debido a que la cantidad de columnas es fija, no se lo
pedimos al usuario, simplemente lo declaramos con valor dos. Luego
tenemos el puntero, pero no es un puntero cualquiera, al ser una matriz,
será un puntero que tendrá otros punteros adentro, por eso se usa doble
asterisco, entonces se obtiene el tamaño del usuario (cantidad de libros) y
al momento de inicializar la fila estamos indicando que es un arreglo de
punteros, por eso se usa el * en la línea 23.
Luego al interior del ciclo, cuando estamos llenando la matriz, debemos
indicar que cada fila estará compuesta por un array de punteros de tamaño
dos (dos columnas) y así construimos nuestra matriz dinámica.
Debes notar también que la liberación de la memoria es un poco más
trabajosa, pues debemos ir fila por fila liberando la memoria de las
columnas creadas y luego liberar la fila completa. Ahí podrás notar la
diferencia en eficiencia y uso de memoria al usar arreglos o usar matrices.
Ejemplo de Punteros(Aritmética de Punteros):

Los punteros almacenan un valor que corresponde a una dirección de
memoria y el lenguaje de programación C++ permite que un puntero pueda
recibir una nueva dirección de memoria, es decir que sea apuntado a otra
variable. Es claro que esto último sólo se podrá lograr si la nueva posición
de memoria almacena un dato del mismo tipo del puntero o si se hace una
conversión explícita del tipo de dato del puntero.
Para poder desplazar un puntero por la memoria C++ permite ejecutar los
operadores de adición y sustracción en los punteros, por tanto la dirección
que almacena el puntero se puede incrementar o decrementar de acuerdo
a la operación que se involucre al puntero. Está permitido el uso de los
siguientes operadores: +, -, ++ y -- para ejecutar operaciones de
aritmética de punteros.
117
Observe el siguiente ejemplo 1 que ilustra el concepto. Puede observar la

diferencia entre las direcciones de memoria cada vez que se hace un
aumento en la dirección del puntero:
Ejemplo 1.
#include<iostream>
int main()
{
int array[3] = {15, 35, 55};
int *ptr = array; // No se usa el operador '&' porque los arreglos se
comportan como punteros
cout<<"Direccion almacenada por ptr: "<<ptr<<endl;

cout<<"Valor en la direccion almacenada por ptr: "<<*ptr<<endl;
cout<<"Direccion almacenada por ptr + 1: "<<ptr+1<<endl;
cout<<"Valor en la direccion almacenada por ptr + 1:
"<<*(ptr+1)<<endl;
cout<<"Direccion almacenada por ptr + 2: "<<ptr+2<<endl;
cout<<"Valor en la direccion almacenada por ptr + 2:
"<<*(ptr+2)<<endl;
return 0;
}
Ejecute y analice el ejemplo 2 a continuación. ¿Puede explicar los

incrementos que se hacen al puntero? ¿Por qué se incrementa el puntero
en esas cantidades aún sabiendo que los miembros de la estructura están
en posiciones contiguas de memoria?
118
Ejemplo 2.
#include<iostream>
/* Estructura con miembros de distintos tipos de datos */
struct Clase
{
char mem1 = 'D';
double mem2 = 12345678987654321.88888888888889;
unsigned short mem3 = 4554;
float mem4 = 3.14159;
long long int mem5 = 5444333222;
char mem6 = 'X';
int mem7 = 434776;
double mem8 = 2.35656778457911;
};
int main()
{
struct Clase local_struct; // Estructura local de tipo struct Clase
struct Clase *ptr_str = &local_struct; // Puntero a variables (objetos)
del tipo de la estructura struct Clase
/* Acceso a través del puntero ptr_str a los miembros de local_struct,

mediante conversion explicita (casting) y aritmetica de punteros */
/* 1. El puntero ptr_str que es del tipo *struct Clase debe convertirse a

un puntero del tipo de dato al que se quiere acceder, por ejemplo: a un
dato char, entonces se debe convertir asi (char*)ptr_str */
119
/* 2. Con el operador asterisco se debe acceder al valor almacenado en

la dirección a la que apunta el puntero ptr_str convertido: *((char*)ptr_str)
*/
/* 3. Con aritmetica de punteros se puede desplazar al puntero ptr_str

a traves de las posiciones de memoria donde se almacenan los miembros
de la estructura, por ejemplo: *((double*)ptr_str+1) */
cout<<*((char*)ptr_str)<<endl;
cout<<*((double*)ptr_str+1)<<endl;
cout<<*((short*)ptr_str+8)<<endl;
cout<<*((float*)ptr_str+5)<<endl;
cout<<*((long long int*)ptr_str+3)<<endl;
cout<<*((char*)ptr_str+32)<<endl;
cout<<*((int*)ptr_str+9)<<endl;
cout<<*((double*)ptr_str+5)<<endl;
return 0;
}
120
121
CAPÍTULO IX
9. ARCHIVOS
9.1. Definición.
Gary. J Broson nos dice que un archivo o fichero es una colección de datos
almacenados juntos bajo un nombre común, por lo general en un disco,
cinta magnética o CD-ROM. Un archivo se almacena en forma física en un
medio externo como un disco. Cada archivo tiene un nombre de archivo
único conocido como el nombre externo del archivo.
9.2. Flujos de archivos.
Es necesario un objeto de flujo donde no debe influir el tipo de archivo

para que este pueda leer y escribir del archivo.
 Entrada:
Se declaran mediante el tipo ifstream.
 Salida:
Se declaran mediante el tipo ofstream.
Ejemplo 1: FORMATO BASE DE ENTRADA

int main () {
ofstream myfile;
myfile.open ("EJEMPLO.txt");
myfile << "MI PRIMER ARCHIVO\n";
myfile.close();
return 0;
}
122
Ejemplo 2: EL MISMO PROBLEMA, PERO CON LA LECTURA

#include <iostream>
#include <fstream>
#include <string>
int main () {
string line;
ifstream myfile ("EJEMPLO 3 .txt");
if (myfile.is_open()){
while ( getline (myfile,line) )
{
cout << line << '\n';
}
myfile.close();
}
else {
cout << "NO SE PUEDE ABRIR EL ARCHIVO";
}
return 0;
}
Ejemplo 3: USAMOS LA ENTRADA Y SALIDA

#include <fstream>
#include<iostream>
int main (int argc , char *argv[]){
char cadena [128];
//crear fichero salida
ofstream fs("nombre.txt");
fs <<"ARCHIVO"<<endl;
123
/*cerar el fichero , para luego arbirlo para la lectura */

ifstream fe("nombre.txt");
fe.getline(cadena , 128);
cout<<cadena<< endl;
}
Ejemplo 4:
#include <iostream>
#include <fstream.h>
int main (int argc, char*argv[])
{
char cadena [128];
ifstream dfe ("ejemplo4.cpp");
while(!fe.eof())
{
fe>>cadena;
cout<<cadena<<endl;
}
fe.close();
system("PAUSE");
return EXIT_SUCCESS;
}
9.3. Tipos de archivos básicos.
9.3.1. Archivos basados en caracteres

Se usa para almacenar información que pueda o deba ser manipulada con
un editor de texto.
124
Ejemplo 1:
Realice un programa que pida al usuario el nombre de un fichero
de texto y, a continuación, permita almacenar al usuario tantas frases
como el usuario desee.
#include<iostream>
#include<stdlib.h>
#include<fstream>
void escribirFrases();
int main(){
escribirFrases();
system("pause");
return 0;
}
void escribirFrases(){
ofstream archivo;
string nombreArchivo,frase;
char rpt;
cout<<"Digite el nombre del archivo: ";
getline(cin,nombreArchivo);
archivo.open(nombreArchivo.c_str(),ios::out); //Creamos el archivo
if(archivo.fail()){ //Si a ocurrido algun error
cout<<"No se pudo abrir el archivo";
exit(1);
}
do{
fflush(stdin);
cout<<"Digite una frase: ";
getline(cin,frase);
archivo<<frase<<endl;
125
cout<<"\nDesea agregar otra frase(S/N): ";

cin>>rpt;
}while((rpt == 'S') || (rpt == 's'));
archivo.close(); //Cerramos el archivo
}
Ejemplo 2:
Realice un programa que pida al usuario el nombre o ubicación de un fichero
de texto y a continuación de lectura a todo el fichero.
#include<iostream>
#include<stdlib.h>
#include<string.h>
#include<fstream>
void lectura();
int main(){
lectura();
system("pause");
return 0;
}
void lectura(){
ifstream archivo;
string nombreArchivo,texto;
cout<<"Digite el nombre o la ubicacion del archivo o fichero: ";
archivo.open(nombreArchivo.c_str(),ios::in); //Abrimos el archivo
en modo lectura
if(archivo.fail()){
exit(1);
}
126
while(!archivo.eof()){ //mientras no sea final del archivo

getline(archivo,texto);
cout<<texto<<endl;
}
archivo.close(); //Cerramos el archivo
}
Ejemplo 3:
Realice un programa que pida al usuario el nombre o ubicación de un fichero
de texto y, a continuación añada texto en él hasta que el usuario lo decide.
#include<iostream>
#include<stdlib.h>
#include<string.h>
#include<fstream>
void aniadir();
int main(){
aniadir();
system("pause");
return 0;
}
void aniadir(){
ofstream archivo;
string nombreArchivo,texto;
char rpt;
cout<<"Digite el nombre o ubicacion del archivo: ";
archivo.open(nombreArchivo.c_str(),ios::app); //Abrimos el archivo
en modo añadir
if(archivo.fail()){
127
exit(1);
}
do{
fflush(stdin);
cout<<"Digite una frase: ";
getline(cin,texto);
archivo<<texto<<endl;
cout<<"Desea agregar otra frase? (s/n): ";
cin>>rpt;
}while((rpt == 'S') || (rpt == 's'));
archivo.close();
}
9.3.2. Archivos basados en binarios

Son útiles cuando necesitamos guardar información de no están limitados.
Pantigoso (2017) se refiere a que este tipo de ficheros nos permite
almacenar estructuras completas, en las que se mezclen datos de
cadenas con datos numéricos.
Ejemplo 1:
Lectura de archivo binario:
#include <iostream>
#include <fstream>
int main(){
streampos size;
char * memblock;
ifstream file ("EJEMPLO BINARIO", ios::in|ios::binary|ios::ate);
if (file.is_open()){
size = file.tellg();
memblock = new char [size];
128
file.seekg (0, ios::beg);

file.read (memblock, size);
file.close();
cout << "todo el contenido del archivo está en la memoria";
delete[] memblock;
}
else {
cout << "NO SE PUEDE ABRIR EL ARCHIVO";
}
return 0;
}
Ejemplo 2:
En este ejemplo vamos a escribir un archivo binario.
#include <fstream>
#include <iostream>
int main(){
ifstream origen("foto.jpg", ios::binary);
ofstream destino("CopiaFoto.jpg", ios::binary);
// QUITE ios::binary y vea el resultado
char byte;
while( !origen.eof() && !origen.fail() ){
origen.read((char *) & byte, sizeof(char));
if(origen.good()){
destino.write((char *) & byte, sizeof(char));
}
}
destino.close();
origen.close();
return 0;
129
Ejemplo 3:
#include <iostream>
#include <fstream>
#include <cstdlib>
#include <string.h>
struct tipoRegistro{
char nombre[32];
int edad ;
float altura ;
};
int main (int argc, char *argv[]){
tipoRegistro reg1;
tipoRegistro reg2;
ofstream fsalida("prueba.dat",ios::out | ios::binary );
strcpy(reg1.nombre, "Robert Jaime");
reg1.edad=31;
reg1.altura = 1.68;
fsalida.write((char *)&reg1,sizeof(tipoRegistro));
fsalida.close();
ifstream fentrada("prueba.dat", ios::in | ios::binary);
fentrada.read((char*)&reg2,sizeof(tipoRegistro));
cout<<reg2.nombre<<endl;
cout<<reg2.edad<<endl;
cout<<reg2.altura<<endl;
fentrada.close();
system("PAUSE");
}
130
131
CAPÍTULO X
10. MÉTODOS DE ORDENAMIENTO
10.1. Definición.
La ordenación o clasificación de datos es la operación de arreglar los

registros de una tabla, y disponer estos datos en algún orden determinado
con respecto a uno de los campos de elementos del conjunto. Una colección
de datos puede ser almacenada en un archivo, un array (vector), un array
de registros, una lista enlazada o un árbol. (Sánchez, p.248)
Cuando los datos son almacenados en un array, lista enlazada o árbol, se
denomina ordenación interna, el otro caso es si los datos están
almacenados en un archivo, el proceso de ordenación se llama ordenación
externa.
El propósito de un ordenamiento es facilitar las búsquedas de los miembros
del conjunto ordenado. El ordenar un conjunto de datos significa mover los
datos para que queden en una secuencia tal que represente cierto orden,
lo cual puede ser numérico, alfabético, ascendente o descendente.
10.2. Ordenamiento por selección.
Todo ordenamiento tiene un invariante que permite asegurarse de que cada

paso que se toma va en la dirección de obtener una lista ordenada.
Descripción:
 Busca el elemento más pequeño de la lista.
 Lo intercambia con el elemento ubicado en la primera posición de la
lista.
 Busca el segundo elemento más pequeño de la lista.
 Lo intercambia con el elemento que ocupa la segunda posición en la
lista.
132
 Repite este proceso hasta que haya ordenado toda lista.
Este algoritmo solo necesita una variable adicional para realizar los
intercambios. El ciclo externo se ejecuta “n” veces para una lista de “n”
elementos, en el algoritmo cada búsqueda requiere comparar todos los
elementos no clasificados.
Ejemplo:
#include<iostream>
#include<conio.h>
int main(){
int numeros[]={6,8,14,9,20};
int i,j,aux,min;
for(i=0;i<5;i++){
min=i;
for(j=i+1;j<5;j++){
if(numeros[j]<numeros[min]){
min=j;
}
}
aux=numeros[i];
numeros[i]=numeros[min];
numeros[min]=aux;
}
cout<<”ordenamiento de forma ascendente”;
for(i=0;i<5;i++){
cout<<numeros[i]<<” “;
}
return 0;
}
133
10.3. Ordenamiento por burbuja

La ordenación por burbuja se basa en comparar elementos adyacentes de
la lista (vector) e intercambiar sus valores si están desordenados. De este
modo se dice que los valores más grandes burbujean hacia la parte superior
de la lista (hacia el último elemento), mientras que los valores más
pequeños se hunden hacia el fondo de la lista. En el caso de un
array(lista)con n elementos, la ordenación por burbuja requiere hasta n-1
pasadas.
La primera pasada realiza los siguientes pasos: el vector tiene los
elementos A[0], A[1], … ,A[n-1]. El método comienza comparando A[0]
con A[1]; si están desordenados, se intercambian entre sí.
A continuación se compara A[1] con A[2], realizando el intercambio entre
ellos si están desordenados. Se continúa comparando A[2] con A[3],
intercambiandolos si están desordenados…, hasta comparar A[n-2] con
A[n-1] intercambiandolos si están desordenados. Al terminar esta pasada
el elemento mayor está en la parte superior de la lista.
La segunda pasada realiza un proceso parecido al anterior, pero la última
comparación y, por tanto, el último posible intercambio es realizado con los
elementos A[n-3] y A[n-2] y, por tanto, coloca el segundo elemento mayor
en la posición A[n-2].
El proceso descrito se repite durante n-1 pasadas teniendo en cuenta que
en la pasada i se ha colocado el elemento mayor de las posiciones 0, … ,n-
i en la posición n-i. De esta forma, cuando i toma el valor n-2, el vector
está ordenado. (Sánchez, pag. 249)
El siguiente ejemplo muestra el proceso de forma gráfica:
134
Ejemplo:
#include<iostream>
#include<conio.h>
int main(){
int numeros[]={15,35,55,10,25};
int i,j,aux;
for(i=0; i<5; i++){
for(j=0; j<5; j++){
if(numeros[j]>numeros[j+1]){
aux=numeros[j];
numeros[j]=numeros[j+1];
numeros[j+1]=aux;
}
}
}
//imprimir
cout<<”Ordenado ascendentemente”;
for(i=0; i<5; i++){
135
cout<<numeros[i]<<” “;
}
return 0;
}
10.4. Ordenamiento por inserción

El ordenamiento por inserción es una manera muy natural de ordenar para
un ser humano, y puede usarse fácilmente para ordenar un mazo de cartas
numeradas en orden arbitraria.
Este método consiste en tomar una sublista inicial con un único elemento
que se podrá considerar siempre ordenada. En la sublista ordenada se irán
insertando sucesivamente los restantes elementos de la lista inicial, en el
lugar adecuado para que dicha sublista no pierda la ordenación.
El algoritmo considera que la sublista A[0], A [1], … , A[i-1] está ordenada,
posteriormente inserta el elemento A [i] en la posición que le corresponda
para que la sublista A[0], A [1], … ,A[i-1], A[i] esté ordenada, moviendo
hacia la derecha los elementos que sean necesarios. La sublista ordenada
aumentará su tamaño cada vez que se inserte un elemento hasta llegar a
alcanzar el de la lista original, momento en el que habrá terminado el
proceso. Los métodos de ordenación por inserción pueden ser directo o
binario, dependiendo de que la búsqueda se realice de forma secuencial o
binaria. (Sánchez,pág.251)
Características:
 Funcionamiento sencillo
 Estabilidad
 No intercambia registros con claves iguales.
 Una variable adicional puede realizar los intercambios.
 El número de intercambios puede reducirse en aproximadamente un
25% para los datos aleatorios, esto hace que tenga mejor
rendimiento.
136
 La secuencia destino donde debe insertarse el nuevo elemento ya

está ordenada.
Ejemplo 1:
#include<iostream>
#include<conio.h>
int main(){
int numeros[]={19,30,65,11,35};
int i,p,aux;
for(i=0; i<5; i++){
p=i;
aux=numeros[i];
while((p>0)&&(numeros[p-1]>aux)){
numeros[p]=numeros[p-1];
p--;
}
numeros[p]=aux;
}
cout<<”Ordenado ascendentemente”;
for(i=0; i<5; i++){
cout<<numeros[i]<<” ”;
}
return 0;
}
Ejemplo 2:
// ordenamiento por inserción binaria
#include <iostream>
int p, n=5, i;
137
int izquierda, derecha, central, aux;

int vector[5]= {15, 10, 21, 9, 18};
main(){
for(p = 1; p< n; p++){
aux = vector[p];
izquierda = 0;
derecha = p-1;
while(izquierda <= derecha){
central = int( (izquierda + derecha) / 2);
if(aux <= vector[central]){
derecha = central - 1;
}
else{
izquierda = central + 1;
}
}
// desplazando hacia la derecha los elementos ordenados para
insertar el nuevo
for(i = (p-1); i >= izquierda; i--){
vector[i+1] = vector[i];
}
vector[izquierda] = aux;
}
//Imprimir ordenado
for(i= 0; i < 5; i++){
cout << vector[i] << " ";
}
}
138
10.5. Ordenación Shell.

La ordenación Shell se suele denominar también ordenación por inserción
con incrementos decrecientes. Es una mejora de los métodos de inserción
directa y burbuja, en el que se comparan elementos que pueden ser no
contiguos.
La idea general del algoritmo es la siguiente. Se divide la lista original (n
elementos) en n/2 grupos de dos elementos, con un intervalo entre los
elementos de cada grupo de n/2 y se clasifica cada grupo por separado (se
comparan las parejas de elementos y si no están ordenados se
intercambian entre sí de posiciones). Se divide ahora la lista en n/4 grupos
de cuatro con un intervalo o salto de n/4 y, de nuevo, se clasifica cada
grupo por separado. Se repite el proceso hasta que, en un último paso, se
clasifica el grupo de n elementos. En el último paso el método shell coincide
con el método de la burbuja. (Sánchez, pág.253)
Características:
 Se basa en comparaciones e intercambios.
 Necesita que el tiempo de acceso a cualquier dato sea constante (es
decir, fue ideado para trabajar con arrays, arrays de referencias o
punteros, etc…)
 No es estable: dados dos elementos que al compararlos sean
“iguales” -es decir, que pueden ir indistintamente en la misma
posición, no mantienen necesariamente el orden relativo inicial entre
ellos.
 El estudio de su complejidad no es trivial, sino todo lo contrario. La
implementación original de Shell tiene una complejidad en el peor
caso de O(n2), aunque en un caso promedio o en casos típicos
comprobados empíricamente, los resultados son mucho mejores que
con la burbuja, selección directa o inserción directa, cuya complejidad
en el peor caso también es del orden de O(n2).
139
En cierto modo, puede considerarse una ampliación del algoritmo de

inserción directa, con lo cual, conviene tenerlo claro antes de meterse con
el de Shell.
No es un algoritmo en-línea.
En el código anterior se observa que se comparan pares de elementos

indexados por j y k, (a[j],a[k]), separados por un salto, intervalo. Así, si
n=8 el primer valor de intervalo = 4, y los índices i=5, j=1, k=6. Los
siguientes valores de los índices son i=6, j=2, k=7, y así hasta recorrer la
lista. Para realizar un nuevo recorrido de la lista con la mitad de grupos, el
intervalo se hace la mitad: intervalo <- intervalo / 2, así se repiten los
recorridos por la lista, mientras intervalo > 0(Donald E. Knuth, 1998,
pág.179)
10.6. Ordenamiento HeapSort

Este método es también conocido con el nombre “montículo” en el mundo
de habla hispana. Su nombre se debe a su autor J. W. J. Williams quien lo
bautizó así en 1964. Es el más eficiente de los métodos de ordenación que
trabajan con árboles.
140
Funcionamiento:
Este algoritmo consiste en almacenar todos los elementos en un montículo
y luego extraer el nodo que queda como raíz en iteraciones sucesivas
obteniendo el conjunto ordenado. Para esto el método realiza los siguientes
pasos:
1. Se construye el Heap/montículo a partir del arreglo original
2. La raíz se coloca en el arreglo.
3. El último elemento del montículo se vuelve la raíz.
4. La nueva raíz se intercambia con el elemento de mayor valor de
cada nivel.
5. Tras el paso anterior la raíz vuelve a ser el mayor del montículo
6. Se repite el paso 2 hasta que quede el arreglo ordenado.
Ejemplo:
#include <iostream>
#define max 100
main(){
int B[max],j,pos,aux,i,P,n;
cout<<"Cantidad de elementos: ";
cin>>n;
for(i=1;i<=n;i++){
cin >> B[i];
}
for(P=n;P>0;P--){
for(i=1;i<=P;i++){
pos=B[i];
j=i/2;
while(j>0 && B[j]<pos){
B[i]=B[j];
i=j;
141
j=j/2;
}
B[i]=pos;
}
aux=B[1];
B[1]=B[P];
B[P]=aux;
}
cout<<"El orden ascendentemente es:"<<endl;
for(i=1;i<=n;i++){
cout<<B[i] << " ";
}
}
142
143
CAPÍTULO XI.
MÉTODO DE SELECCIÓN.
11.1. Definición.
Es un algoritmo de ordenamiento que requiere O(n^2) operaciones para

ordenar una lista de números.(GeeksforGeeks,2019)
Funcionamiento:
- Buscar el mínimo elemento de la lista.
- Intercambiar con el primer elemento.
- Buscar el mínimo del resto de la lista.
- Intercambiar con el segundo, y así sucesivamente.
Ejemplo:
El siguiente programa ordenará los números 3,4,5,2,1 en forma
ascendente y descendente.
#include<iostream>
#include<conio.h>

int main(){
int numeros[] = {3,4,5,2,1};
int i,j,aux,min;
//Algoritmo del Ordenamiento por Selección
for(i=0;i<5;i++){
min = i;
for(j=i+1;j<5;j++){
if(numeros[j] < numeros[min]){
min = j;
}
144
}
aux = numeros[i];
numeros[i] = numeros[min];
numeros[min] = aux;
}
cout<<"Orden Ascendente: ";
for(i=0;i<5;i++){
cout<<numeros[i]<<" ";
}
cout<<"\nOrden Descendente: ";
for(i=4;i>=0;i--){
cout<<numeros[i]<<" ";
}
getch();
return 0;
}
De esta manera se puede escribir el siguiente pseudocódigo para

ordenar una lista de n elementos indexados desde el 0:
para i=0 hasta n-1
para j=i+1 hasta n
si lista[j] < lista[i] entonces
intercambiar(lista[i], lista[j])
fin si
fin para
fin para
Clasificación:
El algoritmo de ordenación de selección ordena una matriz mediante
la búsqueda repetida del elemento mínimo (considerando el orden
145
ascendente) de la parte no ordenada y poniéndolo al principio. El algoritmo

mantiene dos subarrays en una matriz determinada. (GeeksforGeeks,2019)
1) La sub barra que ya está ordenada.
2) Sub barra restante que no está ordenada.
En cada iteración de ordenación de selección, el elemento mínimo
(considerando el orden ascendente) de la sub barra no ordenada se
selecciona y se mueve a la sub barra ordenada.(GeeksforGeeks,2019)
En el ejemplo siguiente se explican los pasos anteriores:
Ejercicio 1:
arr[] = 64 25 12 22 11
// Encuentra el elemento mínimo en arr[0...4]

// y colócalo al principio
11 25 12 22 64

// y colócalo al principio de arr[1...4]
11 12 25 22 64

// y colóquelo al principio de arr[2...4]
11 12 22 25 64

// y colóquelo al principio de arr[3...4]
11 12 22 25 64
Ejercicio 2:
El siguiente arreglo ordena números , primero ingresando la cantidad
de números, en segundo paso ingresar los números a ordenar y como
resultado lo ordenará en orden ascendente.
146
#include<iostream>
main(){
int n, pos, aux;
cout << " Ingrese el numero de elementos: "; cin >> n;
int numeros[n];
for( int i=0; i<n; i++){
cout << "Ingrese el numero "<< i+1 << ": "; cin >> numeros[i];
}
for( int j=0; j<n; j++ ){
pos=j;
aux = numeros[j];
while(( pos > 0 ) && (numeros[pos-1] > aux) ){
numeros[pos] = numeros[pos-1];
pos--;
}
numeros[pos] = aux;
}
cout << "orden ascendente: " << endl;;
for( int k=0; k<n; k++ ){
cout << "[" <<numeros[k] << "]" <<", ";
}
}
Ejercicio 3:
El siguiente arreglo ordena números, primero ingresando la cantidad
de números, en segundo paso ingresar los números a ordenar y como
resultado lo ordenará en orden ascendente (otra forma).
#include <iostream>
int k, n=10, i;
147
int promedio, izquierda, derecha, central, aux;

int vector[10]= {25, 17, 65, 10, 45, 30, 6, 40, 30, 15};
main(){
for(k = 1; k < n; k++){
aux = vector[k];
izquierda = 0;
derecha = k-1;
while(izquierda <= derecha){
central = int( (izquierda + derecha) / 2);
if(aux <= vector[central]){
derecha = central - 1;
}
else{
izquierda = central + 1;
}
}
for(i = (k-1); i >= izquierda; i--){
vector[i+1] = vector[i];
}
vector[izquierda] = aux;
}
promedio = (vector[7] + vector[8] + vector[9]) / 3;
for(i= 0; i < 10; i++){
cout << vector[i] << " ";
}
cout << endl;
cout << " El promedio de las edades mas altas es : " << promedio ;
148
149
CAPÍTULO XII
12. MÉTODO DE BÚSQUEDA
12.1. Definición.
“Los procesos de búsqueda son algoritmos que permiten recorrer un arreglo

de datos para encontrar un elemento determinado” (Teddy Alfaro, p. 1).
Existen 2 tipos de algoritmos de búsqueda: búsqueda secuencial/lineal y
búsqueda binaria.
12.2. Búsqueda Secuencial/Lineal:

Consiste en comparar cada uno de los elementos de un arreglo con el
elemento a buscar, comparando primero con el valor inicial del arreglo
(Array[0]), luego con el de la 2º valor de arreglo (Array[1]) y así
sucesivamente.
Ejemplo 1. Crear un programa que determine cuál es el menor valor del

arreglo Array[9]={111,25,7,9,23,4,87,45,2}
#include <iostream>
//----------------------------------------
int Fnc_Menor(int a[], int tamano){
int menor = a[0];
for (int i=1; i<tamano; i++) {
if(a[i] < menor){
menor = a[i];
}
}
return menor;
}
150
//---------------------------------------
main(){
int array[9]={111,25,7,9,23,4,87,45,2},
n=9, menor=0, mayor=0;
//------------------------
menor = Fnc_Menor(array,n);
cout<<"Menor elemento del arreglo: "<<menor<<endl;
}
Ejemplo 2. Crear un programa que determine cuál es el mayor valor del

arreglo Array[9]={111,25,7,9,23,4,87,45,2}
#include <iostream>
//----------------------------------------
int Fnc_Mayor(int a[], int tamano){
int mayor = a[tamano-1];
for (int i=0; i<tamano-1; i++) {
if(a[i] > mayor){
mayor = a[i];
}
}
return mayor;
}
//---------------------------------------
main(){
int array[9]={111,25,7,9,23,4,87,45,2},
n=9, menor=0, mayor=0;
//------------------------
mayor = Fnc_Mayor(array,n);
cout<<"\nMayor elemento del arreglo: "<<mayor<<endl;
}
151
Ejemplo 3. Usando el arreglo del ejercicio anterior, realice un programa

que determine si un número a elección se encuentra en el arreglo.
Array[9]={111,25,7,9,23,4,87,45,2}
#include <iostream>
//----------------------------------------
int Fnc_Encontrar(int a[],int tamano, int elemento_buscado){
int encontrar=-1;
for (int i=0; i<tamano; i++){
if ( a[i]==elemento_buscado ){
encontrar=i;
}
}
return encontrar;
}
main(){
int array[9]={111,25,7,9,23,4,87,45,2},
n=9, valor;
int encontrado;
cout<<"Cual es el valor que desea encontrar: ";
cin>> valor;
encontrado = Fnc_Encontrar(array, n, valor);
if(encontrado != -1){
cout<<"el valor SI se encuentra en el arreglo"<<endl;
}
else{
cout<<"el valor NO se encuentra en el arreglo"<<endl;
}
}
152
Ejemplo 4:
Crear un programa que reciba un arreglo de X cantidades y un elemento,
determinar si el elemento está en el arreglo y en qué posición.
#include <iostream>
//-----------------------------------------------------
int Fnc_Posicion (int a[],int tamano, int elemento_buscado){
int posicion=-1;
for (int i=0; i<tamano; i++){
if ( a[i]==elemento_buscado ){
posicion=i;
}
}
return posicion;
}
//----------------------------------------------------
main(){
int n, valor;
int posicion;
//-----------------------------------------
cout<<"cantidad de valores en el arreglo: ";
cin>> n;
int array[n];
for(int i=0; i<n; i++){
cout<<"\n\t"<<i+1<<"º valor: ";
cin>> array[i];
}
cout<<"Cual es el valor que desea encontrar: ";
cin>> valor;
//-----------------------------------------
153
posicion = Fnc_Posicion(array, n, valor);

if(posicion == -1){
cout<<"el valor NO se encuentra en el arreglo\n";
}
else{
cout<<"el valor se encuentra en la posicion "
<<posicion<<" del arreglo"<<endl;
}
}
Ejemplo 5:
Realice un programa que permita encontrar un elemento en un arreglo
bidimensional y determine cuáles son el mínimo y máximo valor de ese
arreglo (Búsqueda indexada).
#include <iostream>
int main() {
int max,min, fila, columna;
cout<<"numero de filas: ";
cin>> fila;
cout<<"numero de columnas: ";
cin>>columna;
int a[fila][columna];
for(int i=0; i<fila; i++){
for(int j=0; j<columna; j++){
cout<<"\tFila "<<i
<<" y columna "<<j<<": ";
cin>>a[i][j];
}
}
max=-1000;
154
min= 1000;
for(int i=0;i<fila;i++){
for(int j=0;j<columna;j++) {
if (a[i][j]>max){
max = a[i][j];
}
if (a[i][j]<min){
min = a[i][j];
}
}
}
cout<<"\nEl maximo valor del arreglo es: "<<max
<<"\nEl minimo valor del arreglo es: "<<min<<endl;
}
Los algoritmos de búsqueda lineal/secuencial son más eficaces y rápidos si

se trabajan con arreglos pequeños. En el peor de los casos el elemento a
encontrar estará al final, por lo que se realizaría un total de búsquedas igual
al número de elementos en el arreglo, disminuyendo la velocidad del
programa.
12.3. Búsqueda Binaria.

“La Búsqueda Binaria, compara si el valor buscado está en la mitad superior
o inferior. En la que está, subdivido nuevamente, y así sucesivamente hasta
encontrar el valor.” (Teddy Alfaro O., p. 4)
Este tipo de búsqueda sólo se puede realizar si el arreglo está ordenado.
155
Figura 1. Rosita Wachenchauzer, Margarita Manterola, Maximiliano Curia,

Marcos Medrano, Nicolás Paez. (s.f).
Ejemplo 6. Realice un programa que permita determinar si un término X

se encuentra en un arreglo (Array), usando el método de búsqueda binaria.
#include <iostream>
//----------------------------------------
//función para realizar una búsqueda binaria,
//se compara el valor a buscar con cada valor medio
//que se determina en cada vuelta del ciclo do while
int busqueda_binaria(int A[],int dato,int tamano){
int izq=0, medio, der=tamano-1;
do {
medio = (izq+der) / 2;
if(A[medio]==dato) {
return medio;
}
156
else if(dato<vector[medio]) {
izq = medio +1;
}
else {
der=medio-1;
}
}
while (izq<=der);
return -1;
}
//------------------------------------------
main(){
//se puede ingresar cualquier arreglo, este es de ejemplo
int array[10]={1,3,4,6,8,9,11,13,15,16};
int n=10;
cout<<"cual es el valor que desea buscar: ";

cin>>valor;
encontrado = busqueda_binaria(array, valor, n);
if(encontrado==-1){
cout<<"el valor "<<valor<<" NO esta en el arreglo\n";
}
else{
cout<<"el valor "<<valor<<" SI esta en el arreglo\n";
}
}
Este tipo de algoritmo es más veloz y eficaz si el elemento a
encontrar se encuentra en la parte media del arreglo.
157
EJERCICIOS PROPUESTOS
Estructuras lógicas de control
1. Escriba un programa en C++ que convierta pies en metros. El

programa deberá desplegar pies de 5 a 80 en incrementos de tres pies
y los metros equivalentes correspondientes. Use la relación que hay
3.28 pies en un metro.
2. Escriba un programa En tanto se introduzcan calificaciones menores
que o iguales a 100, el programa continúa solicitando y aceptando
datos adicionales. Cuando se introduce un número menor que o igual
a 100, el programa suma este número al total. Cuando se introduce
un número mayor que 100, se sale del ciclo y se despliega la suma de
las calificaciones que se introdujeron.
3. Elabore un programa que visualice los primeros 10 números a partir
del 0 con aumento de 3 en 3.
4. Elabore un programa que visualice los 10 primeros números pares
cuadrados.
5. Elabore un programa que sume los números ingresados y termine
cuando se ingrese un numero negativo.
7. Escribir un programa que escriba los números comprendidos entre 1 y
500. El programa escribirá en la pantalla los números en grupos de 10,
solicitando al usuario si quiere o no continuar visualizando el siguiente
grupo de números.
8. Escribir un programa que calcule la media de números introducidos por
el teclado hasta que el número ingresado sea cero.
9. Leer 10 números y obtener su cubo y su cuarta.
10. Elaborar un programa que imprima solo los números pares y positivos
a su vez sacar el promedio de ellos.
158
11. Algoritmo que pida caracteres e imprima ‘VOCAL’ si son vocales y ‘NO
VOCAL’ en caso contrario, el programa termina cuando se introduce
un espacio.
Arreglos Unidimensionales
1. Pediremos los IDs (números) de alumnos de dos clases, álgebra y

análisis. Queremos mostrar todos los alumnos comunes en las dos
asignaturas.
Estos alumnos se guarden en un tercer arreglo y que sea el que se
muestre. También indica el número de alumnos que se repiten.
2. Pedir por teclado el tamaño de un arreglo de números y pedir los
valores numéricos con los que se rellena. Los valores no se pueden
repetir. Mostrar el arreglo con los valores al final.
3. Suponga un array con N números enteros generados aleatoriamente y
mostrados en pantalla, N debe ser un número impar, mostrar en
pantalla el valor que ocupa el centro del array.
4. Suponga un array con N notas de 0 a 20, calcule el promedio de
aprobados y el promedio de los desaprobados e indique la cantidad de
aprobados y desaprobados.
5. Suponga un array que contiene N notas de 0 a 20 generados
aleatoriamente y mostradas en pantalla, de acuerdo a la nota
contenida, indique cuántos estudiantes son:
Deficientes 0-5
Regulares 6-10
Buenos 11-15
Excelentes 16-20
6. Hallar la longitud de las siguientes cadenas y ver cual tiene mayor
longitud.
Programación
Computadora
159
Sistemas
7. Calcular cuál de las siguientes palabras es mayor alfabéticamente:
Aprehender
Aprender
8. Se tienen 2 amigos:
Amigo 1:
Nombres: Juan Jesús
Apellidos: López Díaz
Amigo 2:
Nombres: Cristofer David
Apellidos: Mayta Rojas
¿Cuál de los dos tiene más caracteres en su nombre completo?
9. ¿Mayor alfabéticamente y Mayor longitud es lo mismo? Comprobarlo
en un programa.
10. Mostrar un programa en el cual se ingresarán datos como: Nombre,
Apellidos, Edad y Domicilio de 2 personas. Se deberá mostrar así:
Nombres y Apellidos:
Edad:
Domicilio con más caracteres:
Domicilio con menos caracteres:
Programación Modular
1. Realice una función que saque la raíz cuadrada de un número.

2. Realice una función que haga la conversión de Nuevos Soles
Peruanos(PEN) a Dólares Estadounidenses(USD). 1 PEN=0.28 USD
3. Realice una función que dé como resultado la cantidad de cifras de un
número.
4. Realice una función que dé como resultado la cantidad de letras de una
palabra o frase.
160
5. Realice una función que identifique si un triángulo es escaleno,

isósceles o equilátero recibiendo como parámetros la longitud de sus
lados.
6. Realice una función recursiva para la suma.
7. Realice una función recursiva para la potencia.
8. Realice una función recursiva que convierta un número ingresado por
el usuario a sistema binario.
9. Realice una función recursiva que invierta un número ingresado por el
usuario.
10. Realice una función recursiva que calcule el Máximo Común Divisor de
dos números ingresados por el usuario.
Programación Orientada a Objetos
1. Leer 3 notas por alumno para ‘n’ alumnos y calcular el promedio de

c/u y el promedio del curso.
2. Defina la clase y declare sus métodos para el siguiente objeto: una
nave de un videojuego. Se sabe que la nave se puede situar en unas
coordenadas (x,y) de la pantalla y que tiene un máximo de tres vidas.
Además, la nave puede moverse en la pantalla (subir, bajar, ir a la
derecha e ir a la izquierda) y ser destruida (no más de tres veces).
3. Defina una jerarquía de clases y sus métodos para los siguientes
objetos: vehículo, coche, moto. Tanto el coche como la moto son
vehículos. Ambos vehículos tienen un número de ruedas y una
velocidad máxima. Por otro lado, el coche tiene una característica que
las motos no tienen: el número de puertas. Mientras que las motos
tienen la característica de admitir una o dos plazas.
4. Crear dos clases, A y B, con constructor por defectos notificándose
ellos mismos. Una nueva clase llamada C que hereda de A, y cree un
objeto miembro B dentro de C, pero no cree un constructor para C.
Cree un objeto de la clase C y observe los resultados.
161
5. Crear una jerarquía de clases de tres niveles con constructores por

defecto y con destructores, ambos notificándose utilizando cout.
Verificar que el objeto más alto de la jerarquía, los tres constructores
y destructores son ejecutados automáticamente. Explicar el orden en
que han sido realizados.
6. Crear una clase Car para que herede desde una clase llamada Vehicle,
colocando correctamente las funciones miembro en Vehicle (esto es,
añadir algunas funciones miembro). Añada un constructor (no el de
por defecto) a Vehicle, que debe ser llamado desde dentro del
constructor Car
7. Crear una clase Enemigo con un método de ataque, y dos clases una
de Ninja y otra de Guerrero, que hereden la clase Enemigo.
8. Crear un registro de notas para un colegio, tomando en cuenta el grado
y la sección.
9. Elaborar una clase RACIONAL que modele los números racionales
implementando al menos las operaciones de suma, resta, opuesto e
inverso de un número racional a imitación de la suma o resta de los
números reales o enteros.
10. Elaborar una clase COMPLEJO que modele los números complejos
implementando al menos las operaciones de suma, resta y módulo de
un número complejo a imitación de la suma o resta de los números
reales o enteros.
Estructuras, uniones y enumeraciones
1. Cree una estructura llamada personas, con los siguientes datos: DNI,
edad, nombre, apellido paterno y apellido materno.
2. En base al ejercicio anterior solicite la entrada de datos por teclado.
3. Cree una estructura llamada trabajadores, con los siguientes datos:
fecha de ingreso, área, nombres, apellido paterno y materno. Solicite
la entrada a través de un bucle para 40 trabajadores.
162
4. Cree una estructura llamada estudiantes, asigne los datos: código de

estudiante, carrera de estudios y asigne también la estructura llamada
personas (ver ejercicio 1).
5. En base al ejercicio anterior realice el ordenamiento por nombre de los
alumnos.
6. Realice la impresión de los datos a través de un bucle en base a los
datos ingresados (ver ejercicio 3).
7. Cree una estructura llamada personas con los siguientes datos:
nombres, apellido paterno, apellido materno, DNI, edad. Luego cree
dos estructuras llamadas estudiantes y profesores en la estructura
estudiantes considere los datos: código de estudiante, ciclo académico
y los datos de la estructura personas. Y para el caso de la estructura
profesores considere los siguientes datos: código de profesor, turno
(M, T, N), y dedicación (parcial, completo)
8. En base al ejercicio anterior solicite a través de un bucle el ingreso de
datos para 5 estudiantes y 3 profesores.
9. Realice la impresión de los profesores y estudiantes que sus nombres
empiecen con M (ver ejercicio 7).
10. ¿Luego de la declaración de la estructura es necesario el punto y coma
(en la parte que indica posición en el siguiente código)?
struct Nombre{
tipo atributo1,
tipo atributo2,
…..
} “Posición”
Punteros
1. Imprima a través de punteros letra por letra la palabra ALGORITMOS.

2. Mediante el uso de punteros almacene las variables 3 y 7 y mande a
imprimir sus direcciones de memoria.
163
3. En base al ejercicio anterior intercambie las direcciones de memoria

de los valores.
4. A través de punteros imprima letra por letra la palabra SISTEMAS
5. Llame desde una función externa un valor referenciado vía punteros.
6. A través de la aritmética de punteros, llame a impresión las letras de
la palabra PROGRAMACION.
7. Defina una cola.
8. Defina una lista.
9. Mande a imprimir los valores de una cola.
11. Mande a imprimir los valores de una lista.
Archivos
1. Escribir un programa que cree un fichero de texto cuyo nombre se pide

inicialmente al ejecutar el programa y cuyo contenido se obtenga por
teclado carácter a carácter. La introducción del texto a través del
teclado debe acabar al introducir el carácter $.
2. Realizar un programa que cree un fichero de texto cuyo nombre es el
primer argumento de la línea de órdenes y cuyo contenido son una
serie de líneas separadas por caracteres \n que contienen cada una el
resto de los argumentos de la línea de órdenes, escritos en
mayúsculas. Por ejemplo, la orden: prog crea el archivo de nombre
mifi que contiene las líneas:
Matias
Jesus
Jose
3. El programa que se presenta a continuación lee caracteres de teclado
y los almacena en un fichero de sólo escritura, estos caracteres serán
introducidos en mayúscula.
4. Lectura de datos de distintos tipos de un archivo de texto.
164
5. Diseñar un programa que, dado un archivo de texto compuesto por

frases, compruebe si la primera letra de cada frase es mayúscula, en
caso contrario, sustituir la minúscula por la correspondiente
mayúscula. (Para este ejercicio es conveniente disponer de una tabla
ASCII).
6. Realizar un programa para cambiar en un fichero un carácter por otro.
El fichero resultado se llamará SALIDA.NEW y el de entrada se leerá
de la entrada estándar. El programa leerá el nombre de fichero de
entrada, el carácter a cambiar y el carácter por el cual se va a cambiar.
7. Tiene los siguientes considerandos:
a. Escriba un conjunto de dos instrucciones que declare primero los
siguientes
objetos como objetos ifstream y luego los abre como archivos de
entrada
de texto: enDatos.txt, precios.txt, cupones.dat y exper.dat.
b. Vuelva a escribir las dos instrucciones para el ejercicio 2a usando
una sola instrucción.
a. Introduzca y ejecute el programa 8.3a en su computadora.
b. Agregue un método close() al programa 8.3a y luego ejecute el
programa.
a. Introduzca y ejecute el programa 8.3b en su computadora.
b. Agregue un método close() al programa 8.3b y luego ejecute el
programa.
10. Haz un programa que lea un fichero “ fichero.txt ” y escriba en otro
fichero “FICHERO2.TXT” el contenido del fichero de entrada con todas
las letras en mayúsculas.
165
Métodos de ordenamiento, selección y búsqueda
1. Cree un programa que ordene una lista que contiene las edades de
una familia formada por X personas usando el método de
ordenamiento por selección. Mostrar el arreglo de manera ascendente
2. Realizar un programa que le permita ingresar al usuario una cierta
cantidad de números; el programa tendrá que comparar los números
y como resultado ejecutar el ordenamiento ascendente, usando
ordenamiento por burbuja.
3. Crear un programa que ordene los números de menor a mayor
{20,50,100,2,63,5,42,9,41,5,6} utilizando el algoritmo de inserción
binaria
4. Crear un programa donde se ordene en orden descendente una
sucesión de números primos.
5. Realizar un programa donde se ordene de forma ascendente y
descendente las edades de las personas que se ingresen en una lista.
6. Realizar un programa que ordene de manera ascendente una sucesión
Fibonacci.
7. Realizar un programa que permita ingresar una lista de alumnos y
reciba y busque un apellido y nombre cualquiera, el programa debe
determinar si estos datos se encuentran registrados en la lista.
8. Se registra la lista de orden de llegada de una carrera de atletismo,
imprimir la posición en la que llegó Juan.
Orden[10] = {Mario, Ángel, Jhon, Juan, Uriel, Diego, Franco,
Leonardo, Beto, Mauricio}
9. Crear un programa que determine la posición del elemento mayor y
menor de una serie de X números a ingresar. Los datos a ingresar
son a criterio del usuario.
10. Mediante búsqueda binaria, crea un programa que permita ingresar
un nuevo número a una lista ya ordenada. Arreglo de ejemplo:
Array[10]={1,3,4,6,7,9,10,14,15,17}. Dato a ingresar: 13.
166
BIBLIOGRAFÍA
Acera, M.Á & Sanz, A.M. (2015). Manual Imprescindible de C++.

Recuperado de :
https://www.google.com/url?sa=t&source=web&rct=j&url=https://
www.casadellibro.com/libro-manual-imprescindible-de-c-c-
/9788441518117/1013582&ved=2ahUKEwiE8I6RuZLrAhUhJLkGHaK
8B_wQFjAJegQIAxAB&usg=AOvVaw3HNdxFsKcvzCJ7SRCMz3hR
Alfaro, T. (s.f). Algoritmos de Búsqueda y Ordenamiento. Recuperado de:
https://www.inf.utfsm.cl/~noell/IWI-131-p1/Tema8b.pdf
Algoritmos de Búsqueda y Ordenación. (s.f). Recuperado de:
https://www.fing.edu.uy/tecnoinf/maldonado/cursos/prinprog/mate
rial/teo/prinprog-teorico11.pdf
Aulafacil.com (2020). Función Strcmp - Lenguaje De Programación C.
Recuperado
de:https://www.aulafacil.com/cursos/programacion/lenguaje-de-
programacion-c/funcion-strcmp-l17440.
Aulafacil.com (2020). Funciones Strcpy Y Strcat - Lenguaje De
Programación C. Recuperado
de:https://www.aulafacil.com/cursos/programacion/lenguaje-de-
programacion-c/funciones-strcpy-y-strcat-l17324.
Bronson, G.(2007). C++ para ingeniería y ciencias, 2a. ed. Recuperado
de :
https://onedrive.live.com/?authkey=%21AJlEM3kSVh6vy2M&cid=1
217A2ACC6518BFE&id=1217A2ACC6518BFE%21351&parId=1217A
2ACC6518BFE%21336&o=OneUp
Cortijo Bon, F.J. & Berzal Galiano, F. (S.f.). Programación Orientado
objetos en C++. Curso de C++ Builder. Recuperado de :
https://elvex.ugr.es/decsai/builder/intro/5.html
Ecured.cu.(2020). Cadenas De Caracteres En C++ .Ecured. Recuperado
de:
167
https://www.ecured.cu/Cadenas_de_Caracteres_en_C%2B%2B#:~
:text=Acciones%20de%20p%C3%A1gina&text=Cadenas%20de%2
0Caracteres.,en%20posiciones%20consecutivas%20de%20memori
a.
Funciones II: Parámetros por valor y por referencia. (s. f.).
c.conclase.net. Recuperado 10 de agosto de 2020, de
http://c.conclase.net/curso/?cap=015
Gutierrez, L. (s.f.).Estructura repetitiva. Slideshare. SlideShare.
Recuperado de : https://es.slideshare.net/laryenso/estructura-
repetitivas
Joyanes,L. & Sánchez, L.(2006).Programación en c++:un enfoque
práctico.Madrid,España:McGraw-Hill.
Juárez, P. (s. f.). Programación modular en C. Scribd. Recuperado 10 de
agosto de 2020, de
https://es.scribd.com/doc/14611784/Programacion-modular-en-C
Knuth,Donald. (1968). The Art of Computer Programming. EE.UU:
Addison-Wesley
Métodos de Ordenamiento: Heapsort. (2015). Heapsort. Recuperado de:
http://ordenamientoheapsort.blogspot.com/2015/09/metodos-de-
ordenamiento-los-metodos-de.html
Pathak, Deepika. (2019). Selection Sort. GeeksforGeeks. Recuperado de :
https://www.geeksforgeeks.org/selection-sort/
Sitio de Análisis de Algoritmos.Estamos trabajando para
ustedes.Recuperado de
https://danielandres25.wordpress.com/unidad-1/algoritmos-de-
busqueda-y-ordenamiento/metodo-de-ordenamiento-shell-sort/
Subprogramas. programación modular. (s. f.). Informatica.uv.es.
Recuperado 10 de agosto de 2020, de
http://informatica.uv.es/iiguia/AED/oldwww/2004_05/AED.Tema.05
.pdf
168
TonaCastro,Claudia. (2016). Métodos de ordenación. SlideShare.

Recuperado de :
https://es.slideshare.net/ClaudiaTonaCastro/presentacin-insercin-
directa-y-binaria-62032062
Vicente, B & Roldán, M. (2017). Fundamentos de Programación con el
Lenguaje de Programación C++. San Francisco, California 94105,
USA : Creative Commons
Wachenchauzer, R., Manterola, M., Curia, M., Medrano, M. y Paez,N.
(s.f). Algoritmos de Programación con Python. Recuperado de:
https://uniwebsidad.com/libros/algoritmos-pythn
169
SOBRE LOS AUTORES:

Frank Edmundo Escobedo Bailón
Universidad Nacional Mayor de San Marcos (UNMSM), Lima – Perú.
E-mail: fescobedob@unmsm.edu.pe
ORCID: https://orcid.org/0000-0002-2058-0976
Ingeniero de sistemas e informática, Maestro en Ingeniería de Sistemas, Doctor en Educación, Doctor en Ingeniería de
Sistemas, con estudios concluidos en el Doctorado en Psicología, egresado del Doctorado en Neurociencias. Con diplomaturas
en: (1) Auditoría, (2) Alta dirección y gestión empresarial, (3) Evaluación por competencias, (4) Estrategias didácticas y
Tecnologías de Información y Comunicaciones. Miembro del Comité Editorial de la Revista Desafíos de la Universidad de
Huánuco. Con 18 años de experiencia como docente universitario. Docente Principal en la Universidad Nacional Tecnológica
de Lima Sur(UNTELS) y Docente Asociado en la Universidad Nacional Mayor de San Marcos(UNMSM). Consultor
TI/sistemas de información.
Kathy Giannina Ruiz Carrasco

Universidad Ricardo Palma
E-mail: 1308440@esan.edu.pe
Ingeniera informática de profesión, Magíster en Administración de Empresas y especialización en marketing, con más de 12
años de experiencia en Gestión de Proyectos y Aseguramiento de Calidad de Software, actualmente desempeñando funciones
como Subgerente de Sistemas.
Hugo Froilán Vega Huerta

E-mail: hvegah@unmsm.edu.pe
Doctor en Ingeniería de Sistemas en la UNFV, Magister en: Administración en la UNMSM, director de la Facultad de
Ingeniería en Informática de la URP (2011-2014). Vicedecano Académico de la Facultad de Ingeniería de Sistemas de la
UNMSM (2016-2020). Investigador en el área de inteligencia artificial, específicamente en redes neuronales y lógica difusa,
responsable del grupo de investigación YACHAY. "Premio al Mérito Científico"-UNMSM (2012), por la cantidad de artículos
publicados y los trabajos de investigación. Actualmente es profesor principal en la UNMSM.
. Hugo Froilán Vega Huerta
Carlos Ernesto Chávez Herrera
E-mail: cchavezh@unmsm.edu.pe
Ingeniero de sistemas e informática de profesión, Magister en Administración y Dirección de Empresas, Doctorado concluido
en Ingeniería de Sistemas, con más de 12 años de experiencia en docencia universitaria, profesor auxiliar en la UNMSM, más
de 15 años de experiencia en Gestión de Proyectos de Software, Consultor en Sistemas de Información y Tecnologías de
Información.
Oscar Benito Pacheco

E-mail: obenitop@unmsm.edu.pe
Mg(c) en Ingeniería de Sistemas en la UNMSM con mención en Ingeniería de Software, Licenciado en Computación en la
UNMSM, Diplomatura: (1) Especialización en Auditoría en Tecnologías de Información UNMSM, (2) Docencia Universitaria
en la UNE Enrique Guzmán y Valle, (3) Calidad Total en la Gestión Administrativa en la UNE Enrique Guzmán y Valle,
Miembro del Comité Directivo del CERSEU Facultad de Ciencias Matemáticas de la UNMSM (2017-2020). Investigador en
el área de inteligencia artificial, específicamente en redes neuronales y lógica difusa, docente del grupo de investigación
YACHAY. Actualmente profesor auxiliar en la UNMSM.
170

Libro de Fundamentos de Programacion Version Final 1

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

Libro de Fundamentos de Programacion Version Final 1

Cargado por

Copyright:

Formatos disponibles

FUNDAMENTOS DE

Primera Edición Digital: Enero, 2021

ISBN: 978 – 612 – 00 – 5955 - 5

Derechos Reservados. Prohibida la

1. ESTRUCTURAS LÓGICAS .......................................................... 8

1.1. Estructuras Lógicas Secuenciales ..................................... 8

1.2. Estructuras Lógicas Selectivas ....................................... 11

1.3. Estructuras Lógicas Repetitivas ..................................... 21

1.3.1. Estructura Mientras (While) ...................................... 22

1.3.2. Ciclo For ................................................................... 25

1.3.3. Ciclo do while ........................................................... 29

2.1. Arreglos Unidimensionales ............................................. 33

2.2. Arreglos Bidimensionales ............................................... 38

2.3. Cadena de caracteres. .................................................... 41

CAPÍTULO III. ............................................................................ 58

3. PROGRAMACIÓN MODULAR ................................................... 58

CAPÍTULO IV. ............................................................................. 76

4. PROGRAMACIÓN ORIENTADA A OBJETOS .............................. 76

4.1. Definición. ........................................................................ 76

4.2. Definición de clases y objetos. .......................................... 76

4.3. Definición de encapsulamiento. ........................................ 77

4.4. Métodos y atributos. ......................................................... 77

4.5. Creación de clases y objetos en C++................................. 78

4.6. Constructores y destructores. ........................................... 79

4.8. Funciones amigas(Friends)............................................... 82

5.1. Definición. ........................................................................ 91

6.1. Creación de clases y objetos en C++................................. 98

CAPÍTULO VII. ......................................................................... 103

7. ENUMERACIONES ................................................................ 103

7.1. Creación de clases y objetos en C++............................... 103

CAPÍTULO VIII ......................................................................... 108

8. PUNTEROS ............................................................................ 108

8.1. Definición. ...................................................................... 108

8.2. Detalles al crear y usar punteros en C++. ....................... 108

8.3. Los punteros y el ampersand. ......................................... 109

Los apuntadores y el asterisco ............................................... 109

Ejemplo 1. .......................................................................... 110

Ejemplo de punteros (Array Dinámico): .............................. 113

Ejemplo de Punteros (Matriz Dinámica): ............................. 115

Ejemplo de Punteros(Aritmética de Punteros): .................... 117

CAPÍTULO IX ............................................................................ 122

9. ARCHIVOS .......................................................................... 122

9.1. Definición. ...................................................................... 122

9.2. Flujos de archivos. ......................................................... 122

9.3. Tipos de archivos básicos. .............................................. 124

9.3.2. Archivos basados en binarios .................................. 128

CAPÍTULO X ............................................................................. 132

10. MÉTODOS DE ORDENAMIENTO .......................................... 132

10.1. Definición. ................................................................... 132

10.2. Ordenamiento por selección. ........................................ 132

10.3. Ordenamiento por burbuja ........................................ 134

10.4. Ordenamiento por inserción ...................................... 136

10.5. Ordenación Shell. ...................................................... 139

10.6. Ordenamiento HeapSort ............................................ 140

CAPÍTULO XI. ........................................................................... 144

MÉTODO DE SELECCIÓN............................................................ 144

11.1. Definición. ................................................................... 144

Clasificación: ......................................................................... 145

CAPÍTULO XII .......................................................................... 150

12. MÉTODO DE BÚSQUEDA .................................................... 150

12.1. Definición. ................................................................... 150

12.2. Búsqueda Secuencial/Lineal: ..................................... 150

12.3. Búsqueda Binaria. ..................................................... 155

EJERCICIOS PROPUESTOS ........................................................ 158