Discussion :

[emprex]

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

Code :

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

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

[emprex]

Et sur ce code les valeurs sont-elles normales ?

Code :

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

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;
}

[diogene]

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

Code :

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

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 :

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

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);

[emprex]

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

[Melem]

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

En théorie : non.

[emprex]

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

[Jean-Marc.Bourguet]

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

[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 ?

[Melem]

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.

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

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

[Emmanuel Delahaye]

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 :

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

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 :

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
 
#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;
}

[Emmanuel Delahaye]

Et sur ce code les valeurs sont-elles normales ?

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

Code :

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
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 :

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

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.

[Emmanuel Delahaye]

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

[Emmanuel Delahaye]

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.

[Melem]

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

[Jean-Marc.Bourguet]

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