Passer la structure pour fonctionner

Je suis un nouveau programmeur en C et je voulais savoir comment transmettre une struct à une fonction. Je reçois une erreur et je n’arrive 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 actuelle:

 void addStudent(person) { return; } 

compiler errors:

ligne 21: avertissement: déclaration de tag douteuse: struct student
ligne 223: l’argument # 1 est incompatible avec le prototype:

L’implémentation de la fonction de ligne doit ê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 lorsque le prototype l’utilise.

Voici comment passer la struct par référence. Cela signifie que votre fonction peut accéder à la struct dehors de la fonction et modifier ses valeurs. Vous faites cela en passant un pointeur sur la structure à la fonction.

 #include  /* 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 la struct par valeur afin que votre fonction reçoive une copie de la struct et ne peut pas accéder à la structure extérieure pour la modifier. Par extérieur je veux dire en dehors de la fonction.

 #include  /* 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; } 

Lors de la transmission d’une structure à une autre fonction, il serait généralement préférable de faire comme Donnell suggéré ci-dessus et de la passer par référence à la place.

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

Voici un exemple de la manière la plus simple de procéder:

 #include  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 de l’ student , puis nous passons 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 à l’un de ses membres (équivalent fonctionnellement à: (*s).age ).

Toutes les modifications que nous addStudent() à la fonction addStudent() seront répercutées lorsque nous retournerons à main() , car le pointeur nous a donné une référence à l’endroit où la mémoire de l’ student est stockée dans la mémoire. Ceci est illustré par le printf() , qui affichera “10” dans cet exemple.

Si vous n’aviez pas passé de référence, vous travailleriez en fait avec une copie de la structure que vous avez transmise à la fonction, ce qui signifie que toutes les modifications ne seraient pas reflétées lorsque vous revenez à main – à moins d’implémenter la structure de retour à la main ou quelque chose le long de ces lignes!

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

Vous devez spécifier un type sur la personne:

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

En outre, vous pouvez taper votre struct pour éviter d’avoir à taper struct chaque fois que vous l’utilisez:

 typedef struct student{ ... } student_t; void addStudent(student_t person) { ... } 

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 ne devez pas nécessairement le spécifier dans l’implémentation de la fonction comme dans:

 void addStudent(struct student person) { return; }