Fundamentos de las Funciones

En C++, una función es una unidad de código encapsulada con un nombre específico que permite ejecutar una tarea determinada. Las funciones permiten la reutilización de código y pueden sobrecargarse para ofrecer múltiples implementaciones bajo el mismo nombre.

Estructura Básica y Llamada

Una función típica consta de un tipo de retorno, un nombre, una lista de parámetros entre paréntesis y un cuerpo delimitado por llaves.

void procesarDatos(int cantidad) {
    // Lógica de procesamiento
}

int main() {
    int elementos = 5;      // Argumento
    procesarDatos(elementos); // Llamada a la función
    return 0;
}

La ejecución se realiza mediante el operador de llamada (los paréntesis). Durante la llamada, los argumentos inicializan los parámetros formales y el control del programa se transfiere a la función. Al finalizar, la sentencia return devuelve el control y, opcionalmente, un valor al invocador.

Parámetros y Argumentos

Los argumentos son los valores iniciales de los parámetros. No hay un orden de evaluación garantizado para los argumentos, por lo que el compilador puede evaluarlos en cualquier secuencia. El número y los tipos de los argumentos deben ser compatibles con la lista de parámetros.

La lista de parámetros puede estar vacía, lo cual se puede expresar implícitamente o explícitamente con void para mantener compatibilidad con C.

void tareaA() { /* ... */ }
void tareaB(void) { /* ... */ }

Cada parámetro debe declararse de forma independiente, incluso si comparten el mismo tipo, y sus nombres deben ser únicos dentro del ámbito de la función.

Objetos Locales y Ciclo de Vida

El cuerpo de la función define un ámbito local. Las variables definidas aquí son objetos locales. Su ciclo de vida depende de cómo se declaren:

• Objetos automáticos: Se crean al pasar por su declaración y se destruyen al final del bloque. Si no se inicializan explícitamente, su valor es indeterminado.
• Objetos estáticos locales: Se inicializan una sola vez antes de que el flujo de control pase por su declaración y mantienen su valor entre llamadas a la función. Su ciclo de vida dura hasta que el programa termina.

Declaraciones y Compilación Separada

Las funciones deben declararse antes de su uso. La declaración (prototipo) incluye el tipo de retorno, el nombre y los tipos de los parámetros, omitiendo el cuerpo.

La compilación separada permite dividir el código en múltiples archivos. Las declaraciones van en archivos de cabecera (.hpp) y las definiciones en archivos de código fuente (.cpp).

// utilidades.hpp
#ifndef UTILIDADES_HPP
#define UTILIDADES_HPP

int elevarAlCuadrado(int valor);

#endif

// operaciones.cpp
#include "utilidades.hpp"

int elevarAlCuadrado(int valor) {
    return valor * valor;
}

// principal.cpp
#include "utilidades.hpp"
#include <iostream>

int main() {
    int numero = 6;
    std::cout << elevarAlCuadrado(numero) << "\n";
    return 0;
}

Para compilar este ejemplo en Linux con GCC:

$ g++ -c operaciones.cpp && g++ -c principal.cpp
$ g++ operaciones.o principal.o -o app
$ ./app

Mecanismos de Paso de Parámetros

El tipo del parámetro dicta cómo interactúa con el argumento. Si es un tipo de referencia, se vincula directamente al argumento (paso por referencia). Si es un tipo no referenciado, se copia el valor (paso por valor).

Paso por Valor y Punteros

En el paso por valor, las modificaciones al parámetro no afectan al argumento original. Los punteros siguen esta regla: se copia la dirección de memoria, por lo que reasignar el puntero local no altera el puntero original, aunque desreferenciarlo sí modifica el objeto apuntado.

void restablecer(int *puntero) {
    *puntero = 0;   // Modifica el objeto apuntado
    puntero = nullptr; // Solo modifica la copia local del puntero
}

En C++ moderno, se prefiere el uso de referencias sobre punteros para acceder a objetos externos, salvo que se necesite expresar la ausencia de un objeto (puntero nulo).

