Discussion :

[tabkelm]

bonjour,

Dans la correction de l'exercice3 de cette page:
https://mrproof.blogspot.com/2010/10...langage-c.html
il y a une ligne que je ne comprends pas:

Code :

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

1
2
 
int *adr_i,i=0x12345678;

i est initialisé avec une valeur hexadécimale alors que son type est int
Bizarre non?
Dans cette ligne,le type de i est int ou int *?


merci de votre aide

[edgarjacobs]

Hello,

Bizarre ? Non.

Tu peux initialiser une valeur numérique avec un valeur décimale i=27, une valeur octale (c'est ce qu'indique le zéro qui préfixe la valeur) i=033 ou hexadécimale i=0x1bEt dans cet exemple, i n'étant pas précédé d'une étoile, il est de type int et pas de type pointeur sur int (ça c'est le cas de adr_i)

[dalfab]

Salut,

L'hexadécimal ça n'est qu'une notation pour écrire un nombre. Un int lui contient un nombre.

Code :

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

1
2
3
4
5
int x = 14;         // par défaut écriture décimale, les humains l'aiment bien
int x = 0xD;        // écriture hexadécimale
int x = 016;        // écriture octale
int x = 0b1110;     // écriture binaire
int x = 3 + 0x1 + 010 + 0b10; // somme de nombres

Ces 5 lignes sont exactement les mêmes. Elles créent un entier x qui contient le nombre quatorze.

[tabkelm]

Dans la solution:

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 <string.h>
#include <strings.h>
 
int main()
{
char *adr_c;
int *adr_i;
int i=0x12345678;
adr_i = &i;
adr_c = (char*)adr_i;
printf("ADRESSE: %p CONTENU: %x\n",adr_c,*adr_c);
printf("ADRESSE: %p CONTENU: %x\n",adr_c+1,*(adr_c+1));
printf("ADRESSE: %p CONTENU: %x\n",adr_c+2,*(adr_c+2));
printf("ADRESSE: %p CONTENU: %x\n",adr_c+3,*(adr_c+3));
 
return 0;
}

1) adr_c est une adresse ou un pointeur ou les 2 en même temps puisqu'un pointeur pointe vers une adresse ?

2) Que représente *adr_c ?

3) Enfin, ce que je ne comprends pas c'est dans :

Code :

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

printf("ADRESSE: %p CONTENU: %x\n",adr_c,*adr_c);

%x est le format de *adr_c or :
%x est un format spécifique à un entier à afficher en forme hexadécimale
*adr_c est de type char, rien à voir avec un entier en forme hexadécimale

[foetus]

adr_c est 1 fenêtre

En gros ton entier i est stocké sur 4 octets : à vérifier en 64 bits
Et tu vas parcourir cette valeur octet par octet : 0x12, 0x34, 0x56 et enfin 0x78 ou bien 0x78, 0x56, 0x34 et enfin 0x12 ... en fonction de l'endianness, boutisme en français.

[Bktero]

adr_c est une adresse ou un pointeur ou les 2 en meme temps puiqu'un pointeur pointe vers une adresse?

Une assez bonne façon de nommée les choses est de dire :

- une variable a une adresse en mémoire
- un pointeur permet de stocker l'adresse d'une variable d'en certain type

Imaginons, tu as une variable int a = 42;, qui est de type "int" et elle est à l'adresse 1098766888 dans la RAM de ton ordinateur. Tu peux faire une autre variable int * p;, qui est de type "pointeur sur int", et tu peux y stocker l'adresse de a avec p = &a.

Pour aller plus loin, tu pourrais créer une variable de type "pointeur sur pointeur de int", qui pourrait stocker l'adresse de p. Mais là on passe au niveau supérieur de la compréhension des pointeurs

On dit qu'un pointeur pointe sur une variable, mais c'est une façon imagée de décrire un pointeur. Un pointeur contient une valeur, supposée est l'adresse valide d'une variable valide. Il est en effet possible de mettre une valeur manuellement et donc potentiellement invalide dans un pointeur, exemple int* a = 42; car 42 n'est sûrement une adresse dans la RAM. Il est aussi possible que la variable n'existe plus au bout d'un certain temps et que donc le pointeur, même si l'adresse qu'il contient est valide dans la RAM, ne pointe plus vers une variable valide.

