Discussion :

[xeron33]

Bonour à tous,
Ce petit programme dans le but de créer un pointeur de type char, de lui affecter la valeur A et de l'incrémenter en affichant son adresse.
Le problème est qu'il m'affiche toujours la même adresse...

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
 
#include <stdio.h>
#include <stdlib.h>
main()
{
  char *ptr1;
  ptr1=(char *) malloc (10 * sizeof (char));
  int i;
  for (i=0;i<10;i++)
  {
    *ptr1='A';
    printf("%x",&ptr1);
    printf(" ");
    printf("%s",ptr1);
    ptr1++;
 
  }
}

Qu'en pensez vous ? Est ce normal ?

[moldavi]

Bonjour.

L'adresse mémoire de ptr1 est unique. Lorsque l'opération ptr1++ est effectuée, ce n'est pas l'adresse mémoire de ptr1 qui est incrémentée, mais le contenu de la valeur de ptr1.

Lorsque l'on écrit "int i = 0", l'adresse de i est unique (&i). Si on effectue "i++", alors i vaut 1, mais son adresse mémoire n'a pas changé. C'est pareil pour un pointeur. C'est l'adresse pointée, donc la valeur du pointeur qui est incrémentée, pas son adresse mémoire.

Aussi pour afficher un caractère, c'est %c et non %s qui attend un \0 à la fin.

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
#include <stdio.h>
#include <stdlib.h>
 
void main(){
 
  char *ptr1;
  ptr1=(char *) malloc (10 * sizeof (char));
  int i;
 
  for (i=0;i<10;i++){
 
    *ptr1='A';
    printf("%x",&(*ptr1));
    printf(" ");
    printf("%c ",*ptr1);
    ptr1++; 
  }
}

[xeron33]

Bonjour.

L'adresse mémoire de ptr1 est unique. Lorsque l'opération ptr1++ est effectuée, ce n'est pas l'adresse mémoire de ptr1 qui est incrémentée, mais le contenu de la valeur de ptr1.

Lorsque l'on écrit "int i = 0", l'adresse de i est unique (&i). Si on effectue "i++", alors i vaut 1, mais son adresse mémoire n'a pas changé. C'est pareil pour un pointeur. C'est l'adresse pointée, donc la valeur du pointeur qui est incrémentée, pas son adresse mémoire.

Aussi pour afficher un caractère, c'est %c et non %s qui attend un \0 à la fin.

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
#include <stdio.h>
#include <stdlib.h>
 
void main(){
 
  char *ptr1;
  ptr1=(char *) malloc (10 * sizeof (char));
  int i;
 
  for (i=0;i<10;i++){
 
    *ptr1='A';
    printf("%x",&(*ptr1));
    printf(" ");
    printf("%c ",*ptr1);
    ptr1++; 
  }
}

Merçi pour votre réponse :
L'adresse mémoire de ptr1 est unique. Lorsque l'opération ptr1++ est effectuée, ce n'est pas l'adresse mémoire de ptr1 qui est incrémentée, mais le contenu de la valeur de ptr1. oui mais puisque la valeur de ptr1 est toujours "A"

C'est l'adresse pointée, donc la valeur du pointeur qui est incrémentée, pas son adresse mémoire.
Quelle différence faites-vous entre valeur de pointeur et adresse mémoire moi j'en vois pas puisque un pointeur contient une adresse mémoire

Aussi pour afficher un caractère, c'est %c et non %s qui attend un \0 à la fin.
J'ai testé avec %c il ne m'affiche pas la valeur de ptr1 soit "A".
Merçi encore

[diogene]

L'adresse mémoire de ptr1 est unique. Lorsque l'opération ptr1++ est effectuée, ce n'est pas l'adresse mémoire de ptr1 qui est incrémentée, mais le contenu de la valeur de ptr1. oui mais puisque la valeur de ptr1 est toujours "A"

Non, la valeur de ptr1 n'est pas "A"

C'est l'adresse pointée, donc la valeur du pointeur qui est incrémentée, pas son adresse mémoire.
Quelle différence faites-vous entre valeur de pointeur et adresse mémoire moi j'en vois pas puisque un pointeur contient une adresse mémoire

