Gibt eine Struktur von einer Funktion in C zurück

Heute habe ich ein paar Freunden beigebracht, wie man C structs benutzt. Einer von ihnen fragte, ob Sie structeine Funktion von einer Funktion zurückgeben könnten , auf die ich antwortete: "Nein! Sie würden stattdessen Zeiger auf dynamisch malloced structs zurückgeben."

Ich kam von jemandem, der hauptsächlich C ++ macht, und hatte erwartet, dass er structs nicht nach Werten zurückgeben kann. In C ++ können Sie die operator =für Ihre Objekte überladen und es ist absolut sinnvoll, eine Funktion zu haben, um Ihr Objekt nach Wert zurückzugeben. In C haben Sie diese Option jedoch nicht und ich habe darüber nachgedacht, was der Compiler tatsächlich tut. Folgendes berücksichtigen:

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;
}    

Ich verstehe, warum struct b = a;sollte nicht funktionieren - Sie können nicht operator =für Ihren Datentyp überladen . Wie ist es, dass gut a = foo();kompiliert? Bedeutet es etwas anderes als struct b = a;? Vielleicht lautet die Frage: Was genau macht die returnAussage in Verbindung mit dem =Unterschreiben?

[bearbeiten]: Ok, ich wurde nur darauf hingewiesen, dass struct b = aes sich um einen Syntaxfehler handelt - das ist richtig und ich bin ein Idiot! Das macht es aber noch komplizierter! Verwenden struct MyObj b = afunktioniert in der Tat! Was fehlt mir hier?

Sie können =problemlos eine Struktur aus einer Funktion zurückgeben (oder den Operator verwenden). Es ist ein klar definierter Teil der Sprache. Das einzige Problem dabei struct b = aist, dass Sie keinen vollständigen Typ angegeben haben. struct MyObj b = awird gut funktionieren. Sie können Strukturen auch an Funktionen übergeben - eine Struktur ist genau die gleiche wie jeder integrierte Typ, um Parameter zu übergeben, Werte zurückzugeben und zuzuweisen.

Hier ist ein einfaches Demonstrationsprogramm, das alle drei Aufgaben ausführt: Übergibt eine Struktur als Parameter, gibt eine Struktur aus einer Funktion zurück und verwendet Strukturen in Zuweisungsanweisungen:

#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;
}

Das nächste Beispiel ist ziemlich genau das gleiche, verwendet jedoch den eingebauten intTyp zu Demonstrationszwecken. Die beiden Programme haben das gleiche Verhalten in Bezug auf die Wertübergabe für die Parameterübergabe, Zuweisung usw.:

#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;
}

Wenn Sie einen Aufruf wie z. B. a = foo();ausführen, überträgt der Compiler möglicherweise die Adresse der Ergebnisstruktur auf den Stapel und übergibt sie als "versteckten" Zeiger an die foo()Funktion. Tatsächlich könnte es so etwas wie:

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

foo(&a);

Die genaue Implementierung hängt jedoch vom Compiler und / oder der Plattform ab. Wie Carl Norum bemerkt, kann die Struktur, wenn sie klein genug ist, sogar vollständig in einem Register zurückgegeben werden.

Die struct bZeile funktioniert nicht, da es sich um einen Syntaxfehler handelt. Wenn Sie es um den Typ erweitern, funktioniert es einwandfrei

struct MyObj b = a;  // Runs fine

Was C hier tut, ist im Wesentlichen eine memcpyvon der Quellstruktur zum Ziel. Dies gilt sowohl für die Zuweisung als auch für die Rückgabe von structWerten (und wirklich für jeden anderen Wert in C).

Ja, es ist möglich, dass wir auch die Struktur übergeben und die Struktur zurückgeben können. Sie hatten Recht, aber Sie haben den Datentyp, der wie diese Struktur aussehen sollte, tatsächlich nicht übergeben. MyObj b = a.

Eigentlich habe ich auch erfahren, als ich versucht habe, eine bessere Lösung zu finden, um mehr als einen Wert für die Funktion ohne Verwendung eines Zeigers oder einer globalen Variablen zurückzugeben.

Im Folgenden finden Sie ein Beispiel dafür, in dem die Abweichung der Durchschnittsnoten eines Schülers berechnet wird.

#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;
}

Soweit ich mich erinnern kann, durften die ersten Versionen von C nur einen Wert zurückgeben, der in ein Prozessorregister passen könnte, was bedeutet, dass Sie nur einen Zeiger auf eine Struktur zurückgeben konnten. Die gleiche Einschränkung gilt für Funktionsargumente.

Neuere Versionen ermöglichen die Weitergabe größerer Datenobjekte wie Strukturen. Ich denke, diese Funktion war bereits in den achtziger oder frühen neunziger Jahren üblich.

Arrays können jedoch weiterhin nur als Zeiger übergeben und zurückgegeben werden.

Sie können Strukturen in C zuweisen. Dies a = b; ist eine gültige Syntax.

Sie haben einfach einen Teil des Typs - das struct-Tag - in Ihrer Zeile weggelassen, der nicht funktioniert.

Es ist kein Problem, eine Struktur zurückzugeben. Es wird als Wert übergeben

Was aber, wenn die Struktur ein Mitglied enthält, das die Adresse einer lokalen Variablen hat?

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);
}

Hier enthält e1.name eine Speicheradresse, die lokal für die Funktion get () ist. Sobald get () zurückkehrt, wäre die lokale Adresse für den Namen freigegeben worden. Wenn wir im Anrufer versuchen, auf diese Adresse zuzugreifen, kann dies zu einem Segmentierungsfehler führen, da wir versuchen, eine freigegebene Adresse zu verwenden. Das ist schlecht..

Wobei die e1.id vollkommen gültig ist, da ihr Wert nach e2.id kopiert wird

Wir sollten daher immer versuchen, die Rückgabe lokaler Speicheradressen einer Funktion zu vermeiden.

Alles, was malloced ist, kann nach Bedarf zurückgegeben werden

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);
}

funktioniert gut mit neueren Versionen von Compilern. Genau wie bei id wird der Inhalt des Namens in die zugewiesene Strukturvariable kopiert.

Die Adresse struct var e2 wird als arg an den Angerufenenstapel gesendet, und dort werden Werte zugewiesen. Tatsächlich gibt get () die Adresse von e2 in eax reg zurück. Dies funktioniert wie ein Aufruf per Referenz.