Struct et pointeurs

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

Le problème exposé dans ce sujet a été résolu.

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!

& 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.

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?

+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.

+0 -0
Connectez-vous pour pouvoir poster un message.
Connexion

Pas encore membre ?

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