Objetivos de Aprendizaje

Al terminar esta clase, habrás aprendido a:

• Entender el propósito de las funciones y por qué son esenciales en C++.
• Crear funciones correctamente, asegurando un código estructurado.
• Invocar funciones dentro de un programa y comprender cómo se ejecutan.
• Distinguir entre funciones que retornan valores y aquellas que simplemente ejecutan instrucciones.
• Comparar diferentes formas de definir funciones y elegir la mejor según la situación.

Declaración, Invocación y Definición de Funciones

En C++, las funciones son bloques de código reutilizables que permiten estructurar un programa de manera modular y organizada. Cada función encapsula una tarea específica, lo que ayuda a mejorar la claridad y mantenibilidad del código. Para poder utilizar una función en un programa, debemos seguir tres pasos fundamentales: declaracíon, invocación y definición.

Estos tres conceptos son esenciales, y cada uno cumple un propósito particular en la estructura del código. Veamos cada uno en detalle.

1. Declaración de una función

   Antes de que una función pueda ser utilizada en el código, el compilador debe ser informado de su existencia. Esto se hace a través de una declaración de función o prototipo.

   La declaración de una función le indica al compilador tres cosas fundamentales:

   • El tipo de dato que la función devolverá (o void si no devuelve nada).
   • El nombre de la función.
   • Los parámetros que acepta (si los hay), junto con sus tipos.

   La sintaxis general de una declaración de función es:

   tipo_de_retorno nombre_de_funcion (lista_de_parametros);
   

   La declaración de la función generalmente se coloca antes de main() o en un archivo de encabezado .h cuando trabajamos con múltiples archivos.

2. Invocación de una función

   Después de declarar una función, podemos invocarla, es decir, llamarla dentro del código para que se ejecute.

   Cuando se invoca una función:

   • Se ejecuta el código contenido en su definición.
   • Si la función devuelve un valor, este puede ser almacenado en una variable o utilizado directamente en una expresión.
   • Si la función es de tipo void, simplemente ejecuta sus instrucciones sin devolver nada.

   La sintaxis de la invocación de una función es simplemente escribir su nombre seguido de paréntesis con los argumentos (si los necesita):

   nombre_de_funcion(argumentos);
   

3. Definición de la función:

   Finalmente, la definición de la función es la parte donde se implementa su comportamiento. Aquí se especifican las instrucciones que se ejecutarán cuando la función sea invocada.

   La sintaxis general de una definición de función es:

   tipo_de_retorno nombre_de_funcion (lista_de_parametros) {
       // Cuerpo de la función: instrucciones a ejecutar
       return valor; // (si la función devuelve un valor)
   }
   

   Cada definición de función debe seguir las siguientes reglas:

   • Debe coincidir con la declaración (si se declaró previamente).
   • Si la función devuelve un valor (por ejemplo, int), debe incluir una instrucción return con el valor a devolver.
   • Si la función no devuelve nada (void), simplemente ejecuta sus instrucciones y no necesita return.

Flujo de ejecución

Cuando el programa se ejecuta, las funciones son llamadas en el orden en que aparecen en main(). El flujo de ejecución es el siguiente:

1. El compilador reconoce la declaración de la función.
2. En main(), cuando se encuentra una invocación de la función, el control del programa se transfiere a la definición de la función.
3. La función ejecuta sus instrucciones.
4. Si la función tiene un valor de retorno, este se devuelve a la línea donde fue invocada.
5. El flujo del programa regresa a main() o a la función que realizó la invocación.

Importancia de la declaración previa

La declaración de funciones antes de su uso es crucial porque el compilador de C++ procesa el código de arriba hacia abajo. Si intentamos llamar a una función antes de que haya sido definida o declarada, obtendremos un error.

Existen dos formas principales de abordar esto:

1. Declarar la función antes de main() y definirla después (como hemos visto hasta ahora).
2. Definir la función antes de main(), evitando así la necesidad de una declaración previa.

Ambos enfoques son válidos, pero el primero es más útil en programas grandes donde las funciones están en distintos archivos.

Enfoque: Declarar – Invocar – Definir

Uno de los enfoques más utilizados para estructurar funciones en C++ es el de declarar – invocar – definir. Siguiendo esta lógica, organizamos nuestro código en tres etapas fundamentales:

