ANSI C devi usare malloc() quando crei una struct?

Question

Diciamo che ho questo struct in ANSI C:

typedef struct _point 
{ 
    float x; 
    float y; 
} Point; 

e questa funzione per creare questa struct:

Point createpoint(float x, float y) 
{ 
    Point p; 
    p.x = x; 
    p.y = y; 
    return p; 
} 

Questo mi permette di creare un struct con questa funzione vale a dire:

int main() 
{ 
    Point pointOne = createpoint(5, 6); 
    Point pointTwo = createpoint(10, 4); 
    float distance = calculatedistancefunc(pointOne, pointTwo); 

    /* ...other stuff */ 

    return 0; 
} 

Qualcuno mi ha detto che questo codice non è valido, perché il struct no ot ottenere malloc 'd nella funzione createpoint(float x, float y) prima che venga restituito e che lo struct venga eliminato. Tuttavia, quando uso il mio struct in questo modo, non sembra essere cancellato.

Quindi la mia domanda è: devo malloc questo struct, e perché?/perchè no?

Answer 1

Qualunque cosa stiate facendo è del tutto corretta. La dichiarazione -

return p; 

nella funzione restituisce una copia della variabile locale p. Ma se vuoi lo stesso oggetto che è stato creato nella funzione, devi farlo malloc. Tuttavia, è necessario free in seguito.

Point createpoint(float x, float y) 
{ 
    Point p; 
    p.x = x; 
    p.y = y; 
    return p; 
} // p is no longer valid from this point. So, what you are returning is a copy of it. 

Ma -

Point* createpoint(float x, float y) 
{ 
    Point *p = malloc(sizeof(Point)); 
    p->x = x; 
    p->y = y; 
    return p; 
}// Now you return the object that p is pointing to. 

Answer 2

È possibile restituire struct in pila, il codice è valido. Si verificherebbe un problema se dovessi restituire un puntatore alla variabile locale, ma non è quello che stai facendo, stai restituendo una copia, va bene.

Answer 3

Point createpoint(float x, float y) 
{ 
    Point p; 
    p.x = x; 
    p.y = y; 
    return p; 
}/

Tutte le variabili locali nella funzione vengono eliminati after funzione ritorna.

1>passaggio per riferimento Quindi, se si sta tornando puntatore a questa variabile locale poi, dopo la funzione restituire questo variabili vengono cancellati in modo che i puntatori non sono validi.

2>passaggio per valore Ma qui si sta tornando copia di questa variabile locale per cui il suo sicuro perché la variabile locale sono gona morto quando restituisce la funzione, ma la copia del valore di ritorno verranno memorizzati nella variabile ricevitore chiamata di funzione prima del ritorno della funzione.

Answer 4

C99 consente la creazione di strutture ancora più semplice in pila.
Dato il seguito struct

typedef struct 
{ 
    float x; 
    float y; 
} Point; 

è possibile inizializzare in un po 'di C++ maniera stile costruttore con la seguente dichiarazione:

Point p = (Point){0.4, 0.5}; 

e quindi si potrebbe o accorciare il createpoint o rottami del tutto :

int main() 
{ 
    Point pointOne = (Point){5, 6}; 
    Point pointTwo = (Point){10, 4}; 
    float distance = calculatedistancefunc(pointOne, pointTwo); 
    //...other stuff 
    return 0; 
} 

Answer 5

Una chiamata a un metodo che restituisce una struttura si comporterà come se il chiamante crea una variabile temporanea della struttura tipo da qualche parte che non è visibile in nessun altro ambito e fornisce alla funzione chiamata un puntatore. La funzione chiamata inserirà quindi i dati nella posizione richiesta e, dopo la sua restituzione, il chiamante sarà in grado di leggere i dati dalla nuova variabile. Data una funzione e chiamando il codice:

StructType BuildStruct(void) 
{ 
    StructType it; 
    it.this=4; 
    it.that=23; 
    return it; 
} 

StructType myStruct; 
myStruct = BuildStruct(); 

è probabile che ci sarà almeno un'operazione di copia, se non due; la dichiarazione return it; potrebbe dover copiare dalla variabile locale it nella struttura temporanea e l'assegnazione a myStruct potrebbe richiedere la copia dalla posizione temporanea a myStruct. Nessuna situazione richiede effettivamente due operazioni di copia; alcuni ne richiedono uno (che potrebbe essere eseguito dal chiamante o dal metodo chiamato) e alcuni non ne richiedono, ma la necessità di copiare dipende dai dettagli sia nel chiamante che nel metodo chiamato.

Un disegno alternativa sarebbe:

void BuildStruct(StructType *it) 
{ 
    it->this=4; 
    it->that=23; 
} 

StructType myStruct; 
BuildStruct(&myStruct); 

Questa sarebbe probabilmente resa codice equivalente al codice meglio si possa sperare utilizzando una variabile di ritorno struttura-tipo, poiché i dati struct sarebbero disposte direttamente nella sua finale spot senza che sia necessaria alcuna copia della struttura.