taille d'un pointeur

bonjour,

Quelque chose me chiffonne en C/C++:
un prof expérimenté d'informatique nous explique que la taille d'un pointeur est unique et cela quelque soit son type(int*,float*,long*,char*,void*,...)
Cette taille correspond à l'architecture du pc:si c'est un processeur 64 bits,on pourra adresser à tous les pointeurs une taille de 2^64 octets dans la RAM.
si c'est un processeur 32 bits,on pourra adresser à tous les pointeurs une taille de 2^32 octets dans la RAM

Pourtant,quand on effectue des opérations sur les pointeurs,les sauts ne sont pas les même selon le type de pointeur:
Par exemple,un char prend 8 octets et s'il s'agit de char *p,le passage de p à p+1 fera un saut de 8 octets
Un short prend 16 octets et s'il s'agit de short *p,le passage de p à p+1 fera un saut de 16 octets
etc...

Ma question:
Comment concilier et expliquer cette unicité de taille de pointeur alors que leurs sauts varient selon le type de pointeur?

merci de votre aide

Bonjour,

Un pointeur est une adresse mémoire, un simple nombre. Supposons que nous ayons 20 cases mémoires. Nous avons donc le pointeur pointant sur 0, sur 1, sur 2.. jusque 20. Pour représenter les nombres de 1 à 20, on a donc toujours un type de la même taille (un int, qui va en général faire 8 octets sur une architecture 64 bits si je ne dis pas de bêtises). Le pointeur fait donc la même taille.

Ajoutons à l'équation deux types, un type A, prenant 2 cases mémoires, et un type B, en prenant 4.
Supposons que nous ayons un type A à l'adresse 1, stocké dans un pointeur qu'on appellera ptr_a. 1 et 2 sont donc occupés par A. Si on ajoute sizeof(A) (ici 2) à ptr_a, on se retrouve avec un pointeur pointant sur la case mémoire numéro 3.
Si on fait très exactement la même chose avec B, on se retrouve à la case numéro 5.

Est ce plus clair ?

Bonjour

Citation:

---

Envoyé par tabkelm

Pourtant,quand on effectue des opérations sur les pointeurs,les sauts ne sont pas les même selon le type de pointeur:
Par exemple,un char prend 8 octets et s'il s'agit de char *p,le passage de p à p+1 fera un saut de 8 octets
Un short prend 16 octets et s'il s'agit de short *p,le passage de p à p+1 fera un saut de 16 octets
etc...

Ma question:
Comment concilier et expliquer cette unicité de taille de pointeur alors que leurs sauts varient selon le type de pointeur?

---

Tu confonds "taille du pointeur" et "taille de l'élément qui est pointé" ;)

Un pointeur c'est juste une variable qui contient une adresse. Et une adresse, dans un ordi, a toujours la même taille. Jusque là, tu as tout à fait raison.

Maintenant, un pointeur n'a de sens que si à terme on utilise ce vers quoi il pointe et ça aussi il faut le connaitre. Donc (par exemple) que se passe-t-il avec un long. Un long est une variable qui s'étend sur 4 octets. Si le long se trouve à l'adresse 0x1000, alors il s'étendra sur 0x1000, 0x1001, 0x1002 et 0x1003. Mais le pointeur qui contient l'adresse de ce long ne contient que 0x1000. Toutefois c'est parce que tu as déclaré ce pointeur comme pointeur sur long (long *pt) que le compilateur sait que le contenu "*pt" fait 4 octets et saura alors comment traiter (par exemple) l'instruction printf("%ld", *pt). C'est pour ça qu'il faut toujours faire attention aux types donnés à nos pointeurs (sinon ça aurait été beaucoup plus simple de créer un type unique "ptr" mais voilà, le C a aussi besoin de connaitre la taille du pointé). Et c'est aussi pour ça qu'il est très mauvais de cacher un pointeur derrière un typedef comme je le vois souvent faire par beaucoup de débutants qui ont peur de cette étoile (ou comme je le vois souvent conseillé par certains profs de C qui, eux non plus, ne semblent pas vraiment maitriser cette notion et qui préfèrent s'en débarasser de cette façon). Un programmeur de C a besoin de connaitre ce sur quoi pointent ses pointeurs s'il veut pouvoir les manipuler correctement.

Ainsi, en écrivant long *pt, tu déclares 2 choses

1. pt est une variable de type "adresse"
2. *pt est une valeur de type "long"