1. Declaración: Se informa al compilador sobre la existencia de la función antes de su uso, especificando su nombre, tipo de retorno y parámetros (si los hay).
2. Invocación: La función es llamada dentro del código principal (main() en la mayoría de los casos), ejecutando su contenido.
3. Definición: Se detalla la implementación de la función, especificando qué instrucciones ejecutará cuando sea invocada.

Esta estructura permite mejorar la organización del código, facilitando su mantenimiento y escalabilidad. Revisemos un ejemplo en el que aplicamos este enfoque:

Ejemplo: Función consoladice()

En el siguiente código, seguimos la secuencia declarar – invocar – definir:

#include <iostream>
using namespace std;
// Primero declaramos la función
void consoladice();
int main() {
    // Invocamos a la función
    consoladice();
    return 0;
}
// Definimos la función previamente declarada, detallando su funcionamiento interno
void consoladice() {
    cout << "Esto es una simple cadena de caracteres o literales." << endl;
    cout << "Ahora te muestro el numero cinco. Aqui esta: " << 5 << endl;
    cout << "Veamos que resultado nos da si hacemos 10/5. El resultado es: " << 10/5 << endl;
    cout << "Una forma tipica de aproximar el numero Pi es haciendo 22/7. El resultado es: " << 22/7 << endl;
    cout << "En C++ no es lo mismo escribir 22/7 que 22.0/7, el trato es diferente." << endl;
    cout << "Con este simple cambio podemos ver que 22.0/7 es igual a " << 22.0/7 << endl;
    cout << "No te parece esto una mejor aproximacion?" << endl;
}

El resultado esperado de este código es

Esto es una simple cadena de caracteres o literales.
Ahora te muestro el numero cinco. Aqui esta: 5
Veamos que resultado nos da si hacemos 10/5. El resultado es: 2
Una forma tipica de aproximar el numero Pi es haciendo 22/7. El resultado es: 3
En C++ no es lo mismo escribir 22/7 que 22.0/7, el trato es diferente.
Con este simple cambio podemos ver que 22.0/7 es igual a 3.14286
No te parece esto una mejor aproximacion?

Para entender mejor el enfoque declarar – invocar – definir, enfoquémonos en tres partes clave del código:

1. Línea 5: Declaración de la función
   • void consoladice(); le indica al compilador que en algún punto del código existirá una función llamada consoladice().
   • Se especifica que su tipo de retorno es void, lo que significa que no devolverá ningún valor.
   • Aunque aún no se conoce la implementación de consoladice(), esta declaración permite que el compilador la reconozca cuando se utilice más adelante.
2. Línea 9: Invocación de la función
   • Dentro de la función main(), la línea consoladice(); ejecuta la función.
   • En este momento, el compilador ya reconoce la existencia de consoladice() gracias a su declaración previa.
   • Cuando se invoca la función, el control del programa se transfiere a su definición, donde se ejecuta su contenido.
3. Líneas 14 a 22: Definición de la función
   • Aquí se encuentra la implementación detallada de consoladice(), especificando sus instrucciones.
   • En este caso, la función imprime varios mensajes en la consola, incluyendo números y operaciones matemáticas.
   • Una cosa importante es la diferencia entre 22/7 y 22.0/7. Cuando se usa 22/7, ambos números son enteros, lo que da como resultado 3 debido a la división entera. Sin embargo, al escribir 22.0/7, se fuerza a la operación a realizarse en punto flotante, obteniendo 3.14286.

Enfoque: Declarar e Implementar antes de Invocar

En C++, además del enfoque declarar – invocar – definir, existe otra manera válida de estructurar nuestras funciones: declarar e implementar antes de invocar. Este método combina la declaración y la definición en un solo paso, antes de que la función sea utilizada en main().

En este enfoque, en lugar de hacer una declaración previa de la función y definirla después de main(), directamente la declaramos y definimos en el mismo lugar antes de invocarla. Esto tiene la ventaja de evitar una declaración separada y hacer que el código sea más compacto y fácil de leer en programas pequeños.

La estructura general de este enfoque es de la siguiente manera:

// Definimos la función antes de main()
tipo_de_retorno nombre_de_funcion(lista_de_parametros) {
    // Cuerpo de la función
    return valor; // si es necesario
}
int main() {
    // Invocación de la función
    nombre_de_funcion(argumentos);
}

