Struct et pointeurs

"À vrai dire je m'y perd un peu avec les pointeurs"

L'auteur de ce sujet a trouvé une solution à son problème.
Auteur du sujet

Bonsoir !

Je continu le tutoriel sur le C. Je suis actuellement rendu aux pointeurs et structures. À vrai dire je m'y perd un peu avec les pointeurs, entre le * et le &, je m'embrouille totalement. Bref voici un code que je test actuellement :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
#include <stdio.h>

typedef struct
{
  int age;
  int weight;
  int size;
  char gender;
  double imc;
} Personne;

void imc(Personne * personne)
{
  int weight, size;

    weight = personne -> weight;
    size = personne -> size;

    personne -> imc = (size * size) / weight;
}

int main()
{
    Personne arthur;

    arthur.age = 16;
    arthur.weight = 53;
    arthur.size = 171;

    imc(arthur);

    printf("%d ans, IMC = %f\n", arthur.age, arthur.imc);

    return 0;
}

Seulement, celui-ci ne compile pas :

1
2
3
4
5
6
struct.c: In function ‘main’:
struct.c:30:5: error: incompatible type for argument 1 of ‘imc’
     imc(arthur);
     ^
struct.c:12:6: note: expected ‘struct Personne *’ but argument is of type ‘Personne’
 void imc(Personne * personne)

Ce que je ne comprend pas, c'est pourquoi il n'accepte pas arthur comme argument alors qu'il est bien du type Personne.

Merci de votre aide!

Mon projet : OpenPlane, un utilitaire en Java pour les pilotes, les vrais !

+0 -0

Cette réponse a aidé l'auteur du sujet

& te permet d'obtenir l'adresse d'une variable, c'est à dire un pointeur vers cette variable. Si toto est une variable de type int, &toto sera un int*. Ta fonction imc n'attend pas une Personne en argument, mais un Personne*, &arthur en est un.

* réalise l'opération inverse, c'est à dire déréférencer un pointeur. Si tata est un int*, *tata sera un int, correspondant à la valeur pointée.

Je vois que tu utilises la notation -> dans ton code, mais peut-être ne comprends-tu pas bien ce que tu fais.

personne->weight est équivalent à (*personne).weight. C'est à dire que tu accèdes au membre weight de la valeur référencée par personne.

Auteur du sujet

Merci pour cette explication claire.
Seulement quand tu dis "& te permet d'obtenir l'adresse d'une variable, c'est à dire un pointeur vers cette variable.", veux-tu dire que chaque variable a automatiquement un pointeur à sa création ? Car si j'ai bien compris, un pointeur est une "variable" de la valeur de la variable qu'il pointe, et qui contient l'adresse de celle-ci, non?

Édité par Wizix

Mon projet : OpenPlane, un utilitaire en Java pour les pilotes, les vrais !

+0 -0

Seulement quand tu dis "& te permet d'obtenir l'adresse d'une variable, c'est à dire un pointeur vers cette variable.", veux-tu dire que chaque variable a automatiquement un pointeur à sa création ?

Wizix

Une variable a toujours une adresse, tu peux avoir la valeur de l’adresse avec l’opérateur &. Ensuite tu en fait ce que tu veux

J’ai l’impression que tu complique les choses pour rien. Tiens, peut être que tu comprendra mieux en transposant la situation :

Une variable prend toujours une certaine place en mémoire, tu peux avoir la valeur de la taille avec l’opérateur sizeof. Ensuite tu en fait ce que tu veux.

Édité par simbilou

La répétition est la base de l’enseignement. — ☮ ♡

+0 -0
Vous devez être connecté pour pouvoir poster un message.
Connexion

Pas encore inscrit ?

Créez un compte en une minute pour profiter pleinement de toutes les fonctionnalités de Zeste de Savoir. Ici, tout est gratuit et sans publicité.
Créer un compte