Ensuite, puisque tout est connu, c'est uniquement pour simplifier la vie du codeur que les concepteurs du C ont défini que l'addition d'un pointeur correspondrait à un décalage de la taille de ce qu'il pointe. Parce que dans 99,8% des cas, quand on écrit "pt+1" c'est qu'on a l'intention de récupérer l'élément pointé qui vient après (en considérant que ce qu'il y a après est de même nature, ce qui est le cas de tableaux).
Et dans les 0.2% restants, si on veut traiter les cases 0x1000, 0x1001, 0x1002 et 0x1003 de façon individuelle, on peut alors utiliser le cast => ((char*)pt) + 1.

Cela c'est ce qu'on appelle "l'arithmétique des pointeurs" (<- lien developpez.com)

Tu n'as pas à te prendre la tête, c'est le compilateur qui ajuste tout seul le décalage réel à faire :zoubi:
Seul les pointeurs génériques void* génèrent des erreurs. Et donc tu n'as qu'à considérer que la mémoire en C est un immense tableau contiguë :

• un pointeur + X -> on avance de X éléments de même type
• un pointeur - X -> on recule de X éléments de même type
• un pointeur1 - un pointeur2 (de même type) -> on prend le nombre d'éléments entre + 1.

Citation:

---

Envoyé par foetus

Tu n'as pas à te prendre la tête, c'est le compilateur qui ajuste tout seul le décalage réel à faire :zoubi:

---

Oui, on peut aussi l'expliquer comme ça :mrgreen:

l'adresse d'un pointeur est en hexadécimal.
Selon que le processeur du pc soit en 64 bits ou en 32 bits,comment diffère la taille de cet hexadécimal?

Le pointeur n'est pas en hexadécimal, on l'exprime couramment en hexadécimal.
Et pour l'exprimer en hexadécimal, le nombre de "digits" sera (sizeof(void*)*CHAR_BIT+3)/4 (nombre de bits /4, arrondi au supérieur).
À cela, on peut rajouter un éventuel préfixe, un caractère nul de fin de chaîne, etc.

...et comment varie la taille de cette adresse en fonction de l'architecture du processeur(16,32 ou 64 bits)?

Citation:

---

Envoyé par tabkelm

l'adresse d'un pointeur est en hexadécimal.

---

Il faut revoir tes cours de mathématiques mon cher :mrgreen: :mrgreen:

Le système décimal est en base 10. Donc 10 chiffres : 0, 1, 2, 3, 4, 5, 6, 7, 8, 9. Et donc 781 vaut à 1*10^0 + 8*10^1 + 7*10^2

Le système hexadécimal est en base 16 et est préfixé par "0x". Donc 16 chiffres : 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F. Et donc 0x781 vaut en décimal 1*16^0 + 8*16^1 + 7*16^2

Il y a d'autres systèmes : binaire (1 et 0), sexagésimal (base 60, pour les secondes/ minutes/ heures) et octal (8 chiffres: 0, 1, 2, 3, 4, 5, 6, 7 et est préfixé par "0")

Et donc 174 = 0xAE = 0256 = 10101110 :mrgreen:

Le système hexadécimal est pratique parce que 1 chiffre correspond à 4 bits (nibble en anglais, lien wiki en français) soit la moitié d'un octet 8 bits :mrgreen:

Citation:

---

Envoyé par tabkelm

...et comment varie la taille de cette adresse en fonction de l'architecture du processeur(16,32 ou 64 bits)?

---

La taille d'un pointeur ne varie pas :mrgreen: un processeur de X bits ne peut adresser que 2^X bits de mémoire.

Sur une PC sous Windows 64 bits, on peut programmer pour Win32 (pointeurs de 32 bits, soit 4 octets, donc 8 chiffres hexadécimaux) ou Win64 (pointeurs de 64 bits, soit 8 octets, donc 16 chiffres hexadécimaux) selon les flags qu'on passe au compilateur et à l'éditeur de liens.

Les processus des deux types cohabitent, mais un seul processus ne peut pas avoir des DLLs de deux bitness différentes.

merci pour cette dernière réponse qui seule résout mon incompréhension

Et avant que tu ne poses la question :mrgreen: suite à la réponse de @Médinoc, les processeurs x86 64 bits sont compatibles 32 bits.

Mais en mode 32 bits au niveau de la mémoire, cela ne change rien :mrgreen: ... sauf pour ton programme qui aura accès qu'à 2^32 bits de mémoire (taille des pointeurs 4 octets au lieu de 8).
C'est juste que la taille des instructions processeur (ADD, MOV, ...) ne font que 32 bits de large (étonnant non :mouarf:)
Et donc, ton processeur 64 bits, lui qui travaille avec des instructions processeur de 64 bits de large, va devoir couper en 2 les instructions en mode 32 bits. C'est pour cette raison que c'est un chouïa + lent :zoubi:

Citation:

---

Envoyé par tabkelm

Citation:

---

Envoyé par tabkelm

Pourtant,quand on effectue des opérations sur les pointeurs,les sauts ne sont pas les même selon le type de pointeur:
Par exemple,un char prend 8 octets et s'il s'agit de char *p,le passage de p à p+1 fera un saut de 8 octets
Un short prend 16 octets et s'il s'agit de short *p,le passage de p à p+1 fera un saut de 16 octets
etc...

Citation:

---

Envoyé par Médinoc

Sur une PC sous Windows 64 bits, on peut programmer pour Win32 (pointeurs de 32 bits, soit 4 octets, donc 8 chiffres hexadécimaux) ou Win64 (pointeurs de 64 bits, soit 8 octets, donc 16 chiffres hexadécimaux) selon les flags qu'on passe au compilateur et à l'éditeur de liens.

Les processus des deux types cohabitent, mais un seul processus ne peut pas avoir des DLLs de deux bitness différentes.

---

---

merci pour cette dernière réponse qui seule résout mon incompréhension

---

Super, merci pour les autres qui ont répondu :moinsser:. Personnellement je ne vois pas trop le rapport entre sa réponse et les opérations sur les pointeurs donc je ne vois pas le rapport entre ton incompréhension et ta question initiale :weird:

Citation:

---

Envoyé par tabkelm

...et comment varie la taille de cette adresse en fonction de l'architecture du processeur(16,32 ou 64 bits)?

---

Cela ne dépend pas forcément des processeurs 8/16/32 bits.
En gros on peut avoir un proc 8 bits et pouvoir adresser 16 bits de données (donc un pointeur fera 16 bits ici).
Et rien n’empêche d'avoir un processeur 64 bits qui peut adresser plus.

Pour les proc 16 bits c'est plus complexe, la plupart peuvent souvent adresser plus (le x86 pouvait adresser jusqu'a 1Mo, mais si on prend un 68k, il peut facilement adresser 32 bits ).

Citation:

---

Envoyé par tabkelm

Par exemple,un char prend 8 octets [...]
Un short prend 16 octets

---

[Détail] C'est possible mais en général ce sera plutôt 8 bits pour les chars et 16 bits pour les shorts.