Al estar definida antes de main(), el compilador ya la conoce cuando es invocada, por lo que no es necesario hacer una declaración previa.

Ejemplo: Función consoladice() sin declaración previa

Ahora veamos un ejemplo práctico donde aplicamos este enfoque:

#include <iostream>
using namespace std;
// Definimos la función antes de invocarla
void consoladice() {
    cout << "Esto es una simple cadena de caracteres o literales." << endl;
    cout << "Ahora te muestro el numero cinco. Aqui esta: " << 5 << endl;
    cout << "Veamos que resultado nos da si hacemos 10/5. El resultado es: " << 10/5 << endl;
    cout << "Una forma tipica de aproximar el numero Pi es haciendo 22/7. El resultado es: " << 22/7 << endl;
    cout << "En C++ no es lo mismo escribir 22/7 que 22.0/7, el trato es diferente." << endl;
    cout << "Con este simple cambio podemos ver que 22.0/7 es igual a " << 22.0/7 << endl;
    cout << "No te parece esto una mejor aproximacion?" << endl;
}
int main() {
    // Invocamos a la función
    consoladice();
    return 0;
}

En este código podemos ver que:

1. Entre las lineas 5 y 13, se combina la declaración y definición

   La función consoladice() se define directamente antes de main(), sin necesidad de hacer una declaración separada.

2. En la linea 17, la función es invocada dentro del main()

   Como la función ya ha sido definida antes, el compilador la reconoce y permite su ejecución sin problemas.

3. El resultado es exactamente el mismo

   A nivel funcional, este enfoque genera el mismo comportamiento que el enfoque declarar – invocar – definir, pero con una estructura más compacta.

✅ Ventajas:

• Código más directo y compacto en programas pequeños.
• No requiere una declaración previa, lo que reduce la cantidad de líneas de código.
• Facilita la lectura en scripts cortos donde todas las funciones se encuentran en un mismo archivo.

❌ Desventajas:

• En programas grandes, puede dificultar la organización si hay muchas funciones definidas antes de main().
• Menos útil cuando se trabaja con múltiples archivos (.h y .cpp), ya que es preferible mantener la declaración en un archivo separado.

Propagación del Valor de Retorno

Hasta ahora hemos trabajado con funciones que simplemente ejecutan instrucciones sin devolver ningún resultado. Sin embargo, en muchos casos, es necesario que una función retorne un valor para que pueda ser utilizado en otros cálculos o almacenado en variables. Este proceso se conoce como propagación del valor de retorno.

En esta sección, aprenderemos cómo funcionan las funciones que devuelven valores, en qué se diferencian de las funciones de tipo void, y cómo podemos aprovechar este mecanismo en C++.

Ejemplo Práctico: Función que calcula el área de un rectángulo

Para ilustrar la propagación del valor de retorno, implementaremos una función que reciba la base y la altura de un rectángulo y calcule su área.

#include <iostream>
using namespace std;
// Función que calcula el área de un rectángulo y devuelve el resultado
double calcularArea(double base, double altura) {
    return base * altura;
}
int main() {
    double base, altura;
    
    // Pedimos al usuario que ingrese los valores
    cout << "Ingrese la base del rectangulo: ";
    cin >> base;
    cout << "Ingrese la altura del rectangulo: ";
    cin >> altura;
    // Llamamos a la función y almacenamos su resultado
    double area = calcularArea(base, altura);
    // Mostramos el resultado
    cout << "El Area del rectángulo es: " << area << endl;
    
    return 0;
}

1. La función calcularArea() devuelve un valor
   • Recibe dos valores (base y altura) como parámetros.
   • Calcula el área mediante la multiplicación base * altura.
   • Utiliza return para enviar el resultado de la operación a la parte del programa que la invocó.
2. Uso del valor de retorno en main()
   • Los valores de base y altura son ingresados por el usuario.
   • La función calcularArea() es llamada, y su resultado es almacenado en la variable area.
   • Finalmente, el resultado es mostrado en la consola.
3. Diferencia clave con una función void

   Si calcularArea() fuera de tipo void, tendríamos que mostrar el resultado directamente dentro de la función, en lugar de devolverlo a main() para su uso posterior.

Ejemplo: Función que determina si un número es par o impar