Paso por Referencia y Constantes

Las referencias actúan como alias, permitiendo modificar el argumento original y evitando copias innecesarias. Si la función no necesita modificar el argumento, debe declararse como referencia constante (const T&).

El compilador ignora las constantes de nivel superior (top-level const) en los parámetros. Por lo tanto, void func(int) y void func(const int) tienen la misma firma y no pueden sobrecargarse. Sin embargo, las constantes de nivel inferior (low-level const), como punteros o referencias a const, sí distinguen firmas.

Parámetros de Tipo Arreglo

Los arreglos no se pueden copiar por valor y, al pasarlos como argumentos, decaen a punteros a su primer elemento.

void mostrar(const int *inicio);
void mostrar(const int arreglo[]);
void mostrar(const int arreglo[10]);

Las tres declaraciones anteriores son equivalentes; el parámetro se trata como const int*. Para manejar el tamaño del arreglo, se utilizan tres técnicas comunes:

1. Marca de fin: Usar un centinela (como el carácter nulo en cadenas de C).
2. Punteros de inicio y fin: Pasar dos punteros, uno al primer elemento y otro al siguiente al último.
3. Tamaño explícito: Pasar un parámetro adicional con el número de elementos.

Alternativamente, se puede usar una referencia a un arreglo para preservar la dimensión, aunque esto limita la función a arreglos de un tamaño exacto:

void mostrarFijo(int (&arreglo)[10]) {
    for (int elem : arreglo) {
        std::cout << elem << " ";
    }
}

Argumentos de Línea de Comandos y Parámetros Variables

La función main puede aceptar argumentos de la línea de comandos mediante int argc (cantidad de argumentos) y char *argv[] (arreglo de cadenas).

Para funciones que aceptan un número variable de argumentos del mismo tipo, C++11 introdujo std::initializer_list:

#include <iostream>
#include <initializer_list>

void desplegar(std::initializer_list<double> valores) {
    for (auto it = valores.begin(); it != valores.end(); ++it) {
        std::cout << *it << " ";
    }
    std::cout << "\n";
}

int main() {
    desplegar({1.1, 2.2, 3.3});
    return 0;
}

Los elementos de initializer_list son siempre constantes. Para tipos heterogéneos o interoperabilidad con C, se utilizan los parámetros de elipsis (...), aunque su uso en C++ puro es limitado debido a la falta de seguridad de tipos.

Tipos de Retorno y la Sentencia return

La sentencia return termina la ejecución de la función. Las funciones void pueden usar return; para salir prematuramente. Las funciones con tipo de retorno deben devolver un valor compatible en todas las rutas de ejecución (excepto main, que asume return 0; si se omite).

Es un error grave devolver referencias o punteros a variables locales automáticas, ya que su memoria se libera al terminar la función, resultando en referencias colgantes o punteros salvajes.

Inicialización de Lista y Retorno de Arreglos

C++11 permite devolver una lista de valores entre llaves para inicializar el objeto de retorno:

#include <vector>
#include <string>

std::vector<std::string> compararCadenas(const std::string &a, const std::string &b) {
    if (a.size() != b.size()) return {"diferente"};
    return {"igual", "longitud", "coincidente"};
}

Las funciones no pueden devolver arreglos directamente, pero sí punteros o referencias a ellos. Se puede simplificar la sintaxis usando alias de tipos o tipos de retorno finales (trailing return types):

using Matriz = int[8];

// Usando alias
Matriz* obtenerBufferA();

// Usando tipo de retorno final
auto obtenerBufferB(int indice) -> int(*)[8];

Sobrecarga de Funciones y Resolución

La sobrecarga permite definir múltiples funciones con el mismo nombre en el mismo ámbito, siempre que sus listas de parámetros difieran en cantidad o tipo. El compilador utiliza la codificación de nombres (name mangling) para distinguir estas funciones a nivel de enlace.

