15 Funciones II: Parámetros por valor y por referencia

Dediquemos algo más de tiempo a las funciones.

Hasta ahora siempre hemos declarado los parámetros de nuestras funciones del mismo modo. Sin embargo, éste no es el único modo que existe para pasar parámetros.

La forma en que hemos declarado y pasado los parámetros de las funciones hasta ahora es la que normalmente se conoce como "por valor". Esto quiere decir que cuando el control pasa a la función, los valores de los parámetros en la llamada se copian a "objetos" locales de la función, estos "objetos" son de hecho los propios parámetros.

Lo veremos mucho mejor con un ejemplo:

#include <iostream>
using namespace std;

int funcion(int n, int m);

int main() {
   int a, b;
   a = 10;
   b = 20;

   cout << "a,b ->" << a << ", " << b << endl;
   cout << "funcion(a,b) ->"
        << funcion(a, b) << endl;
   cout << "a,b ->" << a << ", " << b << endl;
   cout << "funcion(10,20) ->"
        << funcion(10, 20) << endl;

   return 0;
}

int funcion(int n, int m) {
   n = n + 2;
   m = m - 5;
   return n+m;
}

Bien, ¿qué es lo que pasa en este ejemplo?

Empezamos haciendo a = 10 y b = 20, después llamamos a la función "funcion" con las objetos a y b como parámetros. Dentro de "funcion" esos parámetros se llaman n y m, y sus valores son modificados. Sin embargo al retornar a main, a y b conservan sus valores originales. ¿Por qué?

La respuesta es que lo que pasamos no son los objetos a y b, sino que copiamos sus valores a los objetos n y m.

Piensa, por ejemplo, en lo que pasa cuando llamamos a la función con parámetros constantes, es lo que pasa en la segunda llamada a "funcion". Los valores de los parámetros no pueden cambiar al retornar de "funcion", ya que esos valores son constantes.

Si los parámetros por valor no funcionasen así, no sería posible llamar a una función con valores constantes o literales.

Referencias a objetos

Las referencias sirven para definir "alias" o nombres alternativos para un mismo objeto. Para ello se usa el operador de referencia (&).

Sintaxis:

<tipo> &<alias> = <objeto de referencia>
<tipo> &<alias>

La primera forma es la que se usa para declarar objetos que son referencias, la asignación es obligatoria ya que no pueden definirse referencias indeterminadas.

La segunda forma es la que se usa para definir parámetros por referencia en funciones, en estos casos, las asignaciones son implícitas.

Ejemplo:

#include <iostream>
using namespace std;

int main() {
   int a;
   int &r = a;

   a = 10;
   cout << r << endl;

   return 0;
}

En este ejemplo los identificadores a y r se refieren al mismo objeto, cualquier cambio en una de ellos se produce en el otro, ya que son, de hecho, el mismo objeto.

El compilador mantiene una tabla en la que se hace corresponder una dirección de memoria para cada identificador de objeto. A cada nuevo objeto declarado se le reserva un espacio de memoria y se almacena su dirección. En el caso de las referencias, se omite ese paso, y se asigna la dirección de otro objeto que ya existía previamente.

De ese modo, podemos tener varios identificadores que hacen referencia al mismo objeto, pero sin usar punteros.

Pasando parámetros por referencia

Si queremos que los cambios realizados en los parámetros dentro de la función se conserven al retornar de la llamada, deberemos pasarlos por referencia. Esto se hace declarando los parámetros de la función como referencias a objetos. Por ejemplo:

#include <iostream>
using namespace std;

int funcion(int &n, int &m);

int main() {
   int a, b;

   a = 10; b = 20;
   cout << "a,b ->" << a << ", " << b << endl;
   cout << "funcion(a,b) ->" << funcion(a, b) << endl;
   cout << "a,b ->" << a << ", " << b << endl;
   /* cout << "funcion(10,20) ->"
           << funcion(10, 20) << endl; // (1)
   es ilegal pasar constantes como parámetros cuando
   estos son referencias */

   return 0;
}

int funcion(int &n, int &m) {
   n = n + 2;
   m = m - 5;
   return n+m;
}

En este caso, los objetos "a" y "b" tendrán valores distintos después de llamar a la función. Cualquier cambio de valor que realicemos en los parámetros dentro de la función, se hará también en los objetos referenciadas.