Le pointeur contient une adresse et possède lui-même sa propre adresse qui n'a rien à voir avec son contenu

Le déroulement est le suivant (? représente un contenu indéterminé et - un objet alloué dynamiquement donc non nommé)

ligne    adresse  id de l'objet  contenu de l'objet
  6         p        ptr1                ?         //char *ptr1;
  7         p        ptr1                n         //ptr1=malloc (10);
            n          -                 ?
           n+1         -                 ?
           ...        ...               ...
 12         p        ptr1                n         // *ptr1='A';
            n          -                'A'
           n+1         -                 ?
           ...        ...               ...   
 16         p         ptr1              n+1       //ptr1++;
            n          -                'A'
           n+1         -                 ?
           ...        ...               ...
 12         p         ptr1              n+1       // *ptr1='A';         
            n          -                'A'
           n+1         -                'A'
           n+2         -                 ?
           ...        ...               ...
etc.

- ligne 06 : ptr1 est un objet pointeur. Comme pour tout objet, son adresse (p) est constante et déterminée à la création de l'objet.

- ligne 07 : ptr1 contient au départ l'adresse (n) du premier byte de la mémoire allouée par le malloc (10 bytes)

- ligne 12 : à l'adresse contenue dans ptr1 (n pour i ==0 et n+1, n+2,... ensuite; en fait n+i), on place la valeur 'A'. Autrement dit, à cet élément de la zone allouée (le premier pour i==0, ensuite le second puis le troisième ... ; en fait le (i+1)ième) on met 'A'

- ligne 13 : on affiche la valeur de &(*ptr1). &(*ptr1) == ptr1. On affiche alors le contenu de ptr1, donc l'adresse (n+i). C'est l'adresse du (i+1)ième élément alloué par le malloc()

- ligne 15 : on affiche la valeur de l'objet dont l'adresse , soit (n+i), est dans ptr1. Autrement dit, on affiche (char)'A', valeur placée en ligne 12.

- ligne 16 : on incrémente le contenu de ptr1 : Celui-ci contient maintenant l'adresse de l'élément suivant de la zone allouée par le malloc() (soit n+i+1)

- on retourne en ligne 12 ...

L'affichage sera du genre : (n) A (n+1) A (n+2) A ....(n+9) A
ou n est une valeur représentant l'adresse de la zone allouée par le malloc()

A la fin, la zone allouée ne contient que des 'A'.

[xeron33]

Non, la valeur de ptr1 n'est pas "A"

Le pointeur contient une adresse et possède lui-même sa propre adresse qui n'a rien à voir avec son contenu

Le déroulement est le suivant (? représente un contenu indéterminé et - un objet alloué dynamiquement donc non nommé)

ligne    adresse  id de l'objet  contenu de l'objet
  6         p        ptr1                ?         //char *ptr1;
  7         p        ptr1                n         //ptr1=malloc (10);
            n          -                 ?
           n+1         -                 ?
           ...        ...               ...
 12         p        ptr1                n         // *ptr1='A';
            n          -                'A'
           n+1         -                 ?
           ...        ...               ...   
 16         p         ptr1              n+1       //ptr1++;
            n          -                'A'
           n+1         -                 ?
           ...        ...               ...
 12         p         ptr1              n+1       // *ptr1='A';         
            n          -                'A'
           n+1         -                'A'
           n+2         -                 ?
           ...        ...               ...
etc.

- ligne 06 : ptr1 est un objet pointeur. Comme pour tout objet, son adresse (p) est constante et déterminée à la création de l'objet.

- ligne 07 : ptr1 contient au départ l'adresse (n) du premier byte de la mémoire allouée par le malloc (10 bytes)

- ligne 12 : à l'adresse contenue dans ptr1 (n pour i ==0 et n+1, n+2,... ensuite; en fait n+i), on place la valeur 'A'. Autrement dit, à cet élément de la zone allouée (le premier pour i==0, ensuite le second puis le troisième ... ; en fait le (i+1)ième) on met 'A'

- ligne 13 : on affiche la valeur de &(*ptr1). &(*ptr1) == ptr1. On affiche alors le contenu de ptr1, donc l'adresse (n+i). C'est l'adresse du (i+1)ième élément alloué par le malloc()