#include <iostream>
using namespace std;
bool esPar(int numero) {
    return numero % 2 == 0;
}
int main() {
    int numero;
    cout << "Ingrese un numero: "; cin >> numero;
    if (esPar(numero)) {
        cout << "El numero es par." << endl;
    } else {
        cout << "El numero es impar." << endl;
    }
    return 0;
}

Aquí, la función esPar() devuelve un true si el número es par y false si es impar, permitiendo que main() use el resultado para decidir qué mensaje mostrar.

Recursividad: Funciones que se llaman a sí mismas

La recursividad es una técnica en la que una función se invoca a sí misma para resolver problemas dividiéndolos en versiones más pequeñas de sí mismos. Es especialmente útil en algoritmos como el cálculo del factorial, la serie de Fibonacci y recorridos en estructuras de datos como árboles.

Ejemplo: Factorial de un Número

El factorial de un número n es n!=n\cdot(n-1)\cdot(n-2) \cdots 3 \cdot2 \cdot 1. Esta formulación tiene una estructura recursiva que podemos representar matemáticamente de la siguiente manera:

\begin{array}{rl} 0! &=1\\ n! &= n\cdot(n-1)!\\ \end{array}

Teniendo esto en cuenta, podemos programar esta función en C++ de la siguiente manera:

#include <iostream>
using namespace std;
 
int factorial(int n) {
    if (n == 0 || n == 1) {
        return 1;
    }
    return n*factorial(n - 1);
}
 
int main() {
    int numero;
    cout << "Ingrese un numero: "; cin >> numero;
    cout << "El factorial de " << numero << " es " << factorial(numero) << endl;
    return 0;
}

En este código:

• La función factorial(n) se llama a sí misma con n-1 hasta llegar al caso base (n == 0 o n == 1).
• La función se resuelve de manera recursiva, multiplicando los valores hasta encontrar el resultado.

Ejemplo: Números de Fibonacci

Los números de Fibonacci son aquellos comprendidos por la secuencia 1, 1, 2, 3, 5, 8, 13, \cdots. Esta secuencia se caracteriza por el hecho de que cada número es igual a la suma de los dos anteriores.

Matemáticamente, si fibo(n) es la función cuyos resultados son los números de Fibonacci, entonces posee la siguiente estructura matemática

\begin{array}{rl} fibo(0) &= 1\\ fibo(1) &= 1 \\ fibo(n) &= fibo(n-1) + fibo(n-2) \end{array}

Un ejemplo de código en C++ que muestra los números de Fibonacci es el siguiente:

#include<iostream>
 
using namespace std;
 
int fibo(int numero){
    if (numero==0||numero==1){
        return 1;
        }
    return fibo(numero-1)+fibo(numero-2);
    }
 
int main(){
    int x=0, i=0;
    cout << "ingresa un numero: "; cin >> x;
     
    while (i < x){
        cout <<"El numero de fibonacci en la posicion " << i+1 << " es: " << fibo(i)<<endl;
        i=i+1;
    }   
}

Retorno Múltiple en Funciones

En C++, una función puede devolver más de un valor utilizando estructuras como std::pair, std::tuple o referencias a variables.

Ejemplo: Función que devuelve dos valores con std::pair

#include <iostream>
#include <utility> // Para usar std::pair
using namespace std;
 
pair<int, int> dividir(int a, int b) {
    return make_pair(a / b, a % b);
}
 
int main() {
    int numerador=0, denominador=1;
     
    cout << "ingresa el numerador: "; cin >> numerador;
    cout << "Ingresa el denominador: "; cin >> denominador;
     
    pair<int, int> resultado = dividir(numerador, denominador);
 
    cout << "Cociente: " << resultado.first << endl;
    cout << "Resto: " << resultado.second << endl;
 
    return 0;
}

Aquí, la función dividir() retorna dos valores: el cociente y el residuo de una división entera.

Ejemplo: Función que devuelve dos valores con std::tuple

#include <iostream>
#include <tuple>
using namespace std;
tuple<int, int, int> operaciones(int a, int b) {
    return make_tuple(a + b, a - b, a * b);
}
int main() {
    int suma=0, resta=0, producto=0;
    int a=0, b=0;
    
    cout << "ingresa un numero: "; cin >> a;
    
    cout << "ingresa otro numero: "; cin >> b;
    
    std::tie(suma, resta, producto) = operaciones(a, b);
    cout << "Suma: " << suma << ", Resta: " << resta << ", Producto: " << producto << endl;
    return 0;
}

