Sucesión de Fibonacci con C++

La Sucesión de Fibonacci es una sucesión de números enteros iniciando con dos números base, 0 y 1. Cada número de la sucesión es el resultado de la suma de los dos anteriores; por ejemplo:

[0] [1] [1] [2] [3] [5] [8] [13] [21] [34]

Esta Sucesión de Fibonacci solo muestra 10 números y se observa cómo se genera cada número sumando los dos números anteriores, es decir: 0 + 1 = 1, 1 + 1 = 2, 1 + 2 = 3, 2 + 3 = 5… hasta 13 + 21 = 34…

Código fuente:

El programa que nos permite generar la Sucesión de Fibonacci en C++ es muy sencillo y tan solo ocupa un total de 26 líneas de código, es interactivo ya que le permite al usuario el límite de números de la sucesión.



#include <iostream>
using namespace std;

const string INFO = "Este programa imprime la sucesion de fibonacci desde \
1 hasta N, \nsiendo este ultimo un numero ingresado por el usuario\n";

int main() {
  unsigned long long aux = 1, fib = 0, lim, init;

  cout << INFO << endl;
  cout << "Ingrese un numero para la sucesion de fibonacci: ";
  cin >> lim;

  if(lim > 0) {
    for(init = 1; init <= lim; init++) {
      cout << "[" << fib << "] ";
      aux += fib; /* lo mismo que aux = aux + fib; */
      fib = aux - fib;
    }
  } else {
    cout << "El numero debe ser mayor a cero!!" << endl;
  }
  cout << "\n";

  return 0;
}

Las dos primeras líneas corresponden a la directiva del preprocesador #include y la segunda corresponde al espacio de nombres en C++; son temas relacionados con la estructura básica explicados de forma sencilla.

Constante INFO:
const string INFO = "Este programa imprime la sucesion de fibonacci desde \
1 hasta N, \nsiendo este ultimo un numero ingresado por el usuario\n";

En este fragmento de código se crea una constante de tipo string que contiene un texto para ser mostrado al usuario, no es obligatoria, solo es información sobre el programa. En C++ las constantes se declaran con la palabra reservada const y se recomienda que el nombre de la constante sea en mayúscula.

Función main():
int main() {
   /* Bloque de codigo de la función principal */
   return 0;
}

Al igual que en otros lenguajes como C, Go, Kotlin o Java, en el lenguaje de programación C++ es obligatoria la función main(), es la única función que se llama de forma automática cuando el programa es ejecutado y solo el código en su interior es ejecutado; esto incluye llamadas a funciones, instancia de objetos, entre otros.

Declarando variables:
unsigned long long aux = 1, fib = 0, lim, init;

En C++ hay 4 tipos de datos para trabajar con números enteros, estos son, short, int, long y long long, tanto positivos como negativos pero con una diferencia que los divide en mixtos y solo positivos. Si deseamos usar tipos de datos que sólo admiten valores positivos N > 0, se debe preceder al tipo de dato con la palabra clave unsigned como se hace en la primera línea del fragmento de código anterior, ya de lo contrario estaremos trabajando con tipos mixtos (tanto negativos como positivos).

En este fragmento de código se declaran 4 variables de tipo long long que sólo admiten números positivos; pero solo dos de ellas son inicializadas; la primera, llamada aux, se inicializa con 1 y la segunda, llamada fib, se inicializa con 0. Se inicializan ya que se usarán como contadores o acumuladores, de lo contrario sus valores serán indeterminados y generarán resultados inesperados.

Mostrando información y leyendo datos por teclado:
cout << INFO << endl;
cout << "Ingrese un numero para la sucesion de fibonacci: ";
cin >> lim;

Este es el fragmento de código más sencillo de todo programa ya que solo muestra en pantalla la información almacenada en la constante INFO y le indica al usuario que ingrese un número. Con el objeto cin se lee el dato ingresado al usuario y con el operador de extracción «>>» almacenamos el dato en la variable lim.

Procesando la información y mostrando la Sucesión de Fibonacci:
if(lim > 0) {
  for(init = 1; init <= lim; init++) {
    cout << "[" << fib << "] ";
    aux += fib; /* lo mismo que aux = aux + fib; */
    fib = aux - fib;
  }
} else {
  cout << "El numero debe ser mayor a cero!!" << endl;
}