- ligne 15 : on affiche la valeur de l'objet dont l'adresse , soit (n+i), est dans ptr1. Autrement dit, on affiche (char)'A', valeur placée en ligne 12.

- ligne 16 : on incrémente le contenu de ptr1 : Celui-ci contient maintenant l'adresse de l'élément suivant de la zone allouée par le malloc() (soit n+i+1)

- on retourne en ligne 12 ...

L'affichage sera du genre : (n) A (n+1) A (n+2) A ....(n+9) A
ou n est une valeur représentant l'adresse de la zone allouée par le malloc()

A la fin, la zone allouée ne contient que des 'A'.

**************************************************************************************

Merçi pour votre démonstration le pouce vert est de rigueur !!!!
Toutefois 1 ombre encore dans votre explication
- ligne 13 : on affiche la valeur de &(*ptr1). &(*ptr1) == ptr1. On affiche alors le contenu de ptr1, donc l'adresse (n+i). C'est l'adresse du (i+1)ième élément alloué par le malloc()
Pourquoi vous dites On affiche alors le contenu de ptr1, donc l'adresse (n+i). au départ on est à n=i=0 (non ?)

Et trés bizarre mais à l'exécution maintenant le contenu de l'adresse change :

./C1

804a008 A 804a009 A 804a00a A 804a00b A 804a00c A 804a00d A 804a00e A 804a00f A 804a010 A 804a011 A

Comme je pensais que ça allait se produire au début de mon sujet.
Là je vois pas

[diogene]

Pourquoi vous dites On affiche alors le contenu de ptr1, donc l'adresse (n+i). au départ on est à n=i=0 (non ?)

Oui pour i, non pour n.
n est la valeur renvoyée par le malloc. Ce n'est pas 0 (ou NULL) sinon l'allocation a échoué.
Au fur et à mesure qu'on déroule la boucle, on aura n , n+1, n+2,... (à cause de la ligne 16) dans ptr1 ce qui est en fait égal à n+i.
Et donc l'adresse contenue dans le pointeur ptr1 change ce que montre bien l'affichage.

[moldavi]

Merçi pour votre réponse :
L'adresse mémoire de ptr1 est unique. Lorsque l'opération ptr1++ est effectuée, ce n'est pas l'adresse mémoire de ptr1 qui est incrémentée, mais le contenu de la valeur de ptr1. oui mais puisque la valeur de ptr1 est toujours "A"

La valeur de ptr1 est une adresse mémoire, pas la valeur A.

C'est l'adresse pointée, donc la valeur du pointeur qui est incrémentée, pas son adresse mémoire.
Quelle différence faites-vous entre valeur de pointeur et adresse mémoire moi j'en vois pas puisque un pointeur contient une adresse mémoire

Un pointeur a une adresse mémoire et sa valeur contient aussi une autre adresse mémoire.

Aussi pour afficher un caractère, c'est %c et non %s qui attend un \0 à la fin.
J'ai testé avec %c il ne m'affiche pas la valeur de ptr1 soit "A".
Merçi encore

La valeur de ptr1 n'est pas A mais une adresse mémoire.

Peut-être qu'une représentation graphique sera plus parlant :

http://chgi.developpez.com/pointeur/

[xeron33]

Merçi à vous deux pour votre aide, je pense avoir compris la démonstration, c'est vrai que ce n'est pas évident à assimiler.
Juste une dernière chose j'avais fait une erreur entre 2 sources quasiment identiques sauf que sur l'un d'eux j'avais écris à la ligne 13 :

Code :

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

1
2
 
 printf("%x\n",&ptr1);

au lieu de :

Code :

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

1
2
 
 printf("%x\n",&(*ptr1));

Et là l'adresse ne variait pas, il prenait en compte l'adresse de départ de ptr1 si j'ai tout bien compris...
Merçi encore
A +

[diogene]

Le premier affiche l'adresse de ptr1 qui ne peut pas changer : elle est celle qui lui a été attribuée lors de sa création et ne changera jamais.

Le second affiche le contenu de ptr1, qui lui peut changer et change effectivement à cause du ptr1++