Pour qu'un pointeur "pointe sur un pointeur", il faudrait qu'il soit de type "pointeur sur pointeur de TOTO" justement.

[Sve@r]

Bonjour

i est initialisé avec une valeur hexadécimale alors que son type est int
Bizarre non?

Non, pas bizarre. L'hexadécimal est juste un système de numération des nombres entiers établis sur une certaine base. Parce qu'un nombre n'a de sens que si on connait la base dans laquelle il est écrit. Et donc tout nombre exprime une quantité de puissance de ladite base par le rang du chiffre. Ainsi dans la base 18 (pourquoi pas), le nombre 1234 exprime la quantité égale à 1*18^3 + 2*18^2 + 3*18^1 + 4*18^0. Mais ça reste un nombre entier. C'est une chose que tu es censée savoir depuis la fin du primaire.
Le C permet d'exprimer les entiers en base 8, 10 ou 16 et ce, dans toutes les configurations (exemple 0123 + 0x10 vaut 99 (123 en octal c'est 83 en décimal, 10 en hexadécimal c'est 16 en décimal, et 83 + 16 font bien 99).

Dans cette ligne,le type de i est int ou int *?

Là c'est une meilleure question. C'est en effet un raccourci d'écriture que certains utilisent mais qui ne fait réellement pas gagner grand chose (en fait rien du tout). Tu as le droit de séparer ça en deux lignes...

Code c :

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

1
2
int *adr_i;
int i=0x12345678;

... ce qui devient de suite plus clair.

1)adr_c est une adresse ou un pointeur ou les 2 en meme temps puiqu'un pointeur pointe vers une adresse?

Non, un pointeur ne "pointe pas" vers une adresse. Une adresse c'est (en simplifiant) la position d'une case dans la RAM et un pointeur c'est un type de variable permettant de stocker cette adresse.

2)Que représente *adr_c?

Là c'est un poil plus difficile car la notation "étoile truc" change de signification selon comment on l'utilise. Si tu déclares une variable (style int *adr_c) alors tu déclares une variable prévue pour stocker une adresse (donc un pointeur) et si tu utilises cette notation dans une instruction (style int xxx; xxx=(*adr_c)+1) alors cela signifie que tu vas récupérer la valeur située dans la case mémoire qu'il y a à cette adresse (et à cette valeur tu ajoutes ensuite "1" et tu stockes ensuite le résultat de l'opération dans la variable "xxx").

3)Enfin,ce que je ne comprends pas c'est dans:
printf("ADRESSE: %p CONTENU: %x\n",adr_c,*adr_c);
%x est le fomat de *adr_c or:
%x est un format spécifique à un entier à afficher en forme hexadécimale
*adr_c est de type char;rien à voir avec un entier en forme hexadécimale

Oui, une adresse en RAM étant à la base un nombre, tu as tout à fait le droit d'afficher ce nombre dans la base de ton choix. De même un caractère étant lui-aussi un nombre (c'est le nombre qui a été établi dans la table de codage des caractères plus connue sous le nom de "table ascii"), tu as là aussi tout à fait le droit d'afficher ce nombre dans la base que tu veux. Tu as même le droit d'effectuer des calculs sur des caractères. Exemple 'a' + 1 donnera 'b' (parce que dans la table ascii, le 'a' et le 'b' sont à un rang l'un de l'autre). De même 'c' + 'A' - 'a' donnera 'C' (parce que dans la table ascii, les minuscules et majuscules se suivent et ont donc toutes le même écart).

[tabkelm]

quand je déclare comme ceci un entier:

Code :

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

1
2
 
int *p=5;

le pointeur est-il bien p?(et non *p)

[Sve@r]

quand je déclare comme ceci un entier:

Code :

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

1
2
 
int *p=5;

le pointeur est-il bien p?(et non *p)

Là tu ne déclares pas un entier mais un pointeur. Le "5" est vu comme étant l'adresse que tu veux y stocker.
Plus précisément écrire int *p a deux actions

