it-swarm.com.de

Struktur an Funktion übergeben

Ich bin ein neuer C-Programmierer und wollte wissen, wie ich ein struct an eine Funktion weitergeben kann. Ich erhalte eine Fehlermeldung und kann die richtige Syntax dafür nicht finden. Hier ist der Code dafür ....

Struktur:

struct student{
    char firstname[30];
    char surname[30];
};

struct student person;

Anruf:

addStudent(person);

Prototyp:

void addStudent(struct student);

und die eigentliche Funktion:

void addStudent(person)
{
    return;
}

Compiler-Fehler:

zeile 21: warnung: zweifelhaft tag deklaration: struct student
Zeile 223: Argument # 1 ist nicht kompatibel mit Prototyp:

47
Daniel Del Core

Die Zeilenfunktionsimplementierung sollte sein:

void addStudent(struct student person) {

}

person ist kein Typ, sondern eine Variable. Sie können sie nicht als Typ eines Funktionsparameters verwenden.

Stellen Sie außerdem sicher, dass Ihre Struktur vor dem Prototyp der Funktion addStudent definiert ist, wie er vom Prototyp verwendet wird.

40
MByD

So übergeben Sie den struct als Referenz. Dies bedeutet, dass Ihre Funktion auf das struct außerhalb der Funktion zugreifen und dessen Werte ändern kann. Dazu übergeben Sie der Funktion einen Zeiger auf die Struktur.

#include <stdio.h>
/* card structure definition */
struct card
{
    int face; // define pointer face
}; // end structure card

typedef struct card Card ;

/* prototype */
void passByReference(Card *c) ;

int main(void)
{
    Card c ;
    c.face = 1 ;
    Card *cptr = &c ; // pointer to Card c

    printf("The value of c before function passing = %d\n", c.face);
    printf("The value of cptr before function = %d\n",cptr->face);

    passByReference(cptr);

    printf("The value of c after function passing = %d\n", c.face);

    return 0 ; // successfully ran program
}

void passByReference(Card *c)
{
    c->face = 4;
}

Auf diese Weise übergeben Sie den Wert struct so, dass Ihre Funktion eine Kopie des Werts struct erhält und nicht auf die äußere Struktur zugreifen kann, um sie zu ändern. Äußerlich meine ich außerhalb der Funktion.

#include <stdio.h>


/* global card structure definition */
struct card
{
    int face ; // define pointer face
};// end structure card

typedef struct card Card ;

/* function prototypes */
void passByValue(Card c);

int main(void)
{
    Card c ;
    c.face = 1;

    printf("c.face before passByValue() = %d\n", c.face);

    passByValue(c);

    printf("c.face after passByValue() = %d\n",c.face);
    printf("As you can see the value of c did not change\n");
    printf("\nand the Card c inside the function has been destroyed"
        "\n(no longer in memory)");
}


void passByValue(Card c)
{
    c.face = 5;
}
90
Donnell

Wenn Sie eine Struktur an eine andere Funktion übergeben, ist es normalerweise besser, die oben von Donnell vorgeschlagene Vorgehensweise zu befolgen und sie stattdessen als Referenz zu übergeben.

Ein sehr guter Grund dafür ist, dass es die Dinge einfacher macht, wenn Sie Änderungen vornehmen möchten, die wiedergegeben werden, wenn Sie zu der Funktion zurückkehren, die die Instanz davon erstellt hat.

Hier ist ein Beispiel für den einfachsten Weg:

#include <stdio.h>

typedef struct student {
    int age;
} student;

void addStudent(student *s) {
    /* Here we can use the arrow operator (->) to dereference 
       the pointer and access any of it's members: */
    s->age = 10;
}

int main(void) {

    student aStudent = {0};     /* create an instance of the student struct */
    addStudent(&aStudent);      /* pass a pointer to the instance */

    printf("%d", aStudent.age);

    return 0;
}

In diesem Beispiel ist das Argument für die Funktion addStudent() ein Zeiger auf eine Instanz von student struct - student *s. In main() erstellen wir eine Instanz der student -Struktur und übergeben dann unter Verwendung des Referenzoperators (&) Einen Verweis darauf an unsere addStudent() -Funktion.

In der Funktion addStudent() können wir den Pfeiloperator (->) Verwenden, um den Zeiger zu dereferenzieren und auf einen seiner Member zuzugreifen (funktional äquivalent zu: (*s).age).

Alle Änderungen, die wir in der Funktion addStudent() vornehmen, werden wiedergegeben, wenn wir zu main() zurückkehren, da der Zeiger uns einen Verweis darauf gab, wo im Speicher die Instanz von student ist. struct wird gespeichert. Dies wird durch printf() veranschaulicht, das in diesem Beispiel "10" ausgibt.

Wenn Sie keine Referenz übergeben hätten, würden Sie tatsächlich mit einer Kopie der Struktur arbeiten, die Sie an die Funktion übergeben haben. Das bedeutet, dass Änderungen nicht berücksichtigt werden, wenn Sie zu main zurückkehren - es sei denn, Sie haben eine Methode von implementiert die neue Version der Struktur an main zurückgeben oder so ähnlich!

Obwohl Zeiger auf den ersten Blick abstoßend zu sein scheinen, werden sie zu einer Selbstverständlichkeit, sobald Sie wissen, wie sie funktionieren und warum sie so praktisch sind, und Sie fragen sich, wie Sie jemals ohne sie umgegangen sind!

8
tom1990

Sie müssen einen Typ für die Person angeben:

void addStudent(struct student person) {
...
}

Sie können auch Ihre Struktur eingeben, um zu vermeiden, dass Sie bei jeder Verwendung eine Struktur eingeben müssen:

typedef struct student{
...
} student_t;

void addStudent(student_t person) {
...
}
4
drew212

Anstatt:

void addStudent(person)
{
    return;
}

versuche dies:

void addStudent(student person)
{
    return;
}

Da Sie bereits eine Struktur namens 'student' deklariert haben, müssen Sie dies in der Funktionsimplementierung nicht unbedingt wie folgt angeben:

void addStudent(struct student person)
{
    return;
}
0
afmf