boucle while simple

**xeron33** · 07/09/2007, 22h42

Envoyé par Emmanuel Delahaye

Quand l'objet pointé n'est plus valide, par exemple, suite à la libération du bloc pointé. On matérialise cet état en lui donnant la valeur NULL. C'est une opération volontaire du (bon) codeur.

Tu te trompes de manuel. Celui de la bibliothèque C est le 3 (free(3))

http://man.developpez.com/man3/free.3.php

2)tu codes :

Code :

free (p), p = NULL;

free() libère l'espace mémoire pointé par ptr, qui a été obtenu lors d'un appel antérieur à malloc(), calloc() ou realloc(). Si le pointeur ptr n'a pas été obtenu par l'un de ces appels, ou si il a déjà été libéré avec free(), le comportement est indéterminé. Si ptr est NULL, aucune tentative de libération n'a lieu.
bonsoir Emmanuel, donc free libère l'espace mémoire pointé içi par p(pointeur p) et l'associe à rien; c'est à dire ne pointe sur rien donc NULL. t'es OK ? A +

**Emmanuel Delahaye** · 08/09/2007, 01h11

Envoyé par xeron33

Code :

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

   free (p), p = NULL;

donc free libère l'espace mémoire pointé içi par p(pointeur p)

OK.

et l'associe à rien; c'est à dire ne pointe sur rien donc NULL. t'es OK ?

Non.
C'est mon action volontaire p = NULL qui fait qu'il pointe sur 'rien'.

Si on fait simplement free (p); p se retrouve à pointer sur de la mémoire invalide. Toute réutilisation entrainerait un comportement indéterminé. Pour éviter ça, j'utilise un principe de Bonne Programmation qui veut que l'état d'un poiteur soit toujours clair et testable. NULL, c'est clair : invalide.

Ca a l'air difficile à comprendre... Tu trouves ça compliqué ?

**xeron33** · 09/09/2007, 13h19

Envoyé par Emmanuel Delahaye

OK.Non.
C'est mon action volontaire p = NULL qui fait qu'il pointe sur 'rien'.

Si on fait simplement free (p); p se retrouve à pointer sur de la mémoire invalide. Toute réutilisation entrainerait un comportement indéterminé. Pour éviter ça, j'utilise un principe de Bonne Programmation qui veut que l'état d'un poiteur soit toujours clair et testable. NULL, c'est clair : invalide.

Ca a l'air difficile à comprendre... Tu trouves ça compliqué ?

bonjour Emmanuel, oui ça j'avais compris que c'était ton action volontaire, c'était simplement pour voir si ce que tu faisais je le comprenais bien merçi en tout cas.
j'aurai d'autres questions à propos des pointeurs merçi encore A +

**xeron33** · 09/09/2007, 19h15

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 /* Definition de la variable 'a' valant 4 */
   int a = 4;
 
   /* Definition d'un pointeur 'p' initialise' avec l'adresse de la variable 'a' */
   int *p = &a;
 
   /* Definition de la variable 'b' non initialisee */
   int b;
 
   /* recuperation de la valeur de 'a' dans 'b' via le pointeur 'p' */
   b = *p;
 
   /* 'b' vaut maintenant 4 */

bonsoir Emmanuel je voudrais faire le clair dans mon esprit par apport à une question que je me pose sur les pointeurs. En effet un pointeur contient l'adresse d'une variable ok quelle est la différence entre adresse et valeur ? Ici on donne :

Code :

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

int *p=&a;

puis

Code :

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

b=*p;

Tout ça pour moi me pose pas de problème sauf que si p reçoit l'adresse de a il prend donc automatiquement sa valeur puisque

Code :

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

b=*p;

et /* 'b' vaut maintenant 4
ma question est : comment niveau mémoire fait on la différence entre une adresse et une valeur?Pardonne moi si tu me trouves un peu compliqué par moment mais ça fais parti de ma nature compliqué et passionné. Allez merçi encore pour suivre cette discussion A+

**Emmanuel Delahaye** · 09/09/2007, 21h12

Envoyé par xeron33

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 /* Definition de la variable 'a' valant 4 */
   int a = 4;
 
   /* Definition d'un pointeur 'p' initialise' avec l'adresse de la variable 'a' */
   int *p = &a;
 
   /* Definition de la variable 'b' non initialisee */
   int b;
 
   /* recuperation de la valeur de 'a' dans 'b' via le pointeur 'p' */
   b = *p;
 
   /* 'b' vaut maintenant 4 */