Coincidencia de Funciones (Function Matching)

Cuando se llama a una función sobrecargada, el compilador sigue un proceso de tres pasos para resolver la llamada:

1. Identificar funciones candidatas: Funciones con el mismo nombre y visibles en el punto de llamada.
2. Seleccionar funciones viables: Candidatas cuyo número de parámetros coincida con los argumentos y cuyos tipos sean compatibles.
3. Encontrar la mejor coincidencia: Evaluar las conversiones de tipo necesarias para cada argumento.

Si no hay una mejor coincidencia clara, el compilador reporta un error de llamada ambigua.

Rangos de Conversión de Tipos

Las conversiones se clasifican por prioridad para determinar la mejor coincidencia:

1. Coincidencia exacta (incluye conversiones de arreglo/función a puntero y ajustes de const de nivel superior).
2. Conversión mediante adición de const de nivel inferior.
3. Promoción de tipos (ej. char a int).
4. Conversiones aritméticas o de punteros.
5. Conversiones de tipos definidos por el usuario (clases).

Las promociones y conversiones aritméticas pueden causar ambigüedades inesperadas, por lo que deben manejarse con cuidado en el diseño de interfaces sobrecargadas.

Características Especiales y Optimización

Argumentos Predeterminados

Los parámetros pueden tener valores por defecto. Si un parámetro tiene un valor predeterminado, todos los parámetros a su derecha también deben tenerlo. Los valores predeterminados solo deben especificarse una vez en el ámbito (generalmente en la declaración).

Funciones Inline y Constexpr

La palabra clave inline sugiere al compilador que inserte el cuerpo de la función en el punto de llamada para evitar la sobrecarga de la llamada, ideal para funciones pequeñas y frecuentes. Es solo una sugerencia y el compilador puede ignorarla.

Las funciones constexpr pueden evaluarse en tiempo de compilación. Su cuerpo debe ser muy restrictivo, conteniendo típicamente solo una sentencia return con expresiones constantes, y todos sus parámetros y tipo de retorno deben ser tipos literales.

Depuración con Assert y NDEBUG

La macro assert (de <cassert>) evalúa una expresión en tiempo de ejecución; si es falsa, imprime un diagnóstico y aborta el programa. Es útil para verificar invariantes y precondiciones que "nunca deberían fallar".

El comportamiento de assert depende de la macro NDEBUG. Si NDEBUG está definida, assert se convierte en una operación nula, eliminando el código de verificación en compilaciones de lanzamiento (Release).

#include <iostream>
#include <cassert>

void procesarLote(int tamano) {
    assert(tamano > 0); // Verifica precondición
    // Lógica de procesamiento
    
#ifndef NDEBUG
    std::cerr << "Depuración: procesando lote de tamaño " << tamano 
              << " en " << __func__ << "\n";
#endif
}

Es crucial que las expresiones dentro de assert no tengan efectos secundarios, ya que no se ejecutarán si NDEBUG está definido.

Punteros a Funciones

El tipo de una función está determinado por su tipo de retorno y su lista de parámetros. Se pueden declarar punteros que apunten a funciones específicas.

int calcular(int a, int b) { return a + b; }

// Declaración del puntero a función
int (*operacion)(int, int) = nullptr;
operacion = calcular; // Asignación

int resultado = operacion(5, 3); // Llamada a través del puntero

Los punteros a funciones pueden usarse como parámetros o tipos de retorno. Al usarlos como parámetros, el tipo de función decae automáticamente a un puntero a función. Para mejorar la legibilidad, se recomienda encarecidamente el uso de alias de tipos (using o typedef):

using FuncionMatematica = int(int, int);

void ejecutarOperacion(int x, int y, FuncionMatematica func) {
    std::cout << "Resultado: " << func(x, y) << "\n";
}

// Retorno de puntero a función
auto seleccionarOperacion(char tipo) -> int(*)(int, int) {
    return (tipo == '+') ? calcular : nullptr;
}