Taille d'un pointeur

Version imprimable

Bonjour,
Je veux écrire un programme qui affiche la taille d'un pointeur sur différents types.
voici le code
Code:

1 2 3 4 5 6 7 8 9 10 11 12 #include <stdio.h> int main(void) { int *p = NULL; char *c = NULL; double *z = NULL; printf("La taille d'un pointeur sur un entier est :%i\n", sizeof *p); printf("La taille d'un pointeur sur un caractere est :%i\n", sizeof *c); printf("La taille d'un pointeur sur un double est :%i\n", sizeof *z); return 0; }
Le resultat est 4 , 1 et 8
ma question est très simple , est-ce la bonne manière de procéder pour afficher la taille ?
Merci

Et sur ce code les valeurs sont-elles normales ?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <stdio.h>
int main(void)
{
	int leNb1 = 1;
	int *lePt1;
	lePt1 = &leNb1;
	printf("%d\n", leNb1); /* affiche 1 */
	printf("%d\n", lePt1); /* affiche 1245052 */
	printf("%d\n", lePt1 + 1); /* afficha 1245046 */
	printf("%d\n", *lePt1); /* affiche 1 */
	printf("%d\n", *lePt1 + 1); /* affiche 2 */
	printf("%d\n", *(lePt1+1)); /* affiche 1245120 */
	return 0;
}

Citation:
Envoyé par emprex
Bonjour,
Je veux écrire un programme qui affiche la taille d'un pointeur sur différents types.
voici le code
Code:

1 2 3 4 5 6 7 8 9 10 11 12 #include <stdio.h> int main(void) { int *p = NULL; char *c = NULL; double *z = NULL; printf("La taille d'un pointeur sur un entier est :%i\n", sizeof *p); printf("La taille d'un pointeur sur un caractere est :%i\n", sizeof *c); printf("La taille d'un pointeur sur un double est :%i\n", sizeof *z); return 0; }
Le resultat est 4 , 1 et 8
ma question est très simple , est-ce la bonne manière de procéder pour afficher la taille ?
Merci
Non. ceci te donne la taille des objets pointés. Pour avoir la taiile des pointeurs :
Code:

1 2 3 printf("La taille d'un pointeur sur un entier est :%i\n", sizeof p); printf("La taille d'un pointeur sur un caractere est :%i\n", sizeof c); printf("La taille d'un pointeur sur un double est :%i\n", sizeof z);

30/01/2008, 13h06
emprex

Du coup tous les pointeurs ont la même taille.
30/01/2008, 14h12
Melem

Citation:

Envoyé par emprex

Du coup tous les pointeurs ont la même taille.

En théorie : non.
30/01/2008, 14h16
emprex

Lorsque j'execute le code les valeurs sont 4 4 4
30/01/2008, 14h22
Jean-Marc.Bourguet

Citation:

Envoyé par emprex

Lorsque j'execute le code les valeurs sont 4 4 4

Ce qui n'est pas garanti. Les seules choses de garanties
- c'est qu'on peut stocker un pointeur vers n'importe quel type dans un void* ou dans un (signed/unsigned/) char* et le reconvertir dans le type initial sans perte de valeur;
- c'est qu'on peut avoir des pointeurs vers des types incomplets (donc en pratique tous les pointeurs vers des types pouvant etre incomplets -- struct, union -- ont la meme taille meme si on peut imaginer des cas tordus conformes ne respectant pas cette contrainte -- genre les pointeurs vers les struct dont le nom de tag commence par a ont une taille de 4, les autres une taille de 8).
02/02/2008, 12h38
iMaTh

Melem pourquoi les pointeur ne doivent pas tous faire la meme taille ?

sachant qu'il contient une adresse il devrai car les adresse font la meme taille non ?
02/02/2008, 13h07
Melem

Citation:

Envoyé par iMaTh

Melem pourquoi les pointeur ne doivent pas tous faire la meme taille ?

Pas ne doivent pas tous avoir la même taille, mais ne sont pas tous tenus d'avoir la même taille.

Citation:

Envoyé par iMaTh

sachant qu'il contient une adresse il devrait car les adresse font la meme taille non ?

Ben justement : non. La gestion de la mémoire est une tâche confiée à l'OS. Adresse ne signifie pas forcément adresse physique, ca signifie adresse. Le système effectue éventuellement une certaine redirection pour convertir les adresses en adresse physique ...
02/02/2008, 17h01
iMaTh

donc les pointeurs pointent sur les adresse virtuel qui sont par la suite redirigé vers les adresses physiques si j'ai bien compris.

vachement complex l'informatique.

Citation:

Envoyé par emprex

Je veux écrire un programme qui affiche la taille d'un pointeur sur différents types.
<...>est-ce la bonne manière de procéder pour afficher la taille ?

Non. La taille d'un pointeur p, c'est sizeof p. Ce que tu affiches là, c'est la talle de l'objet pointé.

D'autre part, sizeof retourne un size_t. alors soit tu utilises "%z" pour l'afficher si tu es sous C99, soit "%u" et un cast (unsigned) pour garantir la portabilité, ce qui donne :
Code:

