Pour ne pas trop encombrer, je pose mes questions (de débutant) en une fois
:
1. j'implémente l'exemple classique (il me semble en tous cas!) du type
Pile, dans la fonction dépile :
----> je ne comprends pas quand on doit utiliser le symbole . et le
symbole -> ?
----> quel est l'intérêt des lignes 2 et 4, pourquoi ne pas écrire
uniquement la ligne 3?
2. quand doit-on écrire :
Pile_elt* nouveau=new Pile_elt;
ou :
Pile_elt* nouveau
----> je ne comprends pas quand on doit utiliser le symbole . et le symbole -> ? la -> quand la variable est un pointeur, le . lorsque c'est un objet ou
une référence
----> quel est l'intérêt des lignes 2 et 4, pourquoi ne pas écrire uniquement la ligne 3? tu as besoin de detruire (pour liberer la memoire allouee) l'element au
sommet de la pile lorsque tu depiles. dans ton cas p.tete pointe sur un emplacement en memoire, si tu ne mets que la ligne 2, tu ne pourras plus deleter l'ancienne tete
2. quand doit-on écrire : Pile_elt* nouveau=new Pile_elt; pour creer un nouvel element
ou : Pile_elt* nouveau pour acceder a un element existant (deja alloue)
ne ne vois pas vraiment la différence...
Bernard Bergeron wrote:
1. j'implémente l'exemple classique (il me semble en tous cas!) du type
Pile, dans la fonction dépile :
----> je ne comprends pas quand on doit utiliser le symbole . et le
symbole -> ?
la -> quand la variable est un pointeur, le . lorsque c'est un objet ou
une référence
----> quel est l'intérêt des lignes 2 et 4, pourquoi ne pas écrire
uniquement la ligne 3?
tu as besoin de detruire (pour liberer la memoire allouee) l'element au
sommet de la pile lorsque tu depiles.
dans ton cas p.tete pointe sur un emplacement en memoire, si tu ne mets
que la ligne 2, tu ne pourras plus deleter l'ancienne tete
2. quand doit-on écrire :
Pile_elt* nouveau=new Pile_elt;
pour creer un nouvel element
ou :
Pile_elt* nouveau
pour acceder a un element existant (deja alloue)
----> je ne comprends pas quand on doit utiliser le symbole . et le symbole -> ? la -> quand la variable est un pointeur, le . lorsque c'est un objet ou
une référence
----> quel est l'intérêt des lignes 2 et 4, pourquoi ne pas écrire uniquement la ligne 3? tu as besoin de detruire (pour liberer la memoire allouee) l'element au
sommet de la pile lorsque tu depiles. dans ton cas p.tete pointe sur un emplacement en memoire, si tu ne mets que la ligne 2, tu ne pourras plus deleter l'ancienne tete
2. quand doit-on écrire : Pile_elt* nouveau=new Pile_elt; pour creer un nouvel element
ou : Pile_elt* nouveau pour acceder a un element existant (deja alloue)
ne ne vois pas vraiment la différence...
Jean-Noël Mégoz
"Bernard Bergeron" a écrit dans le message de news:40a12ff1$0$31941$
Pour ne pas trop encombrer, je pose mes questions (de débutant) en une fois
:
Je me trompe peut-être, mais la réponse déjà donnée à ce message me parait un peu laconique pour être vraiment comprise par un novice. Car ce sont en effet des questions de novice !
1. j'implémente l'exemple classique (il me semble en tous cas!) du type Pile, dans la fonction dépile :
----> je ne comprends pas quand on doit utiliser le symbole . et le symbole -> ?
Pour accéder à un membre d'un objet (ou d'une référence comme, ici, p), on utilise le point. Si on écrivait "tete.suivant", ça voudrait dire qu'on veut accéder au membre "suivant" de "tete". Or un pointeur n'a pas de membre : c'est un type simple, au même titre qu'un entier par exemple, une variable qui sert à stocker l'adresse mémoire d'un objet. On utilise donc la flèche dans "tete->suivant" pour dire <<le membre "suivant" de l'objet pointé par "tete">>.
----> quel est l'intérêt des lignes 2 et 4, pourquoi ne pas écrire uniquement la ligne 3?
Si on n'écrit que la ligne 3, la pile change bien de tête, mais alors l'adresse l'objet pointé initialement par "p.tete" est perdue, et il est impossible de faire le delete voulu pour libérer la mémoire qu'il occupe. La ligne 2 sert donc à garder temporairement l'adresse de la tete intiale. Ceci dit, nommer ce pointeur "nouveau" n'est pas l'idéal dans ce cas car il pointe sur un objet qui n'a rien de nouveau. J'aurais trouvé plus judicieux d'écrire : Pile_elt* ancienne_tete = p.tete; p.tete = p.tete-> suivant; delete ancienne_tete;
2. quand doit-on écrire : Pile_elt* nouveau=new Pile_elt; ou : Pile_elt* nouveau
ne ne vois pas vraiment la différence...
La différence est que "nouveau" est initialisé dans le 1er cas et pas dans le 2nd. "Pile_elt* nouveau = new Pile_elt;" crée un nouvel objet de classe Pile_elt, et stocke son adresse mémoire dans un pointeur nommé "nouveau". "Pile_elt* nouveau;" crée un pointeur nommé "nouveau" mais ne lui donne pas de valeur. Il faudra ensuite l'initialiser en le faisant pointer sur un objet de classe Pile_elt.
Tu pourrais renconter aussi la notation "Pile_elt nouveau;", qui créerait un objet de classe Pile_elt, nommé "nouveau". Pour connaitre l'adresse de cet objet, il faudrait écrire "&nouveau". Ainsi : Pile_elt nouvel_objet; Pile_elt* nouveau_pointeur; nouveau_pointeur = &nouvel_objet;
"Bernard Bergeron" <bergeron.trash@free.fr> a écrit dans le message de
news:40a12ff1$0$31941$626a14ce@news.free.fr...
Pour ne pas trop encombrer, je pose mes questions (de débutant) en une
fois
:
Je me trompe peut-être, mais la réponse déjà donnée à ce message me parait
un peu laconique pour être vraiment comprise par un novice. Car ce sont en
effet des questions de novice !
1. j'implémente l'exemple classique (il me semble en tous cas!) du type
Pile, dans la fonction dépile :
----> je ne comprends pas quand on doit utiliser le symbole . et le
symbole -> ?
Pour accéder à un membre d'un objet (ou d'une référence comme, ici, p), on
utilise le point. Si on écrivait "tete.suivant", ça voudrait dire qu'on veut
accéder au membre "suivant" de "tete". Or un pointeur n'a pas de membre :
c'est un type simple, au même titre qu'un entier par exemple, une variable
qui sert à stocker l'adresse mémoire d'un objet.
On utilise donc la flèche dans "tete->suivant" pour dire <<le membre
"suivant" de l'objet pointé par "tete">>.
----> quel est l'intérêt des lignes 2 et 4, pourquoi ne pas écrire
uniquement la ligne 3?
Si on n'écrit que la ligne 3, la pile change bien de tête, mais alors
l'adresse l'objet pointé initialement par "p.tete" est perdue, et il est
impossible de faire le delete voulu pour libérer la mémoire qu'il occupe.
La ligne 2 sert donc à garder temporairement l'adresse de la tete intiale.
Ceci dit, nommer ce pointeur "nouveau" n'est pas l'idéal dans ce cas car il
pointe sur un objet qui n'a rien de nouveau. J'aurais trouvé plus judicieux
d'écrire :
Pile_elt* ancienne_tete = p.tete;
p.tete = p.tete-> suivant;
delete ancienne_tete;
2. quand doit-on écrire :
Pile_elt* nouveau=new Pile_elt;
ou :
Pile_elt* nouveau
ne ne vois pas vraiment la différence...
La différence est que "nouveau" est initialisé dans le 1er cas et pas dans
le 2nd.
"Pile_elt* nouveau = new Pile_elt;" crée un nouvel objet de classe
Pile_elt, et stocke son adresse mémoire dans un pointeur nommé "nouveau".
"Pile_elt* nouveau;" crée un pointeur nommé "nouveau" mais ne lui donne
pas de valeur. Il faudra ensuite l'initialiser en le faisant pointer sur un
objet de classe Pile_elt.
Tu pourrais renconter aussi la notation "Pile_elt nouveau;", qui créerait un
objet de classe Pile_elt, nommé "nouveau".
Pour connaitre l'adresse de cet objet, il faudrait écrire "&nouveau". Ainsi
:
Pile_elt nouvel_objet;
Pile_elt* nouveau_pointeur;
nouveau_pointeur = &nouvel_objet;
"Bernard Bergeron" a écrit dans le message de news:40a12ff1$0$31941$
Pour ne pas trop encombrer, je pose mes questions (de débutant) en une fois
:
Je me trompe peut-être, mais la réponse déjà donnée à ce message me parait un peu laconique pour être vraiment comprise par un novice. Car ce sont en effet des questions de novice !
1. j'implémente l'exemple classique (il me semble en tous cas!) du type Pile, dans la fonction dépile :
----> je ne comprends pas quand on doit utiliser le symbole . et le symbole -> ?
Pour accéder à un membre d'un objet (ou d'une référence comme, ici, p), on utilise le point. Si on écrivait "tete.suivant", ça voudrait dire qu'on veut accéder au membre "suivant" de "tete". Or un pointeur n'a pas de membre : c'est un type simple, au même titre qu'un entier par exemple, une variable qui sert à stocker l'adresse mémoire d'un objet. On utilise donc la flèche dans "tete->suivant" pour dire <<le membre "suivant" de l'objet pointé par "tete">>.
----> quel est l'intérêt des lignes 2 et 4, pourquoi ne pas écrire uniquement la ligne 3?
Si on n'écrit que la ligne 3, la pile change bien de tête, mais alors l'adresse l'objet pointé initialement par "p.tete" est perdue, et il est impossible de faire le delete voulu pour libérer la mémoire qu'il occupe. La ligne 2 sert donc à garder temporairement l'adresse de la tete intiale. Ceci dit, nommer ce pointeur "nouveau" n'est pas l'idéal dans ce cas car il pointe sur un objet qui n'a rien de nouveau. J'aurais trouvé plus judicieux d'écrire : Pile_elt* ancienne_tete = p.tete; p.tete = p.tete-> suivant; delete ancienne_tete;
2. quand doit-on écrire : Pile_elt* nouveau=new Pile_elt; ou : Pile_elt* nouveau
ne ne vois pas vraiment la différence...
La différence est que "nouveau" est initialisé dans le 1er cas et pas dans le 2nd. "Pile_elt* nouveau = new Pile_elt;" crée un nouvel objet de classe Pile_elt, et stocke son adresse mémoire dans un pointeur nommé "nouveau". "Pile_elt* nouveau;" crée un pointeur nommé "nouveau" mais ne lui donne pas de valeur. Il faudra ensuite l'initialiser en le faisant pointer sur un objet de classe Pile_elt.
Tu pourrais renconter aussi la notation "Pile_elt nouveau;", qui créerait un objet de classe Pile_elt, nommé "nouveau". Pour connaitre l'adresse de cet objet, il faudrait écrire "&nouveau". Ainsi : Pile_elt nouvel_objet; Pile_elt* nouveau_pointeur; nouveau_pointeur = &nouvel_objet;
