Restituisce uno `struct` da una funzione in C

Oggi stavo insegnando a un paio di amici come usare C structs. Uno di loro ha chiesto se si poteva restituire una structda una funzione, a cui ho risposto: "No! È piacerebbe tornare puntatori in modo dinamico malloced struct. S al posto"

Venendo da qualcuno che fa principalmente C ++, mi aspettavo di non essere in grado di restituire structi valori. In C ++ puoi sovraccaricare l'oggetto operator =per i tuoi oggetti e ha perfettamente senso avere una funzione per restituire l'oggetto in base al valore. In C, tuttavia, non hai questa opzione e quindi mi ha fatto pensare a cosa sta effettivamente facendo il compilatore. Considera quanto segue:

struct MyObj{
    double x, y;
};

struct MyObj foo(){
    struct MyObj a;

    a.x = 10;
    a.y = 10;

    return a;
}        

int main () {

    struct MyObj a;

    a = foo();    // This DOES work
    struct b = a; // This does not work

    return 0;
}    

Capisco perché struct b = a;non dovrebbe funzionare: non è possibile sovraccaricare operator =il tipo di dati. Com'è che si a = foo();compila bene? Significa qualcosa di diverso da struct b = a;? Forse la domanda da porsi è: che cosa fa esattamente la returndichiarazione congiunta per =firmare?

[modifica]: Ok, mi è stato appena indicato che struct b = aè un errore di sintassi: è corretto e sono un idiota! Ma questo lo rende ancora più complicato! L'uso struct MyObj b = afunziona davvero! Cosa mi sto perdendo qui?

È possibile restituire una struttura da una funzione (o utilizzare l' =operatore) senza problemi. È una parte ben definita della lingua. L'unico problema struct b = aè che non hai fornito un tipo completo. struct MyObj b = afunzionerà bene. Puoi anche passare strutture a funzioni: una struttura è esattamente la stessa di qualsiasi tipo incorporato ai fini del passaggio dei parametri, dei valori di ritorno e dell'assegnazione.

Ecco un semplice programma dimostrativo che fa tutte e tre le cose: passa una struttura come parametro, restituisce una struttura da una funzione e usa le strutture nelle istruzioni di assegnazione:

#include <stdio.h>

struct a {
   int i;
};

struct a f(struct a x)
{
   struct a r = x;
   return r;
}

int main(void)
{
   struct a x = { 12 };
   struct a y = f(x);
   printf("%d\n", y.i);
   return 0;
}

Il prossimo esempio è praticamente lo stesso, ma utilizza il tipo incorporato a intscopo dimostrativo. I due programmi hanno lo stesso comportamento rispetto al valore pass-by per il passaggio dei parametri, l'assegnazione, ecc .:

#include <stdio.h>

int f(int x) 
{
  int r = x;
  return r;
}

int main(void)
{
  int x = 12;
  int y = f(x);
  printf("%d\n", y);
  return 0;
}

Quando si effettua una chiamata come ad esempio a = foo();, il compilatore potrebbe inserire nello stack l' indirizzo della struttura dei risultati e passarlo come puntatore "nascosto" alla foo()funzione. In effetti, potrebbe diventare qualcosa di simile:

void foo(MyObj *r) {
    struct MyObj a;
    // ...
    *r = a;
}

foo(&a);

Tuttavia, l'implementazione esatta di questo dipende dal compilatore e / o dalla piattaforma. Come osserva Carl Norum, se la struttura è abbastanza piccola, potrebbe addirittura essere completamente restituita in un registro.

La struct blinea non funziona perché è un errore di sintassi. Se lo espandi per includere il tipo funzionerà bene

struct MyObj b = a;  // Runs fine

Ciò che C sta facendo qui è essenzialmente uno memcpydalla struttura sorgente alla destinazione. Questo vale sia per l'assegnazione che per la restituzione dei structvalori (e in realtà ogni altro valore in C)

sì, è possibile che possiamo passare anche struttura e struttura di ritorno. Avevi ragione ma in realtà non hai passato il tipo di dati che dovrebbe essere simile a questa struttura MyObj b = a.

In realtà sono anche venuto a sapere quando stavo cercando di trovare una soluzione migliore per restituire più di un valore per la funzione senza usare il puntatore o la variabile globale.

Ora di seguito è riportato l'esempio per lo stesso, che calcola la deviazione dei voti di uno studente sulla media.

#include<stdio.h>
struct marks{
    int maths;
    int physics;
    int chem;
};

struct marks deviation(struct marks student1 , struct marks student2 );

int main(){

    struct marks student;
    student.maths= 87;
    student.chem = 67;
    student.physics=96;

    struct marks avg;
    avg.maths= 55;
    avg.chem = 45;
    avg.physics=34;
    //struct marks dev;
    struct marks dev= deviation(student, avg );
    printf("%d %d %d" ,dev.maths,dev.chem,dev.physics);

    return 0;
 }

struct marks deviation(struct marks student , struct marks student2 ){
    struct marks dev;

    dev.maths = student.maths-student2.maths;
    dev.chem = student.chem-student2.chem;
    dev.physics = student.physics-student2.physics; 

    return dev;
}

Per quanto posso ricordare, le prime versioni di C consentivano solo di restituire un valore che poteva rientrare in un registro del processore, il che significa che si poteva restituire solo un puntatore a una struttura. La stessa restrizione si applicava agli argomenti delle funzioni.

Le versioni più recenti consentono di passare oggetti dati più grandi come le strutture. Penso che questa funzione fosse già comune negli anni ottanta o all'inizio degli anni novanta.

Le matrici, tuttavia, possono ancora essere passate e restituite solo come puntatori.

È possibile assegnare strutture in C. a = b; è sintassi valida.

Hai semplicemente lasciato fuori parte del tipo - il tag struct - nella tua riga che non funziona.

Non vi è alcun problema nel restituire una struttura. Sarà passato per valore

Ma cosa succede se la struttura contiene un membro che ha un indirizzo di una variabile locale

struct emp {
    int id;
    char *name;
};

struct emp get() {
    char *name = "John";

    struct emp e1 = {100, name};

    return (e1);
}

int main() {

    struct emp e2 = get();

    printf("%s\n", e2.name);
}

Ora, qui e1.name contiene un indirizzo di memoria locale per la funzione get (). Una volta restituito get (), l'indirizzo locale per nome sarebbe stato liberato. Quindi, nel chiamante se proviamo ad accedere a quell'indirizzo, potrebbe causare un errore di segmentazione, poiché stiamo provando un indirizzo liberato. Non va bene..

Dove come e1.id sarà perfettamente valido in quanto il suo valore verrà copiato in e2.id

Quindi, dovremmo sempre cercare di evitare di restituire gli indirizzi di memoria locale di una funzione.

Tutto ciò che è stato rubato può essere restituito come e quando desiderato

struct emp {
    int id;
    char *name;
};

struct emp get() {
    char *name = "John";

    struct emp e1 = {100, name};

    return (e1);
}

int main() {

    struct emp e2 = get();

    printf("%s\n", e2.name);
}

funziona bene con le versioni più recenti di compilatori. Proprio come l'id, il contenuto del nome viene copiato nella variabile di struttura assegnata.

L'indirizzo struct var e2 viene spinto come arg per chiamare lo stack e i valori vengono assegnati lì. In effetti, get () restituisce l'indirizzo di e2 in eax reg. Funziona come una chiamata per riferimento.