0
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.
|
Nota: En C no existen referencias de este tipo, y la forma de pasar parámetros por referencia es usar un puntero. Por supuesto, para pasar una referencia a un puntero se usa un puntero a puntero, etc.
La idea original de la implementación de referencias en C++ no es la de crear parámetros variables (algo que existe, por ejemplo, en PASCAL), sino ahorrar recursos a la hora de pasar como parámetros objetos de gran tamaño.
Por ejemplo, supongamos que necesitamos pasar como parámetro a una función un objeto que ocupe varios miles de bytes. Si se pasa por valor, en el momento de la llamada se debe copiar en la pila todo el objeto, y la función recupera ese objeto de la pila y se lo asigna al parámetro. Sin embargo, si se usa una referencia, este paso se limita a copiar una dirección de memoria.
|
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 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 ite 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 &(int*, int);
int main() {
int array[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
(array, 3)++;
(array, 6) = (array, 4) + 10;
cout << "Valor de array[3]: " << array[3] << endl;
cout << "Valor de array[6]: " << array[6] << endl;
return 0;
}
int &(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.
Ir al Principio
Comentarios