j'ai un code qui mixe pointeurs et itérateurs, et comme j'ai un bug
que j'arrive pas trop à mettre à jour, je me demandais un truc.
Si j'écris:
-----------------------
std::list<int> l;
int* p;
...
p= &*l.begin();
-----------------------
est-ce que p pointe sur l'entier qui est dans ma liste ou
sur un temporaire ?
et la même chose si je passe par une fonction
-----------------------
int& premier( std::list<int> l){
return *l.begin();
}
p= &(premier(l));
-----------------------
Merci,
Marc (qui est très déçu de ses qualités de programmeur)
--
Si tu peux supporter d'entendre tes paroles
Travesties par des gueux pour exciter des sots
IF -- Rudyard Kipling (Trad. Paul Éluard)
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Marc Boyer
Le 23-10-2006, Falk Tannhäuser a écrit :
----------------------- std::list<int> l; int* p; ... p= &*l.begin(); ----------------------- est-ce que p pointe sur l'entier qui est dans ma liste
Oui. Il faut juste s'assurer que 'l' ne soit pas vide. int* p = &l.front(); marche aussi.
OK, merci.
et la même chose si je passe par une fonction ----------------------- int& premier( std::list<int> l){
Mauvaise idée : le passage par valeur crée une copie de la liste passée en argument, dont la durée de vie ne s'étend que jusqu'à la fin de la fonction.
C'est vrai. Heureusement que ce n'est pas mon vrai code ;-)
return *l.begin(); } p= &(premier(l));
Par conséquent, ici 'p' pointe dans les choux... Par contre, avec int& premier(std::list<int>& lst) 'p' pointera bien sur le premier élément de la liste passée en argument de 'premier()'.
En fait, dans mon pb, la list est un membre, donc le pb que tu as soulevé ne se pose pas. Ce qui signifie que mon bug est à chercher ailleurs...
Merci, Marc -- Si tu peux supporter d'entendre tes paroles Travesties par des gueux pour exciter des sots IF -- Rudyard Kipling (Trad. Paul Éluard)
Le 23-10-2006, Falk Tannhäuser <falk.tannhauser@crf.canon.fr> a écrit :
-----------------------
std::list<int> l;
int* p;
...
p= &*l.begin();
-----------------------
est-ce que p pointe sur l'entier qui est dans ma liste
Oui. Il faut juste s'assurer que 'l' ne soit pas vide.
int* p = &l.front();
marche aussi.
OK, merci.
et la même chose si je passe par une fonction
-----------------------
int& premier( std::list<int> l){
Mauvaise idée : le passage par valeur crée une copie de la liste passée
en argument, dont la durée de vie ne s'étend que jusqu'à la fin de la
fonction.
C'est vrai. Heureusement que ce n'est pas mon vrai code ;-)
return *l.begin();
}
p= &(premier(l));
Par conséquent, ici 'p' pointe dans les choux...
Par contre, avec
int& premier(std::list<int>& lst)
'p' pointera bien sur le premier élément de la liste passée en argument
de 'premier()'.
En fait, dans mon pb, la list est un membre, donc le pb que tu as
soulevé ne se pose pas. Ce qui signifie que mon bug est à chercher
ailleurs...
Merci,
Marc
--
Si tu peux supporter d'entendre tes paroles
Travesties par des gueux pour exciter des sots
IF -- Rudyard Kipling (Trad. Paul Éluard)
----------------------- std::list<int> l; int* p; ... p= &*l.begin(); ----------------------- est-ce que p pointe sur l'entier qui est dans ma liste
Oui. Il faut juste s'assurer que 'l' ne soit pas vide. int* p = &l.front(); marche aussi.
OK, merci.
et la même chose si je passe par une fonction ----------------------- int& premier( std::list<int> l){
Mauvaise idée : le passage par valeur crée une copie de la liste passée en argument, dont la durée de vie ne s'étend que jusqu'à la fin de la fonction.
C'est vrai. Heureusement que ce n'est pas mon vrai code ;-)
return *l.begin(); } p= &(premier(l));
Par conséquent, ici 'p' pointe dans les choux... Par contre, avec int& premier(std::list<int>& lst) 'p' pointera bien sur le premier élément de la liste passée en argument de 'premier()'.
En fait, dans mon pb, la list est un membre, donc le pb que tu as soulevé ne se pose pas. Ce qui signifie que mon bug est à chercher ailleurs...
Merci, Marc -- Si tu peux supporter d'entendre tes paroles Travesties par des gueux pour exciter des sots IF -- Rudyard Kipling (Trad. Paul Éluard)
Falk Tannhäuser
----------------------- std::list<int> l; int* p; ... p= &*l.begin(); ----------------------- est-ce que p pointe sur l'entier qui est dans ma liste
Oui. Il faut juste s'assurer que 'l' ne soit pas vide. int* p = &l.front(); marche aussi.
et la même chose si je passe par une fonction ----------------------- int& premier( std::list<int> l){
Mauvaise idée : le passage par valeur crée une copie de la liste passée en argument, dont la durée de vie ne s'étend que jusqu'à la fin de la fonction.
return *l.begin(); } p= &(premier(l));
Par conséquent, ici 'p' pointe dans les choux... Par contre, avec int& premier(std::list<int>& lst) 'p' pointera bien sur le premier élément de la liste passée en argument de 'premier()'.
Falk
-----------------------
std::list<int> l;
int* p;
...
p= &*l.begin();
-----------------------
est-ce que p pointe sur l'entier qui est dans ma liste
Oui. Il faut juste s'assurer que 'l' ne soit pas vide.
int* p = &l.front();
marche aussi.
et la même chose si je passe par une fonction
-----------------------
int& premier( std::list<int> l){
Mauvaise idée : le passage par valeur crée une copie de la liste passée
en argument, dont la durée de vie ne s'étend que jusqu'à la fin de la
fonction.
return *l.begin();
}
p= &(premier(l));
Par conséquent, ici 'p' pointe dans les choux...
Par contre, avec
int& premier(std::list<int>& lst)
'p' pointera bien sur le premier élément de la liste passée en argument
de 'premier()'.
----------------------- std::list<int> l; int* p; ... p= &*l.begin(); ----------------------- est-ce que p pointe sur l'entier qui est dans ma liste
Oui. Il faut juste s'assurer que 'l' ne soit pas vide. int* p = &l.front(); marche aussi.
et la même chose si je passe par une fonction ----------------------- int& premier( std::list<int> l){
Mauvaise idée : le passage par valeur crée une copie de la liste passée en argument, dont la durée de vie ne s'étend que jusqu'à la fin de la fonction.
return *l.begin(); } p= &(premier(l));
Par conséquent, ici 'p' pointe dans les choux... Par contre, avec int& premier(std::list<int>& lst) 'p' pointera bien sur le premier élément de la liste passée en argument de 'premier()'.
Falk
Marc G
"Marc Boyer" a écrit dans le message de news:
Bonjour,
j'ai un code qui mixe pointeurs et itérateurs, et comme j'ai un bug que j'arrive pas trop à mettre à jour, je me demandais un truc.
Si j'écris: ----------------------- std::list<int> l; int* p; ... p= &*l.begin();
est-ce que p pointe sur l'entier qui est dans ma liste ou sur un temporaire ?
et pourquoi tu n'écris pas simplement p=l.begin();
"Marc Boyer" <Marc.Boyer@enseeiht.yahoo.fr.invalid> a écrit dans le message
de news: slrnejp1eg.j47.Marc.Boyer@localhost.localdomain...
Bonjour,
j'ai un code qui mixe pointeurs et itérateurs, et comme j'ai un bug
que j'arrive pas trop à mettre à jour, je me demandais un truc.
Si j'écris:
-----------------------
std::list<int> l;
int* p;
...
p= &*l.begin();
est-ce que p pointe sur l'entier qui est dans ma liste ou
sur un temporaire ?
et pourquoi tu n'écris pas simplement
p=l.begin();
Si j'écris: ----------------------- std::list<int> l; int* p; ... p= &*l.begin();
est-ce que p pointe sur l'entier qui est dans ma liste ou sur un temporaire ?
et pourquoi tu n'écris pas simplement p=l.begin();
Parce que begin renvoie un iterateur, et un iterateur n'est pas un pointeur sur la valeur.
Gabriel Dos Reis
Marc Boyer writes:
| Bonjour, | | j'ai un code qui mixe pointeurs et itérateurs, et comme j'ai un bug | que j'arrive pas trop à mettre à jour, je me demandais un truc. | | Si j'écris: | ----------------------- | std::list<int> l; | int* p; | ... | p= &*l.begin(); | ----------------------- | est-ce que p pointe sur l'entier qui est dans ma liste ou | sur un temporaire ?
Est-ce qu'il y a quelque chose dans la liste?
| et la même chose si je passe par une fonction | ----------------------- | int& premier( std::list<int> l){ | return *l.begin(); | } | p= &(premier(l)); | -----------------------
clairement "p" pointe dans le vide -- l est détruit avec ses éléments.
-- Gaby
Marc Boyer <Marc.Boyer@enseeiht.yahoo.fr.invalid> writes:
| Bonjour,
|
| j'ai un code qui mixe pointeurs et itérateurs, et comme j'ai un bug
| que j'arrive pas trop à mettre à jour, je me demandais un truc.
|
| Si j'écris:
| -----------------------
| std::list<int> l;
| int* p;
| ...
| p= &*l.begin();
| -----------------------
| est-ce que p pointe sur l'entier qui est dans ma liste ou
| sur un temporaire ?
Est-ce qu'il y a quelque chose dans la liste?
| et la même chose si je passe par une fonction
| -----------------------
| int& premier( std::list<int> l){
| return *l.begin();
| }
| p= &(premier(l));
| -----------------------
clairement "p" pointe dans le vide -- l est détruit avec ses éléments.
| Bonjour, | | j'ai un code qui mixe pointeurs et itérateurs, et comme j'ai un bug | que j'arrive pas trop à mettre à jour, je me demandais un truc. | | Si j'écris: | ----------------------- | std::list<int> l; | int* p; | ... | p= &*l.begin(); | ----------------------- | est-ce que p pointe sur l'entier qui est dans ma liste ou | sur un temporaire ?
Est-ce qu'il y a quelque chose dans la liste?
| et la même chose si je passe par une fonction | ----------------------- | int& premier( std::list<int> l){ | return *l.begin(); | } | p= &(premier(l)); | -----------------------
clairement "p" pointe dans le vide -- l est détruit avec ses éléments.
-- Gaby
Marc Boyer
Le 24-10-2006, Gabriel Dos Reis a écrit :
Marc Boyer writes:
| Bonjour, | | j'ai un code qui mixe pointeurs et itérateurs, et comme j'ai un bug | que j'arrive pas trop à mettre à jour, je me demandais un truc. | | Si j'écris: | ----------------------- | std::list<int> l; | int* p; | ... | p= &*l.begin(); | ----------------------- | est-ce que p pointe sur l'entier qui est dans ma liste ou | sur un temporaire ?
Est-ce qu'il y a quelque chose dans la liste?
Oui. J'ai pas ajouté le 'push_back' pour alléger la lecture, mais j'aurais peut-être du. --------------------------------------- std::list<int> l; int* p; l.push_back(0); p= &*l.begin(); *p= 1; assert( *(l.begin()) == 1 ); ---------------------------------------
Marc Boyer -- Si tu peux supporter d'entendre tes paroles Travesties par des gueux pour exciter des sots IF -- Rudyard Kipling (Trad. Paul Éluard)
Le 24-10-2006, Gabriel Dos Reis <gdr@integrable-solutions.net> a écrit :
Marc Boyer <Marc.Boyer@enseeiht.yahoo.fr.invalid> writes:
| Bonjour,
|
| j'ai un code qui mixe pointeurs et itérateurs, et comme j'ai un bug
| que j'arrive pas trop à mettre à jour, je me demandais un truc.
|
| Si j'écris:
| -----------------------
| std::list<int> l;
| int* p;
| ...
| p= &*l.begin();
| -----------------------
| est-ce que p pointe sur l'entier qui est dans ma liste ou
| sur un temporaire ?
Est-ce qu'il y a quelque chose dans la liste?
Oui. J'ai pas ajouté le 'push_back' pour alléger la lecture,
mais j'aurais peut-être du.
---------------------------------------
std::list<int> l;
int* p;
l.push_back(0);
p= &*l.begin();
*p= 1;
assert( *(l.begin()) == 1 );
---------------------------------------
| Bonjour, | | j'ai un code qui mixe pointeurs et itérateurs, et comme j'ai un bug | que j'arrive pas trop à mettre à jour, je me demandais un truc. | | Si j'écris: | ----------------------- | std::list<int> l; | int* p; | ... | p= &*l.begin(); | ----------------------- | est-ce que p pointe sur l'entier qui est dans ma liste ou | sur un temporaire ?
Est-ce qu'il y a quelque chose dans la liste?
Oui. J'ai pas ajouté le 'push_back' pour alléger la lecture, mais j'aurais peut-être du. --------------------------------------- std::list<int> l; int* p; l.push_back(0); p= &*l.begin(); *p= 1; assert( *(l.begin()) == 1 ); ---------------------------------------