Esto quiere decir que no podremos llamar a la función con parámetros constantes, como se indica en (1), ya que aunque es posible definir referencias a constantes, en este ejemplo, la función tiene como parámetros referencias a objetos variables.

Y si bien es posible hacer un casting implícito de un objeto variable a uno constante, no es posible hacerlo en el sentido inverso. Un objeto constante no puede tratarse como objeto variable.

Punteros como parámetros de funciones

Esto ya lo hemos dicho anteriormente, pero no está de más repetirlo: los punteros son objetos como cualquier otro en C++, por lo tanto, tienen las mismas propiedades y limitaciones que el resto de los objetos.

Cuando pasamos un puntero como parámetro de una función por valor pasa lo mismo que con cualquier otro objeto.

Dentro de la función trabajamos con una copia del parámetro, que en este caso es un puntero. Por lo tanto, igual que pasaba con el ejemplo anterior, las modificaciones en el valor del parámetro serán locales a la función y no se mantendrán después de retornar.

Sin embargo, no sucede lo mismo con el objeto apuntado por el puntero, puesto que en ambos casos será el mismo, ya que tanto el puntero como el parámetro tienen como valor la misma dirección de memoria. Por lo tanto, los cambios que hagamos en los objetos apuntados por el puntero se conservarán al abandonar la función.

Ejemplo:

#include <iostream>
using namespace std;

void funcion(int *q);

int main() {
   int a;
   int *p;

   a = 100;
   p = &a;
   // Llamamos a funcion con un puntero
   funcion(p); // (1)
   cout << "Variable a: " << a << endl;
   cout << "Variable *p: " << *p << endl;
   // Llamada a funcion con la dirección de "a" (constante)
   funcion(&a);  // (2)
   cout << "Variable a: " << a << endl;
   cout << "Variable *p: " << *p << endl;

   return 0;
}

void funcion(int *q) {
   // Cambiamos el valor de la variable apuntada por
   // el puntero
   *q += 50;
   q++;
}

Dentro de la función se modifica el valor apuntado por el puntero, y los cambios permanecen al abandonar la función. Sin embargo, los cambios en el propio puntero son locales, y no se conservan al regresar.

Analogamente a como lo hicimos antes al pasar una constante literal, podemos pasar punteros variables o constantes como parámetro a la función. En (1) usamos un variable de tipo puntero, en (2) usamos un puntero constante.

De modo que con este tipo de declaración de parámetro para función estamos pasando el puntero por valor. ¿Y cómo haríamos para pasar un puntero por referencia?:

void funcion(int* &q);

El operador de referencia siempre se pone junto al nombre de la variable.

En esta versión de la función, las modificaciones que se hagan para el valor del puntero pasado como parámetro, se mantendrán al regresar al punto de llamada.

Arrays como parámetros de funciones

Cuando pasamos un array como parámetro en realidad estamos pasando un puntero al primer elemento del array, así que las modificaciones que hagamos en los elementos del array dentro de la función serán permanentes aún después de retornar.

Sin embargo, si sólo pasamos el nombre del array de más de una dimensión no podremos acceder a los elementos del array mediante subíndices, ya que la función no tendrá información sobre el tamaño de cada dimensión.

Para tener acceso a arrays de más de una dimensión dentro de la función se debe declarar el parámetro como un array. Ejemplo:

#include <iostream>
using namespace std;

#define N 10
#define M 20

void funcion(int tabla[][M]);
// recuerda que el nombre de los parámetros en los
// prototipos es opcional, la forma:
// void funcion(int [][M]);
// es válida también.

int main() {
   int Tabla[N][M];
...
   funcion(Tabla);
...
   return 0;
}

void funcion(int tabla[][M]) {
...
   cout << tabla[2][4] << endl;
...
}

Otro problema es que, a no ser que diseñemos nuestra función para que trabaje con un array de un tamaño fijo, en la función nunca nos será posible calcular el número de elementos del array.

En este último ejemplo, la tabla siempre será de NxM elementos, pero la misma función admite como parámetros arrays donde la primera dimensión puede tener cualquier valor. El problema es cómo averiguar cual es ese valor.

El operador sizeof no nos sirve en este caso, ya que nos devolverá siempre el tamaño de un puntero, y no el del array completo.

Por lo tanto, deberemos crear algún mecanismo para poder calcular ese tamaño. El más evidente es usar otro parámetro para eso. De hecho, debemos usar uno para cada dimensión. Pero de momento veamos cómo nos las arreglamos con una:

