Ejercicios en el Paradigma Orientado a Objetos

PROGRAMACIÓN EN C++
PRÁCTICA 08
INTRODUCCIÓN A C++
SENTENCIAS DE CONTROL DEL FLUJO DE UN PROGRAMA:
Ejercicio 1.
Ejercicio 2.
Ejercicio 3.
Ejercicio 4.
Ejercicio 5.
Ejercicio 6.
Ejercicio 7.
Ejercicio 8.
Un primer programa en C++. ..................................................................................................1
Una conversación en C++. ........................................................................................................2
Una pequeña operación aritmética. .........................................................................................2
Conversor de euros a pesetas y dólares. ..................................................................................3
Solución de la ecuación de segundo grado...............................................................................3
Ejecutar con el Debugger el programa anterior.....................................................................4
Conversor de Temperatura ......................................................................................................4
Bucles FOR ..................................................................................................................................5
8.1
Un primer bucle FOR................................................................................................... 5
8.2
Varias formas de utilizar el bucle FOR........................................................................ 5
8.3
Calcular el factorial de un número mediante un bucle FOR ........................................ 6
Ejercicio 9.
Bucles WHILE..............................................................................................................................7
9.1
Cálculo del factorial de un número mediante un bucle WHILE ................................... 7
Ejercicio 10.
Bifurcaciones..............................................................................................................................8
10.1
10.2
10.3
Elaboración de un menú. ............................................................................................ 8
Función para determinar si dos números son divisibles entre si ................................ 8
Obtención de las raíces de un polinomio de segundo grado ...................................... 9
Comienza ahora la segunda parte de Informática I y Fundamentos de Computadores, y
comienza con algunos ejemplos sencillos referidos a la programación en C++. Programar en
C++ es un poco distinto a programar en Matlab. Se presupone que usted ha adquirido los
rudimentos necesarios para desarrollar algoritmos y programarlos en un lenguaje
relativamente específico como es Matlab. Ahora, aunque el conocimiento teórico-práctico
sobre algoritmos se mantiene, el lenguaje de programación a utilizar será c++. Este lenguaje
es mucho más genérico y universal que Matlab y le aportará un mayor conocimiento y control
sobre el PC.
No es importante que haga todos los ejercicios durante la práctica, sino que entienda
muy bien cómo y por qué se hacen las cosas. Es preferible que entiendan muy bien un
programa a que hayan acabado todo sin haberse enterado de nada. Los primeros ejercicios
servirán para familiarizarse con el modo de programar y para que vaya entendiendo las cosas.
Hay veces que un mismo problema puede resolverse de varias maneras diferentes que son
igualmente correctas.
Para realizar los Ejercicios de esta práctica debe apoyarse en el libro "Aprenda C++
como si estuviera en Primero (Básico)". Para todos los ejercicios de cualquier práctica
deberá crear un Proyecto en un subdirectorio especial En primer lugar crea un directorio
llamado Practica08 dentro de G:\Informatica. En este directorio deberás guardar todos los
ficheros y todo el trabajo resultante de esta práctica.
Ejercicio 1. Un primer programa en C++.
Programe, compile y ejecute el siguiente sencillo programa de bienvenida al que llamaremos
Ejercicio1:
/* fichero Ejercicio01.cpp */
#include <iostream.h>
void main (void){
cout << "Hola futuro(a) programador de C++" << endl;
cout << "Como estas?" << endl;
} /* fin de main() */
Prácticas de Programación en C++
Pág. 2
Deberá copiar este programa en el editor del Visual C++, compilarlo y ejecutarlo para
comprobar su funcionamiento. El nombre del proyecto será Ejercicio01 y el del programa
será Ejercicio01.cpp. Para compilar y linkar el programa debe utilizar el menú Build y las
opciones Compile File (para compilar), Build (para linkar) y Execute (para ejecutar). Cada
opción comprende las anteriores, esto es, si se quiere ejecutar y no se ha compilado y linkado,
se realizan primero estas operaciones.
Ejercicio 2. Una conversación en C++.
Seguro que el programa del ejercicio anterior le ha dejado con ganas de responder a la
pregunta que aparece en la pantalla. Para ello es necesario introducir el flujo cin, el cual
permite leer tanto números como cadenas de caracteres. Esta función espera hasta que el
usuario pulse Intro. Cuando esto sucede lee todo lo que encuentra. Salvo que encuentre
tabuladores o espacios, que entonces termina de leer.
1.-
Crear un proyecto llamado Ejercicio02, en el cual debe escribir el siguiente programa,
al que llamará Ejercicio02.cpp:
/* fichero Ejercicio02.cpp */
// Este programa le saluda más formalmente
#include <iostream.h>
void main (void){
char nombre[30];
int edad;
cout << "Hola! Como te llamas?";
cin >> nombre;
cout << "Cuantos anyos tienes?";
cin >> edad;
cout << "Hola " << nombre ;
cout << ",tienes " << edad << " anyos" << endl;
}
2.-
Compile el programa y ejecútelo. Recuerde que al responder a la pregunta sólo podrá
teclear una sola palabra. Todos aquellos que tengan nombre compuesto -Luis Alfredo,
Ana Silvia, Marco Antonio y demás- tendrán que esperar a la siguiente práctica para
conocer nuevas funciones de lectura.
Ejercicio 3. Una pequeña operación aritmética.
Estará pensando que el C++ ha de servir para algo más que mantener una aburrida
conversación con la pantalla. En el siguiente programa le presentamos un avance de las
“complicadas” operaciones que puede realizar el C++. Escriba el programa y sálvelo como
maraton.cpp.
/* Un marathon tiene 26 millas y 385 yardas */
/* Calcula la distancia del marathon en Kilómetros */
/* Una milla tiene 1760 yardas */
#include <iostream.h>
void main (void){
int millas,yardas;
float kilometros;
millas = 26;
yardas = 385;
/* fórmula de conversión */
kilometros = 1.609 * (millas + yardas / 1760);
// salida de datos
cout <<"Un marathon tiene "<< kilometros << " kilometros" << endl;
}
Escuela Superior de Ingenieros – Tecnun – Universidad de Navarra
Prácticas de Programación en C++
Pág. 3
Debe crear un proyecto llamado Ejercicio03 y luego compilarlo y ejecutarlo; apunte el
resultado. Ahora modifique el programa sustituyendo 1760 por 1760.0 en la línea que calcula
el número de kilómetros. Vuelva a compilar y a ejecutar. ¿Sale lo mismo que antes? ¿Qué ha
podido pasar?
Ejercicio 4. Conversor de euros a pesetas y dólares.
Por fin ha llegado el momento que realice un programa usted solo(a), para lo cual puede echar
mano de los apuntes y demás ejercicios dados en clase.
En este ejercicio se pide que realice un programa que le pregunte los €uros que desea
convertir y como salida dará cuantas pesetas y dólares son.
Recuerda que 1€ son 166.386 pesetas y aproximadamente (en el momento de la
redacción de la práctica) 1.27 dólares.
Debe crear un proyecto Ejercicio04 y al nombre del fichero fuente llámele
conversor.cpp.
Ejercicio 5. Solución de la ecuación de segundo grado.
Dada la ecuación de segundo grado:
ax2 + bx + c = 0
hay que calcular el discriminante:
discr = b2 - 4ac
si discr > 0.0 las dos raíces son reales y distintas, y valen:
− b + discr
− b − discr
x1 =
x2 =
2a
2a
si discr = 0.0 las dos raíces son reales e iguales y valen:
−b
x1 = x2 =
2a
Finalmente, si discr < 0.0 las dos raíces son complejas conjugadas. Las partes real e
imaginaria valen:
−b
− discr
xr =
xi =
2a
2a
Partiendo del código incompleto que hay a continuación, termine de editar el programa para
resolver la ecuación de segundo grado. Llame Ejercicio05 al proyecto y eccuciones2.cpp al
siguiente fichero. Al terminar, compile y ejecute este programa, cambiando los valores de a, b
y c, de modo que se prueben los tres casos que pueden presentarse en el programa. Puede
probar con los siguientes valores, para que se den los 3 casos:
A
B
C
Resultado
1
4
4
Raíces iguales
1
5
4
Raíces reales
1
3
6.25
Raíces imaginarias
Escuela Superior de Ingenieros – Tecnun – Universidad de Navarra
Prácticas de Programación en C++
Pág. 4
/* fichero ecuaciones2.cpp */
/* Resolución de la ecuación de segundo grado */
#include <iostream.h>
#include <math.h>
//para sqrt()
void main(void)
{
double a, b, c;
double discr, x1, x2, xr, xi;
cout << "Escribe los valores de los coeficientes A, B y C: ";
cin >> a >> b >> c;
discr = ... ;
if (discr > 0.0) {
x1= . . .;
x2= . . .;
cout << "Las dos raices reales son: ";
cout << x1 << " y " << x2 << endl;
}
else if (discr < 0.0) {
xr= . . .;
xi= . . .;
cout << "Raices complejas: " << endl;
cout << "(" << xr << ", " << xi << "i) y ";
cout << "(" << xr << ", " << -xi << "i)" << endl;
}
else {
x1= . . .;
cout << "Las dos raices son iguales y valen: " << x1 << endl;
}
}
Ejercicio 6. Ejecutar con el Debugger el programa anterior
En este ejercicio deberá ejecutar paso a paso el programa que calcula las raíces de la ecuación
de segundo grado.
Deberá colocar el cursor en una línea (por ejemplo la discr = b*b - 4.0*a*c;) y
presionar la tecla F9 (con esto pondrá un breakpoint). Ahora ejecute el programa en modo
debug, dando directamente a la tecla F5 (sino Build->Start debug->Go del menú). El
programa empezará a ejecutarse y se detendrá en la citada línea. A partir de aquí podrá ver
cómo varían las distintas variables del programa, ejecutando el programa paso a paso (tecla
F10). En especial tiene que observar cómo van cambiando las variables x1, x2, xr y xi, por
medio de la ventana Watch.
Ejercicio 7. Conversor de Temperatura
En el siguiente ejercicio debe hacer un conversor de temperatura, de ºC →ºF y ºF →ºC, según
la siguiente fórmula:
9 .0
ºF =
* (º C ) + 32
5 .0
El programa debe pedir al usuario qué tipo de conversión debe hacer y luego el dato
de la temperatura a convertir. Para este ejercicio debe crear un proyecto Ejercicio07 en su
disco de usuario, y el nombre del programa será Temp.cpp.
Si no ha llegado a terminar este ejercicio en las dos horas de prácticas, debe tratar de
hacerlo en las horas libres de ordenador o en casa.
Escuela Superior de Ingenieros – Tecnun – Universidad de Navarra
Prácticas de Programación en C++
Pág. 5
Notas:
- No olvide poner siempre “;” al final de cada sentencia.
- No olvide cerrar las comillas, los paréntesis y las llaves ( { }).
- Por último, recuerde que C++ distingue de minúsculas y mayúsculas.
Ejercicio 8. Bucles FOR
8.1
Un primer bucle FOR.
En este ejercicio va a hacer su primer bucle for. Para ello es necesario echar mano de los
apuntes (sentencias de control) para ver cuál es la forma general del bucle for.
Para este ejercicio, debe crear un proyecto nuevo Ejercicio8_1, con un fichero
MiFor.cpp. Yo le damos el código del bucle for pero el código anterior al bucle debe ponerlo
usted.
En el ejercicio se trata de generar una serie de números aleatorios entre 0 y 1. La
cantidad de números a generar debe ser de 10:
. . .
int Num = 10;
for (int i=1;i<=Num;i++){
double val = rand()/32767.0;
cout << "Numero: " << i+1 << " Valor:"<< val << endl;
}
. . .
La función rand() genera un número entero aleatorio entre 0 y 32767. Esta función se
encuentra en la librería stdlib.h (la cual es necesario incluir al inicio del programa, usando la
directiva #include del preprocesador).
8.2
Varias formas de utilizar el bucle FOR
En el siguiente programa se muestran distintas formas de escribir un bucle for para
sumar los enteros del 1 al 5. Cree un proyecto llamado Ejercicio8_2, teclee con el editor de
Visual C++ el siguiente programa y guárdelo con el nombre SumaFor.cpp:
Escuela Superior de Ingenieros – Tecnun – Universidad de Navarra
Prácticas de Programación en C++
Pág. 6
// fichero SumaFor.cpp
#include <iostream.h>
void main(void)
{
int i=1, suma=0;
for( ; i<=5; ) {
// forma 1
suma += i;
++i;
}
cout << "suma 1 = " << suma << endl;
suma=0;
for(i=1; i<=5; ++i)
// forma 2
suma += i;
cout << "suma 2 = " << suma << endl;
for(i=1, suma=0; i<=5; ++i, suma+=i)
;
cout << "suma 3 = " << suma << endl;
// forma 3
for(i=1, suma=0; i<=5; suma+=i, ++i)
;
cout << "suma 4 = " << suma << endl;
// forma 4
}
La suma de los 5 primeros números enteros se ha realizado de 4 formas distintas. En la
forma 1 se han dejado en blanco las partes de inicialización y actualización del bucle for; el
resultado es correcto porque dichas tareas se han incluido de otra forma. La forma 2 es
completamente estándar. En la forma 3 todo se ha introducido en el paréntesis del bucle; en la
inicialización se da valor inicial tanto a i como a suma; en la actualización se modifica
también tanto i como suma. El resultado es que el bucle sólo necesita una sentencia vacía,
representada por el punto y coma (;). La forma 4 es una variante de la forma 3.
Después de crear el proyecto, de compilar y de ejecutar este programa, observará que
la forma 3 da un resultado diferente de las demás. ¿Sabría explicar por qué? ¿Puede
corregirla? Puede utilizar el debugger para que le ayude a encontrar el error.
8.3
Calcular el factorial de un número mediante un bucle FOR
Este ejercicio consiste en calcular el factorial de un número entero. Para este ejercicio, debe
crear un proyecto nuevo al que llamará Ejercicio8_3, con un fichero llamado
FactorialFor.cpp donde se encontrará el código.
Desde el main() debe preguntarse el número entero sobre el que se quiere calcular el
factorial. Posteriormente, debe aparecer el factorial de ese número.
Escuela Superior de Ingenieros – Tecnun – Universidad de Navarra
Prácticas de Programación en C++
Pág. 7
Ejercicio 9. Bucles WHILE
Salvando el formato de escritura, los bucles while tienen la misma utilización que en Matlab.
Permiten ejecutar repetidamente, mientras que se cumpla una determinada condición, una
sentencia o un bloque de sentencias. La forma general es como sigue:
while (expresion_de_control){
sentencias...
}
La expresión de control es el resultado de una operación booleana. Si el resultado de
esta operación es True se ejecutan las sentencias que hay dentro del bucle. Al acabar de
ejecutar todas las sentencias vuelve a evaluarse la expresión de control. Si vuelve a ser True
vuelven a ejecutarse de nuevo todas las sentencias. Hasta que, en algún chequeo, la expresión
de control sea False.
9.1
Cálculo del factorial de un número mediante un bucle WHILE
Al igual que el ejercicio 8.3, realice un programa para calcular el factorial de un
número pero esta vez utilizando un bucle while.
Cree un nuevo proyecto Ejercicio9_1 y el fichero FactorialWhile.cpp para realizar
este ejercicio.
Escuela Superior de Ingenieros – Tecnun – Universidad de Navarra
Prácticas de Programación en C++
Ejercicio 10.
Pág. 8
Bifurcaciones
10.1
Elaboración de un menú.
En este ejercicio va a aprender a hacer un menú, desde el cual puede escoger distintas
opciones. Lo va a implementar utilizando sólo sentencias if-elseif y sentencias for.
Debe crear otro proyecto, Ejercicio10_1, y un fichero menu.cpp. El código es el siguiente:
// fichero menu.cpp
#include <iostream.h>
#include <stdlib.h>
//para system() y exit;
void main(void)
{
int opcion;
system("cls");
//borra la pantalla al inicio
for(;;){
cout << "\tMi Menu" << endl;
cout << "\t-------" << endl;
cout << "1. Opcion 1" << endl;
cout << "2. Opcion 2" << endl;
cout << "3. Opcion 3" << endl;
cout << "4. Opcion 4" << endl;
cout << "5. Salir" << endl;
//pedimos al usuario que escoja.
cin >> opcion;
//evaluamos la opcion escogida
if (opcion==1) {
cout << "\tHa elegido la opcion 1."
}else if (opcion==2){
cout << "\tHa elegido la opcion 2."
}else if (opcion==3){
cout << "\tHa elegido la opcion 3."
}else if (opcion==4){
cout << "\tHa elegido la opcion 4."
}else if (opcion==5){
cout << "Adios.." << endl;
exit(0);
//termina
}else {
cout << "Elija Bien..." << endl;
}
<< endl;
<< endl;
<< endl;
<< endl;
}
}
Como podrá observar, el bucle for sin ningún parámetro se utiliza como un bucle
infinito, esto quiere decir que nunca terminará, por eso se termina el programa por medio de
la función exit(0). También puede probar a utilizar la sentencia break para salir del bucle for.
En cada opción sólo se ha puesto una sentencia cout, pero podría ir allí todo el código
que se desearía ejecutar cuando se elija dicha opción.
10.2
Función para determinar si dos números son divisibles entre si
Construya un nuevo proyecto que se llame Ejercicio10_2 y dentro de un fichero llamado
Divisible.cpp realice un programa que:
1º Pida dos número por pantalla (M y N).
2º Escriba por pantalla que M y N son divisibles en caso de que se M/N sea una
división entera y que no son divisibles en caso contrario.
3º Vuelva a preguntar: ¿Quiere realizar otra comprobación? (S/N).
Escuela Superior de Ingenieros – Tecnun – Universidad de Navarra
Prácticas de Programación en C++
Pág. 9
4º En caso de que el usuario escriba "S", debe volver al punto 1º, si escribe "N"
el programa debe acabar, y si escribe cualquier otra cosa debe decir que se ha equivocado
contestando y debe volver al punto 3.
Nota: Un operador muy interesante para realizar este ejercicio es el operado (%). Este
operador devuelve la parte entera de una división. Por ejemplo 4 % 2, es igual 0.
10.3
Obtención de las raíces de un polinomio de segundo grado
Las raíces de un polinomio de segundo grado (x1 y x2) expresado como P ( x) = ax 2 + bx + c se
obtienen mediante la fórmula siguiente:
x1 =
−b + b 2 − 4ac
2a
x2 =
−b − b − 4ac
2a
(0.1)
2
De forma que se dan tres posibilidades en las que:
Si el contenido de la raíz es mayor que 0, las raíces son reales y distintas.
Si el contenido de la raíz es igual a cero, las raíces son reales e iguales.
Si el contenido de la raíz es menor que 0, las raíces son imaginarias.
Con lo que el algoritmo para determinar el tipo de raíces de un polinomio de segundo
grado puede plantearse de manera directa chequeando cuál de estas tres posibilidades es la
que se cumple.
A continuación se presenta el diagrama de flujo y el programa:
Escuela Superior de Ingenieros – Tecnun – Universidad de Navarra
Prácticas de Programación en C++
Pág. 10
Para este ejercicio, debe crear un proyecto nuevo al que llamará Ejercicio10_3, con un fichero
llamado Raices.cpp para realizar este ejercicio.
Este programa debe:
1º Pedir los tres coeficientes del polinomio (a, b y c).
2º Determinar si las raíces son reales (iguales o distintas) o imaginarias.
3º
Si son reales y distintas debe sacar por pantalla las dos soluciones.
(ejemplo a=1, b=3, c=2)
Si son iguales debe sacar una solución e indicar que son iguales.
(ejemplo a=1, b=2, c=1)
Si son imaginarias debe sacar las dos soluciones en el siguiente fomato:
Raíz 1: Parte real + Parte imaginaria I
Raíz 2: Parte real - Parte imaginaria I
(ejemplo a=1, b=1, c=1)
Escuela Superior de Ingenieros – Tecnun – Universidad de Navarra