Foro de elhacker.net

Primeramente Saludos. :D
Se me plantea la siguiente duda... ¿cómo a traves de una función podemos devolver un array de estructuras? Por ejemplo:

struct personas{

int edad;
string nombre;

};

personas funcion(){



return ¿?

}

int main (){

personas p[2];

}



Es decir se supone que yo introduciré tanto la edad para p[0] y p[1] y lo mismo con el nombre... pero como se hace para devolver con la función todo esto y pasarlo a otro array que yo me invente..por ejemplo personas pNuevo[2];

Es que cuando es solo una cosa no tengo problema...por ejemplo:


struct persona {
int edad;
string nombre;

}

personas funcion(){

persona p;

return p;
}

int main(){

personas W;

W=funcion();
// A  p  se supone que ya le he introducido tanto el nombre como la edad.

cout<<W.nombre;
cout<<W.edad;

}


El problema lo tengo cuando es mas de una personas.


Un saludo y gracias de antemano.Disculpen si no me entienden del todo... :-X

Hola maikelowen

Eso que planteas no presenta ningún problema ya que en C/C++ el nombre de un arreglo no es más que un apuntador al tipo de dato almacenado en el arreglo. Así dicho tipo de dato sea una estructura. Lo comprenderás más plenamente al leer el tema "Apuntadores en C" en un buen libro de texto o alguna buena página web.

Te pongo un ejemplo. El programa siguiente pide al usuario los datos de 2 personas y los almacena en un arreglo de registros de personas. A continuación, y para verificar que los datos han sido guardados correctamente, los muestra en pantalla.

La primera función, pide los datos al usuario registrarPersonas() pide los datos por consola, y los almacena en un arreglo de struct's. La segunda función mostrarPersonas() recibe dicho arreglo como argumento (que como ya dije no es más que un apuntador al primer struct guardado en el vector), e imprime los datos de los primeros 2 elementos (personas) guardados.

Está codificado para C++, ya que vi que en tu código original incluiste la clase string. Si lo quieres estrictamente para C, házmelo saber.

#include <iostream>
#include <string>
 
using namespace std;
 
struct persona {
	int edad;
	string nombre;
};
 
void registrarPersonas( struct persona *, int );
void mostrarPersonas( struct persona *, int );
 
int main () {
 
	struct persona p[10];
 
	/* registra 2 personas */
	registrarPersonas( p, 2 );
 
	/* muestra los datos de las 2 personas */
	mostrarPersonas( p, 2);
 
	return 0;
}
 
/* Registra datos de N personas en el arreglo */
void registrarPersonas( struct persona *p, int N ) {
 
	int i;
 
	for ( i = 0; i < N; i++ ) {
		cout << "Persona " << i+1 << ":" << endl;
		cout << "   " << "nombre: ";
		getline(cin, p[i].nombre );
 
		cout << "   " << "edad: ";
		cin >> p[i].edad;
		cout << endl;
 
		while ( cin.get() != '\n' ) ;	/* limpiar buffer de entrada */
	}
}
 
/* Imprime los datos de las primeras N personas en el arreglo */
void mostrarPersonas( struct persona *p, int N ) {
 
	int i;
 
	cout << "Imprimiendo datos:" << endl << endl;
	for ( i = 0; i < N; i++ ) {
		cout << "Persona " << i+1 << ":" << endl;
		cout << "   " << "nombre: " << p[i].nombre << endl;
 
		cout << "   " << "edad: " << p[i].edad << endl << endl;
	}
}

Observa el resultado en la consola:


=========================================================
Persona 1:
   nombre: maria a
   edad: 14

Persona 2:
   nombre: jose e. p.
   edad: 31

Imprimiendo datos:

Persona 1:
   nombre: maria a
   edad: 14

Persona 2:
   nombre: jose e. p.
   edad: 31
=========================================================

Muchas gracias yoel_alejandro, pero la función no me gustaría que fuera de tipo void. Por eso en mi caso pues que era de tipo struct...bueno en mi caso "personas", porque quiero devolver un array de estructuras mediante un return...pero no se como se hace :(

Supongo que quieres hacer algo como esto:

#include <iostream>
using namespace std;
 
struct persona {
    string nombre;
    int edad;
};
 
persona La_funcion (string nam, int ed){
    persona retorno;
    retorno.nombre = nam;
    retorno.edad = ed;
    return retorno;
 
}
 
int main(){
   string nam = "Pepe";
   int ed = 22;
   persona El_Pepe = La_funcion (nam, ed);
   cout << El_Pepe.nombre << endl;
   cout << El_Pepe.edad << endl;
}
 

Así llamas a una función para que devuelva un struct, en el caso de un array del mismo, se hace del mismo modo.

Obviamente se puede abreviar, pero para hacerlo mas claro lo he puesto en plan "basto"

Lo de devolver un array... bueno, ahi ya es algo mas complejo, ya que deberías de meter todos los valores a la vez en la función, o pasarla por parámetro, o construir el array fuera de la función e ir añadiendo valores a la misma llamando a la función

Se me ha ocurrido hacerlo de la siguiente forma, que opinas:

/*
 * File:   main.cpp
 * Author: owen
 *
 * Created on 30 de diciembre de 2014, 22:03
 */

#include <cstdlib>
#include <string>
#include <iostream>

using namespace std;


struct personas {
   
    string nombre;
    int edad;
   
   
   
};
   
   
personas funcionIntroduccionDatos(){
   
    personas p;
   
    cout<<"Introduzca nombre: ";
    cin>>p.nombre;
    cout<<"Introduzca edad: ";
    cin>>p.edad;
   
    return p;
   
   
   
   
}   





int main(int argc, char** argv) {
   
    string palabra;
    int contador=0;
   
    personas P[5];
   
    //Limpio Array
   
    for(int i=0;i<5;i++){
            P.nombre=" ";
            P.edad=0;
        }
   
   
    do{
   
        cout<<"Desea introduccir datos de persona (Si o No): ";
        cin>>palabra;
        if(palabra=="Si"){
           
        P[0+contador]=funcionIntroduccionDatos();
        contador++;     
               
        }
       
       
       
       
    }while(palabra=="Si");
   
   
    cout<<"Datos almacenados: "<<endl;
   
    for(int i=0;i<5;i++){
        cout<<"Nombre: "<<P.nombre<<endl;
        cout<<"Edad: "<<P.edad<<endl;
        }
   
   
    return 0;
   
   
   
}

Puedes hacer algo asi:

typedef struct
{
    int edad;
    string nombre;
} persona;
 
persona* registrarPersonas( persona* datos, int n);
 
int main(void)
{
    persona datos[2];
    persona* info;
 
    info = registrarPersonas(datos, 2);
 
    for(int i = 0; i < 2; i++)
        cout << "Nombre: " << info[i].nombre << "\nEdad: "   << info[i].edad << endl;
 
    return 0;
}
persona* registrarPersonas( persona* datos, int n)
{
    for(int i = 0; i < n; i++)
    {
        cout << "Nombre: ";
        getline(cin, datos[i].nombre );
 
        cout << "Edad: ";
        cin >> datos[i].edad;
        cin.ignore();
    }
    return datos;
}
 

Un Saludo

A eso era lo que queria llegar... pero no entiendo muy bien como está puesto todo... ;(

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.