• tu déclares un pointeur nommé "p"
• l'élément "étoile p" (le contenu de la case située à l'adresse 5) doit être considéré comme un int (n'oublie pas que le nombres d'octets n'est pas le même selon le type et qu'il faut que le C sache combien il devra en récupérer quand tu demanderas "étoile p" dans une expression

Bien entendu je considère que tu as écrit "5" comme un exemple et que tu n'iras pas écrire ça dans un vrai programme. Tu ne peux pas mettre n'importe quelle valeur au pif dans un pointeur et espérer que cela va fonctionner. Dans un pointeur tu n'as le droit que d'y mettre des adresses valides.
Une adresse valide c'est soit

• l'adresse d'une variable déjà existante (int xxx; int *p=&xxx)
• une adresse retournée par une fonction d'allocation mémoire (int *p=malloc(1000 * sizeof(int)) => tu demandes à la RAM de te donner un espace suffisant pour y stocker 1000 int => tu récupères alors l'adresse de départ de cet espace et de là tu peux te déplacer où tu veux dedans)
• NULL pour initialiser un pointeur avec une valeur neutre mais quand-même valide

[tabkelm]

l'élément "étoile p" (le contenu de la case située à l'adresse 5)

Je suppose que j'aurai pu mettre à la place de 5 une autre adresse en hexadécimal comme ceci:
in*p=0ABC;
Est-ce bien cela?
a)Si je veux que le contenu de la case soit au tout début de la RAM,dois-je écrire ceci?:
in*p=NULL;
b)si je ceux que le contenu de la case soit à la dernière case de la RAM(j'ai 8 Go de RAM),que dois-je écrire?
Si maintenant à la case 5 je veuille y mettre :
c)un entier quelconque ?
d)l'entier 3 ?
e)une variable v initialisée à 4 ?
que dois-je écrire?

[Sve@r]

Je suppose que j'aurai pu mettre à la place de 5 une autre adresse en hexadécimal comme ceci:
in*p=0ABC;
Est-ce bien cela?

Non. Tu ne mets pas de valeur au pif en espérant que cela va fonctionner, quelle que soit la façon d'écrire cette valeur. Tu ne peux y mettre que (conjonction de subordination) une adresse valide

a)Si je veux que le contenu de la case soit au tout début de la RAM,dois-je écrire ceci?:
in*p=NULL;

Non plus. NULL ne représente pas le début de la RAM mais juste une adresse "neutre" permettant de montrer que le pointeur pointe sur que dalle.

b)si je ceux que le contenu de la case soit à la dernière case de la RAM(j'ai 8 Go de RAM),que dois-je écrire?

Tu peux pas. Et d'ailleurs pourquoi voudrais-tu faire quelque chose d'aussi inutile? qu'est-ce que cette action apportera à ton algorithme???

Si maintenant à la case 5 je veuille y mettre :
c)un entier quelconque ?
d)l'entier 3 ?
e)une variable v initialisée à 4 ?
que dois-je écrire?

Pareil, pourquoi veux-tu écrire spécifiquement dans la case 5? Les pointeurs en C ne sont pas utilisés "pour faire genre". On s'en sert quand on a un besoin précis et dans ce cas, on se fout de la case sur laquelle ils pointent. On sait juste qu'ils pointent vers "la bonne" et ça suffit.

[Kannagi]

Je suppose que j'aurai pu mettre à la place de 5 une autre adresse en hexadécimal comme ceci:
in*p=0ABC;
Est-ce bien cela?
a)Si je veux que le contenu de la case soit au tout début de la RAM,dois-je écrire ceci?:
b)si je ceux que le contenu de la case soit à la dernière case de la RAM(j'ai 8 Go de RAM),que dois-je écrire?

Alors si tu écris le code correctement :

Code :

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

int *p = 0xABC;

Oui tu peux , mais là on va dans un autre domaine (qui est l'embarqué) et qui est loin du niveau débutant.
Et une adresse ne signifie pas forcément que c'est de la RAM.
Mais ce que je dis est vrai que si y'a pas d'adresse virtuel.

Ce qui n'est pas le cas sur PC et sous un OS , qui va mettre des adresses virtuels , et qui ne représente donc pas l'adresse réel qu'il pointe physiquement.
Et donc tu ne peux pas choisir l'adresse pointé , sous peine de segfault (seul l'OS peut te donner des adresses valides ).

[tabkelm]

l'élément "étoile p" (le contenu de la case située à l'adresse 5)

