maikelowen ...
Eso de "una función que devuelva un array" (un array de cualquier cosa) es delicado en C. Recuerda que las variables que se declaren dentro del cuerpo de una función son locales, es decir, se destruyen al terminar la ejecución de la función, y por lo tando sus valores quedan
indefinidos. Esto es, dichos valores pueden conservarse o no, es algo impredecible.
Si vas a construir una función cuyo propósito sea actualizar los valores de los elementos de un array, dicho array ha de ser declarado FUERA de la función. Por ejemplo, sea un código que actualice por teclado los valores de un array de tres elementos. Tal vez pienses en algo como
int * f ( void );
int main() {
/* tomar tres valores desde el teclado */
int *x = f();
/* imprimir */
cout << "Los numeros son: " << x[0] << ", " << x[1] << ", " << x[2] << endl << endl;
return 0;
}
/* Lee tres valores enteros del teclado, y los almacena en vector */
int * f ( void ) {
int x[3];
cout << "1er numero: ";
cin >> x[0];
cout << "2do numero: ";
cin >> x[1];
cout << "3er numero: ";
cin >> x[2];
cin.ignore();
return x;
}
Pues, dicho código es
incorrecto y de hecho el compilador podría informarte al respecto con un mensaje como
"'warning: address of local variable ‘x’ returned", indicándote que estás devolviendo una variable local como retorno de la función.
Puede que este código funcione bien, o puede que no. Es lo que llamamos una técnica de programación potencialmente peligrosa. Algo más apropiado sería:
void f( int * );
int main() {
/* tomar tres valores desde el teclado */
int x[3];
f(x);
/* imprimir */
cout << "Los numeros son: " << x[0] << ", " << x[1] << ", " << x[2] << endl << endl;
return 0;
}
/* Lee tres valores enteros del teclado, y almacena en vector */
void f ( int *x ) {
cout << "1er numero: ";
cin >> x[0];
cout << "2do numero: ";
cin >> x[1];
cout << "3er numero: ";
cin >> x[2];
cin.ignore();
}
donde declarar el array
x FUERA de la función
f, y entonces invocas a
f(x) con el nombre del array como argumento de entrada,
y no como valor de retorno.
Parece extraño que si la función devuelve el array actualizado, entonces dicho array deba pasarse como argumento de ENTRADA, en lugar de devolverse como SALIDA ¡¡¡Pero así es C
!!!, y la razón es que los arrays son técnicamente apuntadores a una zona de memoria que contiene ciertos datos, en lugar de ser objetos abstractos como en la P.O.O.
En lenguajes de programación orientados a objeto, como MATLAB, sí es permitido tener entidades de objeto como valores de retorno de una función. Tal vez este comportamiento se puede emular en C++ mediante referencias a objeto, pero ese sería otro tema.
============================================================================
Es posible poner a la función a devolver un array "a juro", indicando que devuelva
una copia de su propio argumento como valor de retorno (ojo que es una copia de su argumento, no el mismo argumento como tal). Pero eso sería algo redundante, por ejemplo:
int * f( int * );
int main() {
/* tomar tres valores desde el teclado */
int x[3];
int * y;
y = f(x);
/* imprimir */
cout << "Los numeros son: " << x[0] << ", " << x[1] << ", " << x[2] << endl << endl;
return 0;
}
/* Lee tres valores enteros del teclado, y almacena en vector */
int * f ( int *x ) {
cout << "1er numero: ";
cin >> x[0];
cout << "2do numero: ";
cin >> x[1];
cout << "3er numero: ";
cin >> x[2];
cin.ignore();
return x;
}
Funciona igual que antes, sólo que ahora devuelve una copia de
x como retorno. Ahora, ¿qué sentido tiene tener en
main() dos array's, uno
x, y otro
y, para tener el segundo como copia del primero?
Es lo que te hizo
Blaster cuando definió en el main() los arreglos
datos e
info, ambos serán la misma cosa luego de llamar la función
invocarPersonas(), entonces bastaba dejar sólo el primero.
Autor
En línea
