web-dev-qa-db-fra.com

Passer la structure à la fonction

Je suis un nouveau programmeur C et je voulais savoir comment je pourrais passer un struct à une fonction. Je reçois une erreur et je ne peux pas trouver la syntaxe correcte pour le faire. Voici le code pour cela ....

Struct:

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

struct student person;

Appel:

addStudent(person);

Prototype:

void addStudent(struct student);

et la fonction réelle:

void addStudent(person)
{
    return;
}

Erreurs du compilateur:

ligne 21: avertissement: déclaration de balise douteuse: struct student
ligne 223: l'argument n ° 1 est incompatible avec prototype:

cfunctionstruct
47
Daniel Del Core

L'implémentation de la fonction de ligne devrait être:

void addStudent(struct student person) {

}

person n'est pas un type mais une variable, vous ne pouvez pas l'utiliser comme type de paramètre de fonction.

Assurez-vous également que votre structure est définie avant le prototype de la fonction addStudent car le prototype l’utilise.

40
MByD

Voici comment passer le struct par référence. Cela signifie que votre fonction peut accéder à la struct en dehors de la fonction et modifier ses valeurs. Pour ce faire, vous passez un pointeur sur la structure de la fonction.

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

Voici comment vous passez struct par valeur afin que votre fonction reçoive une copie du struct et ne puisse pas accéder à la structure extérieure pour la modifier. Par extérieur, je veux dire en dehors de la fonction.

#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

Lorsque vous passez une structure à une autre fonction, il serait généralement préférable de faire ce que Donnell a suggéré ci-dessus et de la transmettre par référence.

Une très bonne raison à cela est que cela facilite les choses si vous souhaitez apporter des modifications qui seront reflétées lorsque vous revenez à la fonction qui en a créé l'instance.

Voici un exemple de la façon la plus simple de procéder:

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

Dans cet exemple, l'argument de la fonction addStudent() est un pointeur sur une instance d'un student struct - student *s. Dans main(), nous créons une instance de la structure student, puis nous lui transmettons une référence à notre fonction addStudent() à l'aide de l'opérateur de référence (& ).

Dans la fonction addStudent(), nous pouvons utiliser l'opérateur de flèche (->) Pour déréférencer le pointeur et accéder à n'importe lequel de ses membres (fonctionnellement équivalent à: (*s).age).

Toutes les modifications que nous apportons à la fonction addStudent() seront répercutées lorsque nous reviendrons à main(), car le pointeur nous aurait donné une référence à l'endroit où, dans la mémoire, l'instance du studentstr est en cours de stockage. Ceci est illustré par la printf(), qui affichera "10" dans cet exemple.

Si vous n'aviez pas transmis de référence, vous utiliseriez une copie de la structure que vous avez transmise à la fonction, ce qui signifie que les modifications ne seraient pas répercutées lorsque vous revenez à main - à moins que vous n'ayez implémenté un moyen de. repasser la nouvelle version de la structure en main ou quelque chose du genre!

Bien que les indicateurs puissent sembler déconcertants au début, une fois que vous avez compris leur fonctionnement et pourquoi ils sont si pratiques, ils deviennent une seconde nature et vous vous demandez comment vous avez pu vous en passer!

8
tom1990

Vous devez spécifier un type sur personne:

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

De plus, vous pouvez taper votre structure pour éviter de devoir taper structure à chaque fois que vous l'utilisez:

typedef struct student{
...
} student_t;

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

Au lieu de:

void addStudent(person)
{
    return;
}

essaye ça:

void addStudent(student person)
{
    return;
}

Puisque vous avez déjà déclaré une structure appelée 'étudiant', vous n'avez pas nécessairement à le spécifier dans l'implémentation de la fonction comme dans:

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