Ejemplos de capítulos 1 a 6

Veamos algunos ejemplos que utilicen los que ya sabemos de C++.

Pero antes introduciremos, sin explicarlo en profundidad, dos elementos que nos permitirán que nuestros programas se comuniquen con nosotros. Se trata de la salida estándar, "cout" y de la entrada estándar "cin". Estos elementos nos permiten enviar a la pantalla o leer desde el teclado cualquier variable o constante, incluidos literales. Lo veremos más detalladamente en un capítulo dedicado a ellos, de momento sólo nos interesa cómo usarlos para mostrar o leer cadenas de caracteres y variables.

Nota: en realidad "cout" es un objeto de la clase "ostream", y "cin" un objeto de la clase "istream" pero los conceptos de clase y objeto quedarán mucho más claros en capítulos posteriores.

El uso es muy simple:

#include <iostream>
using namespace std;

cout << <variable|constante> [<< <variable|constante>...];
cin >> <variable> [>> <variable>...];

Veamos un ejemplo:

#include <iostream>
using namespace std;

int main()
{
   int a;

   cin >> a;
   cout << "la variable a vale " << a; 
   return 0;
}

Un método muy útil para "cout" es "endl", que hará que la siguiente salida se imprima en una nueva línea.

cout << "hola" << endl;

Otro método, este para "cin" es get(), que sirve para leer un carácter, pero que nos puede servir para detener la ejecución de un programa.

Esto es especialmente útil cuando trabajamos con compiladores como Dev-C++, que crea programas de consola. Cuando se ejecutan los programas desde el compilador, al terminar se cierra la ventana automáticamente, impidiendo ver los resultados. Usando get() podemos detener la ejecución del programa hasta que se pulse una tecla.

A veces, sobre todo después de una lectura mediante cin, pueden quedar caracteres pendiente de leer. En ese caso hay que usar más de una línea cin.get().

#include <iostream>
using namespace std;

int main()
{
   int a;

   cin >> a;
   cout << "la variable a vale " << a; 
   cin.get();
   cin.get();
   return 0;
}

Las líneas "#include <iostream>" y "using namespace std;" son necesarias porque las declaraciones que permiten el acceso a "cout" y "cin" están en una librería externa. Con estos elementos ya podemos incluir algunos ejemplos.

Te aconsejo que intentes resolver los ejemplos antes de ver la solución, o al menos piensa unos minutos sobre ellos.

Ejemplo 1  

Primero haremos uno fácil. Escribir un programa que muestre una lista de números del 1 al 20, indicando a la derecha de cada uno si es divisible por 3 o no.

// Este programa muestra una lista de números, 
// indicando para cada uno si es o no múltiplo de 3.
// 11/09/2000 Salvador Pozo

#include <iostream> // librería para uso de cout
using namespace std;

int main() // función principal
{
   int i; // variable para bucle

   for(i = 1; i <= 20; i++) // bucle for de 1 a 20
   { 
      cout << i; // muestra el número
      if(i % 3 == 0) cout << " es múltiplo de 3"; // resto==0
      else cout << " no es múltiplo de 3"; // resto != 0
      cout << endl; // cambio de línea
   } 

   cin.get();
   return 0;
}

El enunciado es el típico de un problema que puede ser solucionado con un bucle "for". Observa el uso de los comentarios, y acostúmbrate a incluirlos en todos tus programas. Acostúmbrate también a escribir el código al mismo tiempo que los comentarios. Si lo dejas para cuando has terminado el código, probablemente sea demasiado tarde, y la mayoría de las veces no lo harás. ;-)

También es una buena costumbre incluir al principio del programa un comentario extenso que incluya el enunciado del problema, añadiendo también el nombre del autor y la fecha en que se escribió. Además, cuando hagas revisiones, actualizaciones o correcciones deberías incluir una explicación de cada una de ellas y la fecha en que se hicieron.

Una buena documentación te ahorrará mucho tiempo y te evitará muchos dolores de cabeza.

Ejemplo 2  

Escribir el programa anterior, pero usando una función para verificar si el número es divisible por tres, y un bucle de tipo "while".