En effet un pointeur contient l'adresse d'une variable ok quelle est la différence entre adresse et valeur ?

Une valeur est une combinaison de bits à laquelle on donne un sens. (une sémantique).

Par exemple, la combinaison 0010 0000 (ou 0x20) représente soit la valeur numérique 32, soit le caractère ASCII ESPACE.

D'une manière générale, le contenu d'une variable est appelé valeur. Lorsqu'il s'agit d'un variable de type int, on dit que cette valeur est un entier. Quand la variable est un pointeur, cette valeur s'appelle une adresse.

Une adresse est donc un type particulier de valeur.

Ici on donne :

Code :

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

int *p=&a;

puis

la variable 'p' contient l'adresse de la variable 'a'.

Code :

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

b=*p;

La variable 'b' contient la valeur pointée par la variable 'p' (donc la valeur de la variable 'a').

Tout ça pour moi me pose pas de problème sauf que si p reçoit l'adresse de a il prend donc automatiquement sa valeur

Ben non. Tu confonds l'adresse de la variable 'a' et valeur de la variable 'a'. Ce sont 2 choses distinctes (pas le même type, pas la même valeur).

puisque

Code :

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

b=*p;

et /* 'b' vaut maintenant 4

C'est l'opérateur '*' qui a permis de récupérer la valeur de la variable pointée par 'p'. C'est le déréférencement.

ma question est : comment niveau mémoire fait on la différence entre une adresse et une valeur?

Je crois que tout a été dit. Tu compares des choses de nature différentes, d'où l'échec de ton raisonnement...

**xeron33** · 10/09/2007, 16h05

Envoyé par Emmanuel Delahaye

Une valeur est une combinaison de bits à laquelle on donne un sens. (une sémantique).

Par exemple, la combinaison 0010 0000 (ou 0x20) représente soit la valeur numérique 32, soit le caractère ASCII ESPACE.

D'une manière générale, le contenu d'une variable est appelé valeur. Lorsqu'il s'agit d'un variable de type int, on dit que cette valeur est un entier. Quand la variable est un pointeur, cette valeur s'appelle une adresse.

Une adresse est donc un type particulier de valeur.

la variable 'p' contient l'adresse de la variable 'a'.

La variable 'b' contient la valeur pointée par la variable 'p' (donc la valeur de la variable 'a').
Ben non. Tu confonds l'adresse de la variable 'a' et valeur de la variable 'a'. Ce sont 2 choses distinctes (pas le même type, pas la même valeur).

C'est l'opérateur '*' qui a permis de récupérer la valeur de la variable pointée par 'p'. C'est le déréférencement.

Je crois que tout a été dit. Tu compares des choses de nature différentes, d'où l'échec de ton raisonnement...

Bonjour Emmanuel je tenais à te remercier car tu as su m'éclairer sur une question qui me turlupinais par apport aux pointeurs(adresses et valeurs) ainsi qu'aux autres sur ce forum(Thierry en particulier) pour vos aides précieuses je considère mon problème résolu Salut à +

**Emmanuel Delahaye** · 10/09/2007, 17h02

Envoyé par xeron33

Bonjour Emmanuel je tenais à te remercier car tu as su m'éclairer sur une question qui me turlupinais par apport aux pointeurs(adresses et valeurs)

"I'm just doing my job"
-- Jack Bauer in 24.

**xeron33** · 11/09/2007, 11h15

Envoyé par Emmanuel Delahaye

Une valeur est une combinaison de bits à laquelle on donne un sens. (une sémantique).

Par exemple, la combinaison 0010 0000 (ou 0x20) représente soit la valeur numérique 32, soit le caractère ASCII ESPACE.

D'une manière générale, le contenu d'une variable est appelé valeur. Lorsqu'il s'agit d'un variable de type int, on dit que cette valeur est un entier. Quand la variable est un pointeur, cette valeur s'appelle une adresse.

Une adresse est donc un type particulier de valeur.

la variable 'p' contient l'adresse de la variable 'a'.

La variable 'b' contient la valeur pointée par la variable 'p' (donc la valeur de la variable 'a').
Ben non. Tu confonds l'adresse de la variable 'a' et valeur de la variable 'a'. Ce sont 2 choses distinctes (pas le même type, pas la même valeur).

C'est l'opérateur '*' qui a permis de récupérer la valeur de la variable pointée par 'p'. C'est le déréférencement.

Je crois que tout a été dit. Tu compares des choses de nature différentes, d'où l'échec de ton raisonnement...

bonjour Emmanuel puisque tu me dis que c'est ton travail de répondre sur ce forum, je me permets de revenir encore sur les pointeurs oui je sais j'insiste ! mais une question reste en suspens dans mon esprit: oui ok pour l'adresse d'une variable , oui ok pour sa valeur ça j'ai pigé maintenant mais son nom il est stocké comment lui en mémoire pour :

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

1
2
int a;

son nom est "a" comment est stocké "a" ?
Salut A+

**Médinoc** · 11/09/2007, 12h01

En C, il n'est pas stocké (ou alors, dans les infos de débogage).
Seul le compilateur sait que la variable s'appelle "a". Pour le programme lui-même, la variable n'a pas de nom: Elle a juste:

soit une adresse,
soit un offset par rapport à une adresse (typiquement sur un x86, les variables locales ont un offset par rapport au "frame pointer", un pointeur sur la partie de la pile qui correspond à la fonction),
soit un registre (pour les variables qui ne sont pas sauvegardées en mémoire).

**Thierry Chappuis** · 11/09/2007, 17h17

Envoyé par xeron33

mais son nom il est stocké comment lui en mémoire pour :

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

1
2
int a;

son nom est "a" comment est stocké "a" ?
Salut A+

En gros, le compilateur stocke les identificateurs tels que "a" dans l'exemple ci-dessus dans une table des symboles. Cette table des symboles, implantée par exemple savec une table de hachage, permet de faire correspondre un identificateur avec une adresse et un type. Une fois que le code assembleur est généré, il ne reste aucune trace des identificateurs utilisés (à moins de demander explicitement au compilateur de conserver ces informations en vue du déboggage -> option -g avec gcc).

Thierry

**Freed0** · 11/09/2007, 20h22

Envoyé par Emmanuel Delahaye

"I'm just doing my job"
-- Jack Bauer in 24.

**xeron33** · 17/09/2007, 10h23

bonjour à tous et merçi !!!
encore une petite remarque par apport aux pointeurs :
si je code :

Code :

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

1
2
3
4
 
int a=1;
int b=2;
b=a;         /* içi b recoit la valeur de a d'ou b=1  */

