Devolver estructura de la función (C)

Question

Necesito crear una estructura dentro de una función (dinámicamente con malloc) Entonces necesito poder enviarlo a mi principal, y usarlo allí. No tengo problemas para crearlo, simplemente necesito ayuda para enviarlo a mi página principal, y tampoco estoy seguro de cómo acceder una vez que lo tengo allí.

struct retValue * fn() { 
struct retValue 
{ 
    int number; 
}; 

struct retValue* st = malloc(sizeof(*st)); 


return(???); 
} 

Ese es el código que tengo hasta ahora.

Gracias por cualquier ayuda. Avíseme si necesita algo aclarado.

EDIT:

Ok Se necesita alguna aclaración.

Lo que estoy tratando de lograr, es la capacidad de pasar una estructura a través de una función a mi principal. Dentro de la función, debo declarar variables y asignarles valores. Luego, en general, debo imprimir cada variable de la estructura a la pantalla. No se pueden usar variables globales (y por lo tanto no asumo estructuras globales).

Esperemos que aclare las cosas.

EDIT 2:

que he descubierto mi problema. Para aquellos interesados, primero necesitaba tener el prototipo de estructura fuera de mis funciones. Entonces podría pasar st y luego acceder correctamente. Gracias a todos, y perdón por la pobre redacción.

Answer 1

// make the structure def global so that main() and fun() know about it. 
struct retValue { 
int number; 
};  

// function fn returns a pointer to the structure retValue 
struct retValue * fn() {  

struct retValue* st = malloc(sizeof(*st)); 

// return the pointer to the newly allocated structure. 
return(st); 
} 

int main() { 

// call fn() to create a new structure dynamically. 
struct retValue *st = fn(); 
} 

Answer 2

simplemente: return st;

Answer 3

obtendrá cientos de respuestas a esta pregunta. :)

1. Puede devolver un puntero directamente. P.ej. return st, Su función principal podrá entonces acceder a los miembros de la estructura como en st->number. Asegúrese de que el free principal sea el puntero cuando esté listo.

2. Esto no es necesariamente un gran patrón de diseño. Su llamada (fn) está asignando memoria, pero su interlocutor (principal) debe ocuparse de las consecuencias. También puede estructurar esto con la asignación principal de la memoria (usando malloc o en la pila directamente) y pasando el puntero para que fn lo use. Entonces el malloc/free sucede en el mismo lugar. De lo contrario, querrás asegurarte de ponerle a tu función fn algo tan claro como allocateMyStructure, así que está claro que la devolución debe ser liberada.

P.S. No estoy seguro sobre las reglas para definir estructuras dentro de una función, pero no debería hacer eso aquí. Declare struct retValue arriba de main y su función fn, para que ambos puedan "ver" el tipo declarado.

Answer 4

Declare la estructura en un archivo de encabezado común e inclúyalo en su archivo de origen y luego devuelva el st de su función actual. Eso debería funcionar.

Answer 5

struct retValue { int number; }; 

int main(...) { 
    struct retValue *myval; 

    myval = fn(); 
} 

struct retValue *fn() { 
    struct retValue* st = malloc(sizeof(*st)); 

    return st; 
} 

Answer 6

Una cosa que me gustaría señalar ... ya que la estructura es local a la función, no es una estructura global que coincide exactamente con que, de lo contrario podría tener problemas, ¿cómo main() ¿Sabes qué hay en esa estructura? ¿Puedes aclarar?

Editar: Parece que mi respuesta ha confirmado lo que pensaba.

 
struct retValue 
{ 
    int number; 
}; 

int main(int argc, char **argv){ 
    struct retValue *ptr; 
    ptr = fn(); 
    /* do what you have to do... */ 
    .... 
    return 0; 
} 

struct retValue * fn() { 
    struct retValue* st = malloc(sizeof *st); 

    /* do you work on the structure */ 
    st->number = 5; 

    return st; 
} 

Por cierto alguien publicó this antes en la actualidad.

Espero que esto ayude, Saludos cordiales, Tom.