Funciones

Idea principal

Una funcion es un bloque de codigo con nombre que realiza una tarea concreta. En lugar de repetir las mismas lineas en todo el programa, escribes la logica una vez y la llamas cuando la necesitas.

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

int main() {
    int total = sumar(3, 5);  // total vale 8
    return 0;
}

Antes de usar clases (POO), conviene dominar funciones: los metodos de una clase son funciones que viven dentro de un objeto.

Para que sirven las funciones

Beneficio	Explicacion
Reutilizar codigo	Escribes la logica una vez y la usas en muchos lugares
Leer mejor el programa	`calcularPromedio(notas)` se entiende mas que 20 lineas sueltas
Dividir el problema	Cada funcion resuelve una parte: leer datos, validar, calcular, imprimir
Depurar mas facil	Si falla el promedio, revisas solo la funcion del promedio
Preparar POO	Un metodo es una funcion asociada a un objeto

Anatomia de una funcion

Forma general:

tipo_retorno nombre(tipo param1, tipo param2, ...) {
    // cuerpo: instrucciones
    return valor;   // opcional si tipo_retorno no es void
}

Ejemplo desglosado:

double calcularArea(double base, double altura) {
    double area = base * altura / 2.0;
    return area;
}

Parte	En el ejemplo	Significado
Tipo de retorno	`double`	Que tipo de dato devuelve la funcion
Nombre	`calcularArea`	Como la identificas al llamarla
Parametros	`double base, double altura`	Datos que recibe (entrada)
Cuerpo	`{ ... }`	Lo que hace la funcion
`return`	`return area;`	Devuelve un valor y termina la funcion

Llamar (invocar) una funcion

Llamar una funcion significa ejecutar su codigo pasandole los argumentos que necesita:

#include <iostream>

void saludar(std::string nombre) {
    std::cout << "Hola, " << nombre << std::endl;
}

int main() {
    saludar("Ana");           // imprime: Hola, Ana
    saludar("Carlos");
    return 0;
}

Reglas basicas:

El nombre de la llamada debe coincidir con el de la funcion.
Los argumentos ("Ana") se asignan a los parametros (nombre) en el mismo orden.
Si la funcion devuelve un valor, puedes guardarlo en una variable o usarlo en una expresion.

int cuadrado(int x) {
    return x * x;
}

int main() {
    int r = cuadrado(4);           // r = 16
    std::cout << cuadrado(5);      // imprime 25
    return 0;
}

Funciones que no devuelven nada (`void`)

Cuando la funcion solo hace una accion (imprimir, guardar en archivo, modificar algo por referencia) y no necesitas un valor de vuelta, usa void:

void mostrarMenu() {
    std::cout << "1. Agregar producto\n";
    std::cout << "2. Buscar producto\n";
    std::cout << "3. Salir\n";
}

No uses return con un valor en funciones void. Puedes usar return; solo para salir antes del final si hace falta.

Parametros: paso por valor

Por defecto, C++ copia el argumento al parametro. La funcion trabaja con la copia; el original no cambia:

void incrementar(int n) {
    n = n + 1;  // solo cambia la copia local
}

int main() {
    int x = 10;
    incrementar(x);
    std::cout << x;  // sigue siendo 10
    return 0;
}

Esto es util cuando la funcion no debe modificar la variable original (por ejemplo, solo leer un numero para calcular algo).

Parametros: paso por referencia (`&`)

Si quieres que la funcion modifique la variable original, pasa el parametro por referencia con &:

void incrementar(int& n) {
    n = n + 1;  // modifica el original
}

int main() {
    int x = 10;
    incrementar(x);
    std::cout << x;  // ahora es 11
    return 0;
}

Tambien se usa referencia para evitar copiar datos grandes (por ejemplo, un arreglo o un std::string muy largo), aunque no quieras cambiarlos — en ese caso combinas con const (siguiente seccion).

Parametros: referencia constante (`const &`)

Para tipos “pesados” o cuando solo lees el dato sin modificarlo:

#include <string>

void imprimirNombre(const std::string& nombre) {
    std::cout << nombre << std::endl;
    // nombre = "otro";  // ERROR: no se puede modificar
}

Buena practica: para std::string, structs y arreglos que solo lees, usa const Tipo&.

Resumen rapido:

Forma	La funcion puede modificar el original	Copia el dato
`Tipo param`	No	Si
`Tipo& param`	Si	No
`const Tipo& param`	No	No

Valores por defecto en parametros

Puedes dar un valor inicial a un parametro; si al llamar no lo pasas, se usa el default:

void imprimirLinea(std::string texto, int veces = 1) {
    for (int i = 0; i < veces; i++) {
        std::cout << texto << std::endl;
    }
}

int main() {
    imprimirLinea("Hola");           // imprime 1 vez
    imprimirLinea("Hola", 3);        // imprime 3 veces
    return 0;
}

