Parámetros de funciones en C++: por valor, por referencia y const

Parámetros frente a argumentos

Los parámetros de una función son las variables con nombre de su definición; los argumentos son los valores reales que le pasas cuando la llamas. La página anterior mostró cómo definir y llamar funciones; esta página trata de cómo entran realmente esos valores, porque C++ te ofrece varias formas y la elección afecta tanto a la corrección como a la velocidad.

Lo predeterminado en C++ es el paso por valor: la función recibe una copia.

#include <iostream>
using namespace std;

void addTen(int n) {   // n es una copia de lo que pases
    n = n + 10;
    cout << "inside: " << n << endl;
}

int main() {
    int score = 5;
    addTen(score);
    cout << "outside: " << score << endl;   // sigue siendo 5
    return 0;
}

Dentro de addTen, n es una variable independiente inicializada a partir de score. Reasignar n toca solo esa copia, así que score queda intacto de vuelta en main. Esto es seguro y predecible: la función no puede pisar tus datos por accidente, y por eso precisamente es lo predeterminado.

Paso por referencia: dejar que una función cambie a quien la llama

A veces quieres que la función modifique la variable de quien la llama. Añade un & al tipo del parámetro y se convierte en una referencia: un alias del original, no una copia:

#include <iostream>
using namespace std;

void addTen(int& n) {   // n se refiere a la variable de quien llama
    n = n + 10;
}

int main() {
    int score = 5;
    addTen(score);
    cout << score << endl;   // 15 - el original cambió
    return 0;
}

La única diferencia respecto al primer ejemplo es el &, pero ahora n y score son el mismo objeto. Esta es la manera estándar de "devolver" más de un valor o de actualizar algo en el sitio. Un uso clásico es intercambiar dos variables:

#include <iostream>
using namespace std;

void swapValues(int& a, int& b) {
    int tmp = a;
    a = b;
    b = tmp;
}

int main() {
    int x = 1, y = 2;
    swapValues(x, y);
    cout << x << " " << y << endl;   // 2 1
    return 0;
}

Sin el &, swapValues barajaría dos copias y main no vería ningún cambio: un error de principiante muy habitual.

Referencias const: acceso barato y de solo lectura

El paso por valor copia el argumento. Para un int eso no cuesta nada, pero copiar un string o un vector grande en cada llamada es trabajo real y desperdiciado. La solución es una referencia const (const T&): obtienes la velocidad de la referencia (sin copia) más una promesa garantizada por el compilador de no modificar el argumento.

#include <iostream>
#include <string>
using namespace std;

// no se hace ninguna copia del string, y no podemos cambiarlo por accidente
void greet(const string& name) {
    cout << "Hello, " << name << "!" << endl;
    // name = "x";   // sería un error de compilación - name es const
}

int main() {
    string visitor = "Ada";
    greet(visitor);
    greet("temporary");   // const& también puede enlazar a un temporal
    return 0;
}

Una regla práctica útil: pasa los tipos integrados pequeños (int, double, char, bool, punteros) por valor, y pasa los objetos grandes que solo necesitas leer por referencia const. Reserva una T& no const para los casos en los que de verdad pretendes modificar el objeto de quien llama.

Un detalle sutil: una int& n normal no puede enlazar a un temporal ni a un literal. addTen(5) del primer ejemplo no compilaría si el parámetro fuera int&, porque 5 no es una variable a la que puedas asignar un alias. Una const int& sí puede enlazar a 5, lo cual es una razón más por la que las referencias const se usan tanto.

Argumentos por defecto

Puedes dar a un parámetro un valor de reserva para que quien llama pueda omitirlo. Si falta el argumento, se usa el valor por defecto:

#include <iostream>
#include <string>
using namespace std;

void connect(const string& host, int port = 8080, bool secure = false) {
    cout << (secure ? "https" : "http") << "://"
         << host << ":" << port << endl;
}

int main() {
    connect("example.com");              // port=8080, secure=false
    connect("example.com", 443);         // secure=false
    connect("example.com", 443, true);   // los tres dados
    return 0;
}

Hay dos reglas con las que la gente tropieza. Primera, los valores por defecto deben ir al final: una vez que un parámetro tiene un valor por defecto, todos los que vienen después también deben tenerlo. No puedes escribir void f(int a = 1, int b) porque no habría forma de proporcionar b saltándote a. Segunda, cuando una función se declara en una cabecera y se define en otro sitio, pon el valor por defecto solo en la declaración, nunca lo repitas en la definición: repetirlo es un error de compilación.

Pasar arrays y vectores

Un array nativo se degrada a un puntero cuando se pasa, así que la función pierde el rastro de su tamaño; casi siempre pasas la longitud junto a él:

#include <iostream>
using namespace std;

int sum(const int arr[], int size) {   // arr aquí es en realidad un int*
    int total = 0;
    for (int i = 0; i < size; i++) total += arr[i];
    return total;
}

int main() {
    int nums[] = {4, 8, 15, 16};
    cout << sum(nums, 4) << endl;   // 43
    return 0;
}

Como el array se convirtió en un puntero, sizeof(arr) dentro de sum daría el tamaño de un puntero, no del array: un error famoso. En C++ moderno prefiere un std::vector (o un std::span en C++20), pasado por referencia const, que lleva consigo su propio tamaño:

#include <iostream>
#include <vector>
using namespace std;

int sum(const vector<int>& v) {   // sin copia, conoce su propio tamaño
    int total = 0;
    for (int x : v) total += x;
    return total;
}

int main() {
    vector<int> nums = {4, 8, 15, 16};
    cout << sum(nums) << endl;   // 43
    return 0;
}

Fíjate en el const&: quítalo y cada llamada copia el vector entero. Para un vector de cuatro elementos eso es inofensivo, pero para un millón de elementos es un derroche silencioso de rendimiento.

Parámetros de tipo puntero

También puedes pasar un puntero (T*). Igual que una referencia, esto permite a la función alcanzar los datos de quien la llama, pero un puntero puede reapuntarse o ser nulo, así que es la herramienta adecuada cuando "ningún valor" es una opción legítima:

#include <iostream>
using namespace std;

// devuelve false cuando no hay dónde escribir el resultado
bool tryParseDouble(const char* text, double* out) {
    if (out == nullptr) return false;   // protección contra el nulo
    *out = 0.0;
    for (const char* p = text; *p >= '0' && *p <= '9'; ++p) {
        *out = *out * 10 + (*p - '0');
    }
    return true;
}

int main() {
    double value;
    if (tryParseDouble("123", &value)) {
        cout << "parsed: " << value << endl;
    }
    return 0;
}

Quien llama pasa &value para compartir su dirección, y la función escribe a través de *out. La diferencia clave respecto a las referencias: un puntero podría ser nullptr, así que una función que reciba uno debería comprobarlo antes de desreferenciarlo; saltarse esa protección y desreferenciar un puntero nulo es comportamiento indefinido, normalmente un cuelgue. Si "ningún valor" nunca tiene sentido, una referencia es más limpia porque, para empezar, no puede ser nula.

Siguiente: Referencias

Los parámetros son donde las referencias se ganan el sueldo, pero las referencias son una característica por derecho propio: alias que puedes crear para cualquier variable, no solo dentro de la firma de una función. La siguiente página profundiza en cómo funcionan las referencias por sí solas: cómo declararlas, por qué deben inicializarse de inmediato, la diferencia entre una referencia lvalue y una referencia const, y las formas sutiles en que una referencia puede acabar colgando.