c'est la même chose que si je code :

Code :

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

1
2
3
4
5
6
 
int a=1;
int b=2;
int *p;
p=&a;
b=*p;       /* içi b reçoit la valeur de *p d'ou b=1  */

Mon interrogation par apport à ces deux codes pourquoi utiliser ou pas un pointeur?Est-ce plus rapide ?Quel en est l'avantage? Merçi A+

**Emmanuel Delahaye** · 17/09/2007, 10h33

Envoyé par xeron33

<...> pourquoi utiliser ou pas un pointeur?Est-ce plus rapide ?Quel en est l'avantage?

http://emmanuel-delahaye.developpez....util_pointeurs

**Thierry Chappuis** · 17/09/2007, 10h35

L'action réalisée par les deux codes proposés est équivalente. Le 1er présente l'avantage d'être simple... et est probablement très légèrement plus rapide. Je ne vois pas d'intérêt autre que pédagogique à transiter par un pointeur pour affecter la valeur d'une variable a à une variable b (dans le contexte présenté ci-dessus).

Un pointeur est par exemple utile lorsqu'il s'agit de passer l'adresse d'une variable à une fonction. Dans ce contexte, il est alors possible de modifier la valeur située à l'adresse pointée depuis la fonction. Par ailleurs, lorsqu'il s'agit de passer une structure de grande taille à une fonction, l'usage d'un pointeur permet d'éviter d'avoir à copier la structure en entier à chaque appel de la fonction considérée (gain en termes de performance et d'occupation de la mémoire).

Thierry

boucle while simple

C

Discussions similaires

Partager

Partager