Discussion :

[hbx360]

Bonjour, pourriez-vous m'expliquer, quand on a un code comme celui-ci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
char caractere = 'a';
char*ptr = NULL;
ptr = &caractere;

comme ptr est un pointeur de char logiquement ptr vaut 1 octet puisque c'est un char donc si je met l'adresse de caractere dans ptr logiquement le compilateur devrait m'envoyer un message d'erreur si l'adresse de caractère est supérieur à 255.

Et pourtant ce n'est pas ce qui se passe, le programme s'exécute normalement il n'y a pas de message d'erreur et pourtant si je fait : printf("adresse ptr = %d", ptr); l'adresse de caractère est : 2271919.
La valeur de l'adresse est largement supérieur à 255 donc comment se fait-il que le compilateur n'affiche pas de message d'erreur.
Pourriez-vous m'expliquer ?

Merci par avance.

[picodev]

Bonjour,

un pointeur aura une taille de 32 ou 64 bits suivant ta plateforme. Un pointeur sur un char indique que ce qui est pointé aura une taille de 1 octet par le pointeur en lui-même.

[sambia39]

Bonjour
En complément de ce qui a été dit, un pointeur (variable pointeur), est une variable qui contient l'adresse d'une autre variable; elle permet également de faire des calculs sur des adresse.

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
    char *ptr = NULL;   /* pointeur sur char */
    char c_str = 'a';   /* variable de type char */
    char c_Str = 'c';
 
    /*
        variable ptr contient
        l'adresse de c_str
        & pointe sur c_str
    */
    ptr = &c_str;  /* Acquisition de l'adresse */
    *ptr = 'b';      /* c_str vaut 'b' */
    printf("%c\n", c_str );
 
    ptr = &c_Str;   /*  ptr pointe sur c_Str */
    *ptr = 'A';
    printf("%c\n", *ptr );

à bientôt

[hbx360]

Merci pour vos réponses.
picodev merci à toi pour ta réponse précise et qui est aller droit au but ; tu as répondu pile à ce que je voulais savoir c'est parfaitement claire pour moi maintenant.

[hbx360]

En faite j'aurai une autre question quand tu dis :

un pointeur aura une taille de 32 ou 64 bits suivant ta plateforme

est-ce que sa veut dire que quel que soit le pointeur il sera de type void* ?

[Invité]

Plutôt, un pointeur contient une adresse. Cette adresse est dépendante de la plateforme, donc de l'os, sur lequel tu te trouves.

Sur un windowd ou un linux 32bits, les adresses seront codé sur 32bits.
Si la plateforme est un 64bits, les adresses seront codé sur 64bits.

Un pointeur n'est pas un type en soi, c'est uniquement une adresse. Le type donné pour le pointeur permet de spécifié ce qui se trouve à cette adresse mémoire.
Ainsi, le code suivant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

char *maVariable;

Signifie "à l'adresse de maVariable se trouvera une donnée de type char".

[picodev]

Taille de pointeur et type de pointeur sont deux notions différentes.

La taille du pointeur est principalement déterminé par la plateforme sur laquelle va s'exécuter ton programme. Par exemple si tu compiles pour faire tourner ton programme sur un linux 64bit ton pointeur fera 64bit, pour un windows 32bit ton pointeur fera 32bit (en simplifiant à l'extrême). La taille du pointeur ne va pas être déterminé par le langage que tu utiliseras.

En C les pointeurs sont typés. Cela signifie qu'en plus de savoir qu'une variable est un pointeur, c'est-à-dire qu'elle contient une adresse, tu connais le type des données que tu vas trouver à cette adresse, du moins comment les interpréter quand tu vas déréférencer le pointeur. Il est important de connaitre le type de ce qui est pointé dans de nombreux cas. Par exemple si il y a plusieurs données stockées consécutivement, ajouter 1 au pointeur ne va donner l'adresse mémoire suivante, mais l'adresse mémoire plus la taille du type représenté : on accédera donc à la donnée suivante. C'est ce qu'on appelle l'arithmétique des pointeurs.

Il y a aussi des cas de figure où on n'a pas besoin de connaître le type de la donnée pointée. C'est par exemple le cas de malloc qui renvoit un void *. malloc ne s'occupe que de réserver la place mémoire, charge à celui qui l'appelle de correctement le typer. Il y a aussi des cas où on ne sait pas forcément à l'avance quel sera le type des données pointées, dans ce cas on utilisera aussi un void *, comme pour la plupart des données utilisateurs fournies aux callbacks.

L'opérateur & appliqué à une variable (pour simplifier) te donnera un pointeur de type «pointeur sur type de la variable» : appliquer & sur une variable de type int, par exemple, te donnera un pointeur sur un entier, i.e. un int *.