Sobrecarga de funciones (overloading)

La sobrecarga de funciones permite definir múltiples funciones con el mismo nombre pero diferentes tipos o cantidades de parámetros. Esto mejora la legibilidad y reutilización del código.

#include <iostream>
#include <string> // Necesario para usar std::string
#include <cmath>
using namespace std;
// Área de un cuadrado o círculo (figuras con un dato)
double area(double lado) {
    return lado * lado;
}
// Área de un rectángulo (o figuras con dos datos)
double area(double base, double altura) {
    return base * altura;
}
// area de un triangulo (o figuras con tres datos)
double area(double a, double b, double c){
	return 0.25*sqrt((a+b+c)*(a+b-c)*(a-b+c)*(-a+b+c));
}
int main() {
    string figura;
    double resultado = 0;
    double l1=0, l2=0, l3=0;
    // Pedir la figura
    cout << "Que figura es? (cuadrado, circulo, rectangulo o triangulo): ";
    cin >> figura;
    // Evaluar la figura con if-else
    if (figura == "cuadrado") {
        cout << "¿Cuanto mide su lado? "; cin >> l1;
        resultado = area(l1);
        cout << "El area del cuadrado es: " << resultado << endl;
    } 
    else if (figura == "rectangulo"){
        cout << "Cuanto mide la base? "; cin >> l1;
        cout << "Cuanto mide la altura? ";cin >> l2;
        resultado = area(l1, l2);
        cout << "El area del rectangulo es: " << resultado << endl;
    } 
    else if (figura == "circulo") {
		l1 = 3.141592653;
        cout << "Cuánto mide el radio? "; cin >> l2;
        resultado = area(l1, l2);
        cout << "El area del círculo es: " << resultado << endl;
    } 
    else if (figura == "triangulo"){
    	cout << "Cuanto miden sus lados?" << endl;
    	cout << "lado 1: "; cin >> l1;
		cout << "lado 2: "; cin >> l2;
		cout << "lado 3: "; cin >> l3;
			
		if ((l1+l2+l3)*(l1+l2-l3)*(l1-l2+l3)*(-l1+l2+l3)<0){
			cout << "el triangulo es imposible";
		}	
		else {
			resultado = area(l1,l2,l3);
			cout << "El area del triangulo es: " << resultado << endl;
		} 			
	}
    else {
        cout << "Figura no válida." << endl;
    }
    return 0;
}

Funciones inline en C++

Las funciones inline en C++ ofrecen un mecanismo para optimizar el rendimiento del programa reduciendo la sobrecarga de llamadas a función. En lugar de ejecutar una llamada convencional, el compilador intenta expandir el código de la función directamente en cada lugar donde es invocada.

Sintaxis de una función inline

inline tipo_de_retorno nombre_de_funcion(lista_de_parametros) {
    // Cuerpo de la función
    return valor; // Si es necesario
}

Al usar inline, eliminamos la necesidad de saltar a otra dirección de memoria para ejecutar la función, lo que puede reducir el tiempo de ejecución.

Diferencias entre una función inline y una función convencional

Ejemplo de función inline

#include <iostream>
using namespace std;
inline int cuadrado(int x) {
    return x * x;
}
int main() {
    cout << "El cuadrado de 5 es: " << cuadrado(5) << endl;
    return 0;
}

🔍 Proceso del compilador:

1. El compilador sustituye la llamada cuadrado(5) directamente con 5 * 5.
2. No hay salto de ejecución.
3. El cálculo se realiza en la misma línea donde se invocó la función.

Ventajas y desventajas de inline

✅ Ventajas

• Elimina la sobrecarga de llamadas a función: Reduce el tiempo de ejecución en funciones cortas y llamadas frecuentemente.
• Facilita optimización por parte del compilador: Puede mejorar el rendimiento al evitar el uso de registros de CPU y la pila.
• Asegura que el código de la función esté disponible en tiempo de compilación.

❌ Desventajas

• Aumenta el tamaño del binario: Si la función inline es usada muchas veces en un programa grande, el código se duplicará en cada punto de invocación. Esto sucede cuando se usa en funciones largas o muy repetidas en el código.
• No siempre garantiza expansión en línea: El compilador puede ignorar la solicitud de inline si considera que no es óptimo.