#include <iostream>
using namespace std;

#define N 10
#define M 20

void funcion(int tabla[][M], int n);

int main() {
   int Tabla[N][M];
   int Tabla2[50][M];

   funcion(Tabla, N);
   funcion(Tabla2, 50);
   return 0;
}

void funcion(int tabla[][M], int n) {
   cout << n*M << endl;
}

Generalizando más, si queremos que nuestra función pueda trabajar con cualquier array de dos dimensiones, deberemos prescindir de la declaración como array, y declarar el parámetro como un puntero. Ahora, para acceder al array tendremos que tener en cuenta que los elementos se guardan en posiciones de memoria consecutivas, y que a dos índices consecutivos de la dimensión más a la derecha, le corresponden posiciones de memoria adyacentes.

Por ejemplo, en un array declarado como int tabla[3][4], las posiciones de tabla[1][2] y tabla[1][3] son consecutivas. En memoria se almacenan los valores de tabla[0][0] a tabla[0][3], a continuación los de tabla[1][0] a tabla[1][3] y finalmente los de tabla[2][0] a tabla[2][3].

Si sólo disponemos del puntero al primer elemento de la tabla, aún podemos acceder a cualquier elemento, pero tendremos que hacer nosotros las cuentas. Por ejemplo, si "t" es un puntero al primer elemento de tabla, para acceder al elemento tabla[1][2] usaremos la expresión t[1*4+2], y en general para acceder al elemento tabla[x][y], usaremos la expresión t[x*4+y].

El mismo razonamiento sirve para arrays de más dimensiones. En un array de cuatro, por ejemplo, int array[N][M][O][P];, para acceder al elemento array[n][m][o][p], siendo "a" un puntero al primer elemento, usaremos la expresión: a[p+o*P+m*O*P+n*M*O*P] o también a[p+P*(n+m+o)+O*(m+n)+M*n].

Por ejemplo:

#include <iostream>
using namespace std;

#define N 10
#define M 20
#define O 25
#define P 40

void funcion(int *tabla, int n, int m, int o, int p);

int main() {
   int Tabla[N][M][O][P];

   Tabla[3][4][12][15] = 13;
   cout << "Tabla[3][4][12][15] = " <<
     Tabla[3][4][12][15] << endl;
   funcion((int*)Tabla, N, M, O, P);
   return 0;
}

void funcion(int *tabla, int n, int m, int o, int p) {
   cout << "tabla[3][4][12][15] = " <<
     tabla[3*m*o*p+4*o*p+12*p+15] << endl;
}

Estructuras como parámetros de funciones

Las estructuras también pueden ser pasadas por valor y por referencia.

Las reglas se les aplican igual que a los tipos fundamentales: las estructuras pasadas por valor no conservarán sus cambios al retornar de la función. Las estructuras pasadas por referencia conservarán los cambios que se les hagan al retornar de la función.

En el caso de las estructuras, los objetos pueden ser muy grandes, ocupando mucha memoria. Es por eso que es frecuente enviar referencias como parámetros, aunque no se vayan a modificar los valores de la estructura. Esto evita que el valor del objeto deba ser depositado en la pila para ser recuperado por la función posteriormente.

Funciones que devuelven referencias

También es posible devolver referencias desde una función, para ello basta con declarar el valor de retorno como una referencia.

Sintaxis:

<tipo> &<identificador_función>(<lista_parámetros>);

Esto nos permite que la llamada a una función se comporte como un objeto, ya que una referencia se comporta exactamente igual que el objeto al que referencia, y podremos hacer cosas como usar esa llamada en expresiones de asignación. Veamos un ejemplo:

#include <iostream>
using namespace std;

int &Acceso(int*, int);

int main() {
   int array[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};

   Acceso(array, 3)++;
   Acceso(array, 6) = Acceso(array, 4) + 10;

   cout << "Valor de array[3]: " << array[3] << endl;
   cout << "Valor de array[6]: " << array[6] << endl;

   return 0;
}

int &Acceso(int* vector, int indice) {
   return vector[indice];
}

Este uso de las referencias es una herramienta muy potente y útil que, como veremos más adelente, tiene múltiples aplicaciones.

Por ejemplo, veremos en el capítulo sobre sobrecarga que este mecanismo es imprescindible.