Note :
&(*ptr1) == &*ptr1 est la même chose qu'écrire ptr1
* ptr1 est l'objet dont l'adresse est dans ptr1
&*ptr1 est donc l'adresse de l'objet dont l'adresse est dans ptr1 donc est égal au contenu de ptr1

[Obsidian]

Merçi à vous deux pour votre aide, je pense avoir compris la démonstration, c'est vrai que ce n'est pas évident à assimiler.
Juste une dernière chose j'avais fait une erreur entre 2 sources quasiment identiques sauf que sur l'un d'eux j'avais écris à la ligne 13 :

Code :

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

1
2
 
 printf("%x\n",&ptr1);

au lieu de :

Code :

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

1
2
 
 printf("%x\n",&(*ptr1));

Petite remarque : plutôt que « %x », tu peux utiliser « %p » avec printf() pour lui indiquer que c'est le contenu d'un pointeur que tu affiches.

[xeron33]

Petite remarque : plutôt que « %x », tu peux utiliser « %p » avec printf() pour lui indiquer que c'est le contenu d'un pointeur que tu affiches.

Merçi pour cette remarque, avec "%x" j'ai à l'exécution :

804a008
valeur = A
804a009
valeur = A
804a00a
valeur = A
804a00b
valeur = A
804a00c
valeur = A
804a00d
valeur = A
804a00e
valeur = A
804a00f
valeur = A
804a010
valeur = A
804a011
valeur = A


avec "%p" j'ai :

0x804a008
valeur = A
0x804a009
valeur = A
0x804a00a
valeur = A
0x804a00b
valeur = A
0x804a00c
valeur = A
0x804a00d
valeur = A
0x804a00e
valeur = A
0x804a00f
valeur = A
0x804a010
valeur = A
0x804a011
valeur = A


Qu''en penses tu ?

[xeron33]

Le premier affiche l'adresse de ptr1 qui ne peut pas changer : elle est celle qui lui a été attribuée lors de sa création et ne changera jamais.

Le second affiche le contenu de ptr1, qui lui peut changer et change effectivement à cause du ptr1++

Note :
&(*ptr1) == &*ptr1 est la même chose qu'écrire ptr1
* ptr1 est l'objet dont l'adresse est dans ptr1
&*ptr1 est donc l'adresse de l'objet dont l'adresse est dans ptr1 donc est égal au contenu de ptr1

Ok donc si j'ai bien compris quand tu dis : Le second affiche le contenu de ptr1, qui lui peut changer donc ce contenu est une nouvelle adresse ?

[Obsidian]

Merçi pour cette remarque, avec "%x" j'ai à l'exécution :

804a008
valeur = A

avec "%p" j'ai :

0x804a008
valeur = A

Qu''en penses tu ?

« 0x » est le préfixe utilisé dans un code source C pour indiquer que ce suit immédiatement est écrit en hexadécimal.

Lorsque tu utilises « %x », tu demandes simplement à écrire en hexadécimal sur la sortie standard, pas spécialement à rédiger une expression C. Donc, seuls les chiffres seront écrits, ce qui est utile si tu veux concaténer plusieurs valeurs en sortie.

Lorsque tu utilises « %p », tu indiques au C que tu veux écrire le contenu d'un pointeur à l'écran et que tu lui laisses carte blanche pour le faire de la manière la plus appropriée. Il se trouve que le plus naturel est effectivement de l'écrire en hexadécimal mais, dans ce cas, il va mettre en forme la valeur qu'il écrit.

Mais c'est surtout un moyen d'être sûr de choisir toujours le bon format ! N'oublie pas que printf() est une fonction ordinaire et que le seul moyen de connaître le type (et donc la taille en mémoire) des paramètres à afficher est de se baser sur le contenu de la chaîne. Si tu écris « %x », printf considèrera qu'il s'agit d'un « unsigned int », donc sur 32 bits par défaut. Coup de bol, sur une machine 32 bits, les pointeurs font le même format. Par contre, regarde ce qui se passe sur une machine 64 bits :

Code C :

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    x = 0;
    void * y = &x;
 
    printf ("%x\n",y);
    printf ("%p\n",y);
 
    return 0;
}

Code Shell :

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

1
2
3
$ ./programme
52649814
0x7fff52649814

[xeron33]

Merçi pour ton aide.
A +