c'est n'importe quoi !
La preuve:

Code :

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

1
2
3
4
5
6
7
8
9
10
 
#include <stdio.h>
 
int main(void) {
 int *p=5;
 printf("adresse de p :%p\n",&p);
 p=5;
 printf("seconde adresse de p :%p\n",&p);
  return 0;
}

à aucun moment l'adresse de p est 5
Voici ce que me retourne ce code:

adresse de p :0x7ffdbda39230
seconde adresse de p :0x7ffdbda39230

[Bousk]

Tu t'emballes bien vite pour dire n'importe quoi.
Ton code affiche l'adresse de p et à aucun moment l'adresse pointée par/à laquelle fait référence p.

[tabkelm]

peut-être alors avec ce code:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
#include <stdio.h>
 
int main(void) {
 
 int *p=5;
 printf("adresse de p :%p\n",&p);
 p=5;//c'est là que l'adresse est 0x5
 printf("seconde adresse de p :%p\n",&p);
 
  printf("troisième adresse de p :%p\n",p);
  return 0;
}

qui me retourne:

adresse de p :0x7ffc72fa85d0
seconde adresse de p :0x7ffc72fa85d0
troisième adresse de p :0x5

autre question:
pourquoi la taille d'un pointeur est toujuors de 8?:

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) {
 
 char *q;
  float*r;
  int *p;
void *v;
 
printf("taille d'un pointeur de int %d\n",sizeof(p));
printf("taille d'un pointeur de char %d\n",sizeof(q));
printf("taille d'un pinteur de float %d\n",sizeof(r));
printf("taille d'un pinteur de type void %d\n",sizeof(v));
 
  return 0;
}

retour:

taille d'un pointeur de int 8
taille d'un pointeur de char 8
taille d'un pinteur de float 8
taille d'un pointeur de type void:8

[Sve@r]

c'est n'importe quoi !

Ouais t'as raison, je raconte n'importe quoi. Tu dois vraiment être exceptionnel pour t'en être rendu compte avant tous les autres professionnels qui évoluent ici et qui me lisent. Ben tu sais quoi le crack, tu vas prendre le temps d'aller ouvrir un bouquin de C pendant que moi je vais arrêter d'en perdre à tenter de t'expliquer comment ça fonctionne.

à aucun moment l'adresse de p est 5

Exact. Sauf que je n'ai jamais dit que "5" serait "l'adresse de p". T'as qu'à relire ce que j'ai écrit en réfléchissant sur le sens des mots, des verbes, etc.

p=5;//c'est là que l'adresse est 0x5

Non plus. On ne peut pas forcer une adresse à valoir la valeur que l'on veut. Cette ligne ne fait rien d'autre que d'affecter la valeur 5 à la variable "p", chose qui était déjà faite aussi deux lignes au dessus.

qui me retourne:

Code :

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

1
2
adresse de p :0x7ffc72fa85d0
seconde adresse de p :0x7ffc72fa85d0

Ben voilà, la preuve que 5 n'est pas l'adresse de p (ni en premier, ni en second). C'est là qu'on peut réfléchir sur lequel de nous deux est celui qui raconte vraiment n'importe quoi...

printf("troisième adresse de p :%p\n",p)

Là tu n'affiches pas l'adresse de "p", juste "p" qui, bien évidemment, vaut 5 puisque c'est la valeur que tu lui as affectée.

[Christophe]

int *adr_i,i=0x12345678;
Dans cette ligne,le type de i est int ou int *?

Dans ce cas le type de i est int

Sinon, il aurait fallu écrire :

Code :

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

int *adr_i,*i;

Pour avoir les deux variables en pointeur.