// Este programa muestra una lista de números, 
// indicando para cada uno si es o no múltiplo de 3.
// 11/09/2000 Salvador Pozo

#include <iostream> // librería para uso de cout
using namespace std;

// Prototipos:
bool MultiploDeTres(int n);

int main() // función principal
{
   int i = 1; // variable para bucle

   while(i <= 20) // bucle hasta i igual a 20
   { 
      cout << i; // muestra el número
      if(MultiploDeTres(i)) cout << " es múltiplo de 3";
      else cout << " no es múltiplo de 3";
      cout << endl; // cambio de línea
      i++;
   } 

   cin.get();
   return 0;
}

// Función que devuelve verdadero si el parámetro 'n' en 
// múltiplo de tres y falso si no lo es
bool MultiploDeTres(int n)
{
   if(n % 3) return false; else return true;
}

Comprueba cómo hemos declarado el prototipo de la función "MultiploDeTres". Además, al declarar la variable i le hemos dado un valor inicial 1. Observa que al incluir la función, con el nombre adecuado, el código queda mucho más legible, de hecho prácticamente sobra el comentario. Por último, fíjate en que la definición de la función va precedida de un comentario que explica lo que hace. Esto también es muy recomendable.

Ejemplo 3  

Escribir un programa que muestre una salida de 20 líneas de este tipo:

1
1 2
1 2 3
1 2 3 4
...

// Este programa muestra una lista de números
// de este tipo:
// 1
// 1 2
// 1 2 3
// ...

// 11/09/2000 Salvador Pozo

#include <iostream> // librería para uso de cout
using namespace std;

int main() // función principal
{
   int i, j; // variables para bucles

   for(i = 1; i <= 20; i++) // bucle hasta i igual a 20
   {
      for(j = 1; j <= i; j++) // bucle desde 1 a i
         cout << j << " "; // muestra el número
      cout << endl; // cambio de línea
   }

   cin.get();
   return 0;
}

Este ejemplo ilustra el uso de bucles anidados. El bucle interior, que usa "j" como variable toma valores entre 1 e "i". El bucle exterior incluye, además del bucle interior, la orden de cambio de línea, de no ser así, la salida no tendría la forma deseada. Además, después de cada número se imprime un espacio en blanco, de otro modo los números aparecerían amontonados.

Ejemplo 4  

Escribir un programa que muestre una salida con la siguiente secuencia numérica:

1, 5, 3, 7, 5, 9, 7, ..., 23

La secuencia debe detenerse al llegar al 23.

El enunciado es rebuscado, pero ilustra el uso de los bucles "do...while".

La secuencia se obtiene partiendo de 1 y sumando y restando 4 y 2, alternativamente. Veamos cómo resolverlo:

// Programa que genera la secuencia: 
// 1, 5, 3, 7, 5, 9, 7, ..., 23
// 11/09/2000 Salvador Pozo

#include <iostream> // librería para uso de cout 
using namespace std;

int main() // función principal 
{ 
   int i = 1; // variable para bucles 
   bool sumar = true; // Siguiente operación es suma o resta
   bool terminado = false; // Condición de fin 

   do { // Hacer
      cout << i; // muestra el valor en pantalla
      terminado = (i == 23); // Actualiza condición de fin
      // Puntuación, separadores
      if(terminado) cout << "."; else cout << ", "; 
      // Calcula siguiente elemento
      if(sumar) i += 4; else i -= 2; 
      sumar = !sumar; // Cambia la siguiente operación
   } while(!terminado); // ... mientras no se termine
   cout << endl; // Cambio de línea

   cin.get();
   return 0;
}

Ejemplo 5  

Escribir un programa que pida varios números, hasta que el usuario quiera terminar, y los descomponga en factores primos.

No seremos especialmente espléndidos en la optimización, por ejemplo, no es probable que valga la pena probar únicamente con números primos para los divisores, podemos probar con algunos que no lo sean, al menos en este ejercicio no será una gran diferencia.

Piensa un momento en cómo resolverlo e inténtalo, después puedes continuar leyendo.