Cabe recordar que el rango de los números de la Sucesión que se muestran van desde 1 hasta N, es decir, si vamos a mostrar 10 números de la sucesión como se hizo al inicio, se requiere de un bucle que vaya desde 1 hasta N; por lo tanto se requiere que N sea mayor a 0, esto se garantiza con una sentencia if() que verifique si se cumple con este requisito para procesar la información.

El bucle for() va a iterar desde 1 hasta N, siendo este ultimo el limite superior de numeros que se mostraran; en su interior hay un objeto cout que imprime cada número Fibonacci encerrado entre [..] y dos operaciones básicas; la primera corresponde a la suma abreviada de aux = aux + fib en la línea #4 usando el operador de aritmética abreviada += que suma el valor en aux y fib, luego lo agina a aux, ambas formas son válidas; la segunda, en la línea #5, es una resta entre aux y fib sin abreviación ya que aux siempre será mayor que fib.



La sentencia else solo emite un mensaje en caso de que el número ingresado por el usuario sea igual o menor a cero o en caso contrario, que sea un carácter o string.

¿Como funciona internamente las operaciones aritméticas?:

Como se describe arriba, hay dos operaciones aritméticas básicas, la primera es una suma y la segunda es una resta; pero, ¿cómo funcionan tras bambalinas? Aquí veremos lo que ocurre con cada operación.

Primera operación aritmética, aux += fibo aux = aux + fib:

Para ilustrar lo que ocurre con esta primera operación aritmética, he modificado el código para imprimir una tabla que nos muestre con mayor detalles los cambios en las variables con cada iteración.

Ingrese un numero para la sucesion de fibonacci: 10
|	Valores iniciales	| = |	nuevo valor de Aux	|
|	Fib		Aux	|   |	     aux += fib		|
|	[0]	+	[1]	| = |		[1]		|
|	[1]	+	[1]	| = |		[2]		|
|	[1]	+	[2]	| = |		[3]		|
|	[2]	+	[3]	| = |		[5]		|
|	[3]	+	[5]	| = |		[8]		|
|	[5]	+	[8]	| = |		[13]		|
|	[8]	+	[13]	| = |		[21]		|
|	[13]	+	[21]	| = |		[34]		|
|	[21]	+	[34]	| = |		[55]		|
|	[34]	+	[55]	| = |		[89]		|

Al inicio de esta publicación se dijo que la serie inicia con 2 números base, 0 y 1. Al lado izquierdo de la tabla se muestra que Fib tiene como valor inicial 0 mientras que Aux tiene como valor inicial 1; al lado derecho se muestra cada cambio en el valor de la variable Aux después de la suma hecha en cada iteración.

Segunda operacion aritmetica, fib = aux - fib:

Para ilustrar lo que ocurre con esta segunda operación aritmética, he modificado nuevamente el código para imprimir una tabla que nos muestre con mayor detalles los cambios en las variables con cada iteración.

Ingrese un numero para la sucesion de fibonacci: 10 
|	  fib = aux - fib	| = |  Resultado de la Sucesion	|
|	Aux		Fib	|   |	   Numero Fibonacci	|
|	[1]	-	[1]	| = |		[0]		|
|	[2]	-	[1]	| = |		[1]		|
|	[3]	-	[2]	| = |		[1]		|
|	[5]	-	[3]	| = |		[2]		|
|	[8]	-	[5]	| = |		[3]		|
|	[13]	-	[8]	| = |		[5]		|
|	[21]	-	[13]	| = |		[8]		|
|	[34]	-	[21]	| = |		[13]		|
|	[55]	-	[34]	| = |		[21]		|
|	[89]	-	[55]	| = |		[34]		|

Con la anterior operación aritmética se altera el valor de la variable aux, se dijo que este valor es mayor que el valor de fib y la tabla nos muestra que efectivamente si es así; excepto en los primeros valores cuyo valor es igual. Al realizar la resta entre aux y fib nos da como resultado el valor del número Fibonacci; este resultado coincide con el valor de la variable fib en la tabla de la anterior operación.