Los parametros con default deben ir al final de la lista de parametros.

Declaracion vs definicion

En proyectos con varios archivos (como en Sintaxis basica) separas:

Declaracion (prototipo): le dice al compilador que la funcion existe y como se llama.
Definicion: contiene el cuerpo con la logica real.

include/saludo.h — declaracion:

#ifndef SALUDO_H
#define SALUDO_H

#include <string>

void saludar(const std::string& nombre);
int sumar(int a, int b);

#endif

src/saludo.cpp — definicion:

#include "saludo.h"
#include <iostream>

void saludar(const std::string& nombre) {
    std::cout << "Hola, " << nombre << std::endl;
}

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

src/main.cpp — uso:

#include "saludo.h"

int main() {
    saludar("UNEXPO");
    return sumar(2, 3);
}

El compilador necesita ver la declaracion antes de cada llamada. Por eso incluyes el .h donde uses la funcion.

Alcance (scope) de variables

Variables declaradas dentro de una funcion son locales: solo existen mientras se ejecuta esa funcion.

int global = 100;  // ambito global (evitar abusar en ejercicios)

void ejemplo() {
    int local = 5;
    std::cout << global << std::endl;  // OK: puede leer global
    std::cout << local << std::endl;
}

int main() {
    ejemplo();
    // std::cout << local;  // ERROR: local no existe aqui
    return 0;
}

En la materia y en los trabajos, preferi pasar datos por parametros en lugar de usar muchas variables globales.

`return` y multiples salidas

return devuelve un valor y termina la funcion de inmediato:

int absoluto(int n) {
    if (n < 0) {
        return -n;
    }
    return n;
}

Toda ruta del codigo en una funcion que no es void debe llegar a un return (o el compilador avisara).

Si necesitas devolver varios valores, opciones habituales al inicio del curso:

Devolver un struct con varios campos.
Usar parametros por referencia para “salida”.

struct Resultado {
    int cociente;
    int resto;
};

Resultado dividir(int a, int b) {
    Resultado r;
    r.cociente = a / b;
    r.resto = a % b;
    return r;
}

Ejemplo completo: validar y calcular

Programa pequeno que muestra como dividir responsabilidades:

#include <iostream>

bool esPositivo(int n) {
    return n > 0;
}

double promedio(double a, double b) {
    return (a + b) / 2.0;
}

void mostrarResultado(double valor) {
    std::cout << "Promedio: " << valor << std::endl;
}

int main() {
    double n1, n2;
    std::cout << "Nota 1: ";
    std::cin >> n1;
    std::cout << "Nota 2: ";
    std::cin >> n2;

    if (esPositivo(static_cast<int>(n1)) && esPositivo(static_cast<int>(n2))) {
        mostrarResultado(promedio(n1, n2));
    } else {
        std::cout << "Las notas deben ser positivas.\n";
    }
    return 0;
}

Cada funcion tiene una responsabilidad clara: validar, calcular o mostrar.

Errores frecuentes

Error	Que pasa	Como evitarlo
Olvidar `return` en funcion no `void`	Comportamiento indefinido o error de compilacion	Asegura un `return` en cada rama
Confundir declaracion y definicion	“undefined reference” al enlazar	Define la funcion en un `.cpp` y declara en `.h`
Modificar un parametro por valor esperando cambiar el original	El original no cambia	Usa referencia `&` si necesitas modificar
Parametros default no al final	Error de compilacion	Pon los defaults al final de la lista
Llamar antes de declarar	“was not declared in this scope”	Prototipo arriba o `#include` del header

Relacion con POO y trabajos de la materia

En POO, las funciones dentro de una clase se llaman metodos y suelen operar sobre los atributos del objeto.
En los ejercicios asignados, muchas veces conviene crear funciones para: leer datos, buscar en un arreglo, ordenar, escribir archivo, etc.
El ejercicio del criptograma pide POO: ahi la logica ira en metodos de una clase, pero el concepto base sigue siendo el mismo que una funcion con parametros y retorno.

Resumen

Concepto	Recuerda
Funcion	Bloque con nombre que encapsula una tarea
Parametro	Variable formal que recibe la funcion
Argumento	Valor concreto que pasas al llamar
`return`	Devuelve un valor y sale de la funcion
`void`	Funcion sin valor de retorno
Por valor	Copia; no modifica el original
Por referencia `&`	Puede modificar el original
`const &`	Eficiente y solo lectura
Prototipo	Declaracion en `.h`; definicion en `.cpp`

Siguiente paso

Organiza varios archivos con Archivos y compilacion.
Cuando domines funciones sueltas, pasa a Clases y objetos — ahi las funciones viven dentro de clases.
Para varias funciones con el mismo nombre y distintos parametros, ver Sobrecarga.