Lo primero que se nos ocurre, al menos a mi, cuando nos dicen que el programa debe ejecutarse mientras el usuario quiera, es implementar un bucle "do..while", la condición de salida será que usuario responda de un modo determinado a cierta pregunta.

En cada iteración del bucle pediremos el número a descomponer y comprobaremos si es divisible entre los números entre 2 y el propio número.

No podemos empezar 1, ya que sabemos que todos los números son divisibles entre 1 infinitas veces, por eso empezamos por el 2.

Pero si probamos con todos los números, estaremos intentando dividir por todos los pares entre 2 y el número, y sabremos de antemano que ninguno de ellos es un factor, ya que sólo el 2 es primo y par a la vez, por lo tanto, podemos probar con 2, 3 y a partir de ahí incrementar los factores de dos e dos.

Por otra parte, tampoco necesitamos llegar hasta el factor igual al número, en realidad sólo necesitamos alcanzar la raíz cuadrada del número, ya que ninguno de los números primos entre ese valor y número puede ser un factor de número.

Supongamos que tenemos en número 'n', y que la raíz cuadrada de 'n' es 'r'. Si existe un número 'x' mayor que 'r' que es un factor primo de 'n', por fuerza debe existir un número 'h', menor que 'r', que multiplicado por 'x' sea 'n'. Pero ya hemos probado todos los números por debajo de 'r', de modo que si existe ese número 'h' ya lo hemos extraído como factor de 'n', y si hemos llegado a 'r' sin encontrarlo, es que tampoco existe 'x'.

Por ejemplo, el número 257. Su raíz cuadrada es (aproximada), 16. Es decir, deberíamos probar con 2, 3, 5, 7, 11 y 13 (nuestro programa probará con 2, 3, 5, 7, 9, 11, 13 y 15, pero bueno). Ninguno de esos valores es un factor de 257. El siguiente valor primo a probar sería 17, pero sabemos que el resultado de dividir 257 por 17 es menor que 17, puesto que la raíz cuadrada de 257 es 16.031. Sin embargo ya hemos probado con todos los primos menores de 17, con resultado negativo, así que podemos decir que 17 no es factor de 257, ni tampoco, por la misma razón, ningún número mayor que él.

Ya tenemos dos buenas optimizaciones, veamos cómo queda el programa:

// Programa que descompone números en factores primos
// 26/07/2003 Salvador Pozo

#include <iostream> // librería para uso de cout 
using namespace std;

int main()
{
   int numero;
   int factor;
   char resp[12];
   
   do {
      cout << "Introduce un número entero: ";
      cin >> numero;
      factor = 2;
      while(numero >= factor*factor) {
         if(!(numero % factor)) {
            cout << factor << " * ";
            numero = numero / factor;
            continue;
         }
         if(factor == 2) factor++;
         else factor += 2;
      }
      cout << numero << endl;
      cout << "Descomponer otro número?: ";
      cin >> resp;
   } while(resp[0] == 's' || resp[0] == 'S');
   return 0;
}

Vemos claramente el bucle "do..while", que termina leyendo una cadena y repitiendo el bucle si empieza por 's' o 'S'.

En cada iteración se lee un numero, y se empieza con el factor 2. Ahora entramos en otro bucle, este "while", que se repite mientras el factor sea menor que la raíz cuadrada de numero (o mientras numero sea menor o igual al factor al cuadrado).

Dentro de ese bucle, si numero es divisible entre factor, mostramos el factor, actualizamos el valor de numero, dividiéndolo por factor, y repetimos el bucle. Debemos probar de nuevo con factor, ya que puede ser factor primo varias veces. Para salir del bucle sin ejecutar el resto de las sentencias usamos la sentencia "continue".

Si factor no es un factor primo de número, calculamos el siguiente valor de factor, que será 3 si factor es 2, y factor + 2 en otro caso.

Cuando hemos acabado el bucle "while", el valor de numero será el del último factor.

Puedes intentar modificar este programa para que muestre los factores repetidos en forma exponencial, en lugar de repetitiva, así, los factores de 256, en lugar de ser: "2 * 2 * 2 * 2 * 2 * 2 * 2 * 2", serían "2⁸".