1 2 3 4 5 6 La taille d'un pointeur sur un entier est :4 La taille d'un pointeur sur un caractere est :4 La taille d'un pointeur sur un double est :4 Press ENTER to continue.
sur mamachine, avec
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 #include <stdio.h> int main (void) { int *p; char *c; double *z; printf ("La taille d'un pointeur sur un entier est :%u\n", (unsigned) sizeof p); printf ("La taille d'un pointeur sur un caractere est :%u\n", (unsigned) sizeof c); printf ("La taille d'un pointeur sur un double est :%u\n", (unsigned) sizeof z); return 0; }

Citation:

Envoyé par emprex

Et sur ce code les valeurs sont-elles normales ?

Le code est incorrect. Je l'ai corrigé et commenté :

Code:

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
 
#include <stdio.h>
int main(void)
{
	int leNb1 = 1;
	int *lePt1;
	lePt1 = &leNb1;
 
/* affiche 1 : OK */
	printf("%d\n", leNb1);
 
/* affiche 1245052 : adresse : "%p" */
	printf("%p\n", (void *)lePt1);
 
/* affiche 1245046 : adresse : "%p" */
	printf("%p\n", (void *)(lePt1 + 1));
 
/* affiche 1 : OK*/
	printf("%d\n", *lePt1);
 
/* affiche 2 : OK  */
	printf("%d\n", *lePt1 + 1);
 
/* affiche 1245120 : Comportement indefini */
	printf("%d\n", *(lePt1+1));
 
	return 0;
}

Ca donne chez moi :

Code:

1
2
3
4
5
6
7
8
9
 
1
0022FF70
0022FF74
1
2
16384
 
Press ENTER to continue.

pose des questions si tu ne comprends pas.

02/02/2008, 20h30
Emmanuel Delahaye

Citation:

Envoyé par emprex

Du coup tous les pointeurs ont la même taille.

Sur ta machine, oui, c'est tout à fait possible. Mais il ne faut pas en tirer une généralité.
02/02/2008, 20h33
Emmanuel Delahaye

Citation:

Envoyé par iMaTh

donc les pointeurs pointent sur les adresse virtuel qui sont par la suite redirigé vers les adresses physiques si j'ai bien compris.

vachement complex l'informatique.

Oui, c'est le prix à payer pour que les processus soient indépendants et qu'en cas de débordement de mémoire, ils ne viennent pas empiéter sur les adresses du processus voisin.

C'est grâce à ça que les OS sont multi-processus.
03/02/2008, 07h20
Melem

Citation:

Envoyé par iMaTh

donc les pointeurs pointent sur les adresse virtuel qui sont par la suite redirigé vers les adresses physiques si j'ai bien compris.

vachement complex l'informatique.

Non les pointeurs contiennent des adresses. Si ton programme s'exécute sous un système d'exploitation ce dernier va interpréter ces adresses selon sa manière de gérer les adresses. Mais évidemment si tu développes un OS tu as accès à la mémoire physique, qu'il sera alors de ton devoir de gérer afin que les programmes utilisateurs n'ont en pas directement accès (sinon c'est l'anarchie, comme au temps du DOS).
03/02/2008, 10h59
Jean-Marc.Bourguet

Citation:

Envoyé par iMaTh

Melem pourquoi les pointeur ne doivent pas tous faire la meme taille ?

D'un point de vue architecture, le byte est la taille d'un caractere. Cette definition vient d'un temps ou on n'imaginait pas mettre tous les ideogrammes comme caracteres, encore moins une union de tous les charsets dans Unicode, donc le byte est relativement petit: 6, 7, 8 ou 9 bits sont des tailles qui ont ete utilisees. Il y a en des architectures où l'unité la plus petite ayant une adresse est le mot (de 16, 18, 24, 32, 36 ou 60 bits) plutôt que le byte. Celle-ci peuvent ne pas avoir d'instructions manipulant des donnes de taille plus petite que le mot (donc il n'y a pas de notion de byte provenant de l'architecture, le systeme peut en avoir une et pour les manipuler, il faut agir au niveau du bit), ou en voir mais ne favoriser aucune taille (a nouveau, ce qu'est un byte alors provient de l'exterieur).

De nos jours, les architectures adressables par byte sont archi-dominantes sur le domaine des machines ayant une vocation générale, mais ce n'était pas le cas dans les années 70 -- au moment où le C évoluait -- et, même si on savait qu'elles avaient vraisemblablement peu d'avenir, les machines adressables par mot étaient loin d'être anecdotiques durant les années 80 -- au moment où la normalisation du C prenait place.

De son origine, le C suppose une machine adressable par byte: il faut pouvoir faire des pointeurs sur chacun des bytes de la memoire. Il y a deux techniques possibles pour y arriver sur une machine adressable par mot.

1/ Etendre la taille de ce que le C considère un byte pour en faire la même que celle d'un mot -- c'est la technique utilisée de nos jours sur les DSP qui sont les seules machines adressables par mot de conception récente. On se retrouve avec le char (ou le byte) du C qui ne fait pas la meme taille que le byte du systeme, mais ce n'est pas grave: les manipulations de caracteres ne sont pas la raison pour laquelle on utilise des DSP.

2/ Faire en sorte qu'un pointeur vers char contienne non seulement l'adresse du mot, mais aussi une indication du byte dans le mot -- et pour ça il faut des pointeurs vers char qui sont plus grand que les adresses. Un char* ou un void( contient un pointeur vers un mot (a priori, un unsigned*), plus une indication du caractere designe (un petit indice).