 |
C++Talk.NET C++ language newsgroups
|
| View previous topic :: View next topic |
| Author |
Message |
Fabien LE LEZ Guest
|
Posted: Sat Jul 10, 2004 2:59 am Post subject: [Vider un std::vector<>] swap |
|
|
Bonjour,
J'aimerais savoir s'il y a une différence entre
vector<C> v;
....
vector<C>().swap (v);
et
vector<C> v;
....
v.swap (vector<C>());
Merci d'avance...
--
schtroumpf schtroumpf
Jean-Emile de France
|
|
| Back to top |
|
 |
Patrick Mézard Guest
|
Posted: Sat Jul 10, 2004 6:24 am Post subject: Re: [Vider un std::vector<>] swap |
|
|
Fabien LE LEZ wrote:
| Quote: | Bonjour,
J'aimerais savoir s'il y a une différence entre
vector<C> v;
...
vector<C>().swap (v);
et
vector<C> v;
...
v.swap (vector<C>());
Merci d'avance...
|
Dans la mesure où swap prend une référence non const en argument, la
deuxième version ne devrait pas compiler non ?
Patrick Mézard
|
|
| Back to top |
|
 |
drkm Guest
|
Posted: Sat Jul 10, 2004 12:00 pm Post subject: Re: [Vider un std::vector<>] swap |
|
|
Fabien LE LEZ <gramster (AT) gramster (DOT) com> writes:
| Quote: | J'aimerais savoir s'il y a une différence entre
vector<C> v;
...
vector<C>().swap (v);
et
vector<C> v;
...
v.swap (vector<C>());
|
Tout ce que j'ai trouvé est ceci :
21.3/5
Table 65 -- Container requirements
| Quote: | | assertion/note |
expression | return type | pre/post-condition | complexity |
-----------+-------------+--------------------+-----------
a.swap(b); | void | swap(a,b) | (Note A)
-----------+-------------+--------------------+-----------
Note: the algorithms swap(), equal() and lexicographical_compare()
are defined in clause 25. Those entries marked "(Note A)" should
have constant complexity.
25.2.2 Swap [lib.alg.swap]
template<class T> void swap(T& a, T& b);
1. Requires: Type T is Assignable (23.1).
2. Effects: Exchanges values stored in two locations.
S'il s'agit effectivement des seules lignes sur le sujet dans la
norme, on ne peut dire qu'elle est très locace à ce propos . Mais
il me semble que 25.2.2/2 répond à ta question.
--drkm
|
|
| Back to top |
|
 |
Fabien LE LEZ Guest
|
Posted: Sat Jul 10, 2004 12:07 pm Post subject: Re: [Vider un std::vector<>] swap |
|
|
On Sat, 10 Jul 2004 14:00:05 +0200, drkm <usenet.fclcxx (AT) fgeorges (DOT) org>:
| Quote: | Mais
il me semble que 25.2.2/2 répond à ta question.
|
I.e., il n'y a pas de différence entre les deux ?
|
|
| Back to top |
|
 |
drkm Guest
|
Posted: Sat Jul 10, 2004 12:18 pm Post subject: Re: [Vider un std::vector<>] swap |
|
|
Fabien LE LEZ <gramster (AT) gramster (DOT) com> writes:
| Quote: | On Sat, 10 Jul 2004 14:00:05 +0200, drkm <usenet.fclcxx (AT) fgeorges (DOT) org>:
Mais
il me semble que 25.2.2/2 répond à ta question.
I.e., il n'y a pas de différence entre les deux ?
|
Oui.
2. Effects: Exchanges values stored in two locations.
Elle reçoit deux paramètres, et échange les valeurs qui y sont
stockées. Elle ne parle par de premier et second arguments. Mais
peut-être y a-t-il un verset que j'ai loupé.
--drkm
|
|
| Back to top |
|
 |
drkm Guest
|
Posted: Sat Jul 10, 2004 12:46 pm Post subject: Re: [Vider un std::vector<>] swap |
|
|
drkm <usenet.fclcxx (AT) fgeorges (DOT) org> writes:
| Quote: | Fabien LE LEZ <gramster (AT) gramster (DOT) com> writes:
On Sat, 10 Jul 2004 14:00:05 +0200, drkm <usenet.fclcxx (AT) fgeorges (DOT) org>:
Mais
il me semble que 25.2.2/2 répond à ta question.
I.e., il n'y a pas de différence entre les deux ?
Oui.
2. Effects: Exchanges values stored in two locations.
Elle reçoit deux paramètres, et échange les valeurs qui y sont
stockées. Elle ne parle par de premier et second arguments. Mais
peut-être y a-t-il un verset que j'ai loupé.
|
Cfr. la réponse de Patrick à propos de l'objet temporaire. Mais je
pense que cela répond dans le cas de deux objets non-temporaires.
Mais Patrick répond à une question que je m'étais posé en lisant le
DR 101. Pourquoi :
vector<T>().swap( v ) ;
au lieu de :
v.swap( vector<T>() ) ;
qui semble plus naturel, puisque l'on veut agir sur v.
--drkm
|
|
| Back to top |
|
 |
Gabriel Dos Reis Guest
|
Posted: Sat Jul 10, 2004 6:01 pm Post subject: Re: [Vider un std::vector<>] swap |
|
|
drkm <usenet.fclcxx (AT) fgeorges (DOT) org> writes:
| Quote: | Mais Patrick répond à une question que je m'étais posé en lisant le
DR 101. Pourquoi :
vector<T>().swap( v ) ;
au lieu de :
v.swap( vector<T>() ) ;
qui semble plus naturel,
|
Vraiment ?
| Quote: | puisque l'on veut agir sur v.
|
C'est bien ce que fait la première version -- swap(v). ;-)
-- Gaby
|
|
| Back to top |
|
 |
Vincent Lascaux Guest
|
Posted: Sat Jul 10, 2004 11:37 pm Post subject: Re: [Vider un std::vector<>] swap |
|
|
| Quote: | | DR 101. Pourquoi :
|
| vector<T>().swap( v ) ;
|
| au lieu de :
|
| v.swap( vector<T>() ) ;
|
| qui semble plus naturel,
Vraiment ?
| puisque l'on veut agir sur v.
C'est bien ce que fait la première version -- swap(v).
|
Je suis d'accord avec drkm pour dire que la deuxieme version ( v.swap(
vector<T>() ); ) est plus naturelle : en langage objet on écrit
objet.action(parametre); pour les "procédures", et on s'attend plutôt à ce
que ca modifie l'objet plutôt que les paramètres.
On est d'accord qu'ici les deux sont modifiés, mais le but de la ligne est
de vider v (pas de remplir l'objet temporaire).
Je lis vector<T>().swap comme "vide" dans la premiere écriture
Je lis swap(vector<T>()) comme "vide" dans la deuxieme écriture
Il me semble plus "objet" d'écrire v.vide() que vide(v) en C++
--
Vincent (qui n'est pas sur que le poste de Gaby n'était pas un troll, une
blague ou une incomprehension)
|
|
| Back to top |
|
 |
Gabriel Dos Reis Guest
|
Posted: Sat Jul 10, 2004 11:48 pm Post subject: Re: [Vider un std::vector<>] swap |
|
|
"Vincent Lascaux" <nospam (AT) nospam (DOT) org> writes:
| Quote: | | DR 101. Pourquoi :
|
| vector<T>().swap( v ) ;
|
| au lieu de :
|
| v.swap( vector<T>() ) ;
|
| qui semble plus naturel,
Vraiment ?
| puisque l'on veut agir sur v.
C'est bien ce que fait la première version -- swap(v). ;-)
Je suis d'accord avec drkm pour dire que la deuxieme version ( v.swap(
vector<T>() ); ) est plus naturelle : en langage objet on écrit
objet.action(parametre);
|
Mais C++ n'est pas un langage objet.
Mauvaise prémisse, changer de prémisse.
| Quote: | Je lis vector<T>().swap comme "vide" dans la premiere écriture
|
Là tu ne lis pas, tu épelles. C'est différent.
-- Gaby
|
|
| Back to top |
|
 |
Franck Branjonneau Guest
|
Posted: Sun Jul 11, 2004 12:05 am Post subject: Re: [Vider un std::vector<>] swap |
|
|
"Vincent Lascaux" <nospam (AT) nospam (DOT) org> écrivait:
| Quote: | | DR 101. Pourquoi :
|
| vector<T>().swap( v ) ;
|
| au lieu de :
|
| v.swap( vector<T>() ) ;
|
| qui semble plus naturel,
Je lis vector<T>().swap comme "vide" dans la premiere écriture
Je lis swap(vector<T>()) comme "vide" dans la deuxieme écriture
Il me semble plus "objet" d'écrire v.vide() que vide(v) en C++
|
Comme nous en sommes au stade des réécritures, je lis
Il me semble ("objet" v.vide()) (vide(v) C++)
;-)
--
Franck qui ne sait si il troll, il blague ou ne comprends rien.
|
|
| Back to top |
|
 |
drkm Guest
|
Posted: Sun Jul 11, 2004 2:46 am Post subject: Re: [Vider un std::vector<>] swap |
|
|
"Vincent Lascaux" <nospam (AT) nospam (DOT) org> writes:
| Quote: | | DR 101. Pourquoi :
| vector<T>().swap( v ) ;
| au lieu de :
| v.swap( vector<T>() ) ;
| qui semble plus naturel,
Vraiment ?
|
Oui.
| Quote: | | puisque l'on veut agir sur v.
C'est bien ce que fait la première version -- swap(v).
|
Oui.
| Quote: | Je suis d'accord avec drkm pour dire que la deuxieme version ( v.swap(
vector<T>() ); ) est plus naturelle : en langage objet on écrit
objet.action(parametre); pour les "procédures", et on s'attend plutôt à ce
que ca modifie l'objet plutôt que les paramètres.
On est d'accord qu'ici les deux sont modifiés, mais le but de la ligne est
de vider v (pas de remplir l'objet temporaire).
Je lis vector<T>().swap comme "vide" dans la premiere écriture
Je lis swap(vector<T>()) comme "vide" dans la deuxieme écriture
Il me semble plus "objet" d'écrire v.vide() que vide(v) en C++
|
C'est marrant. Je savais, en écrivznt l'article auquel a répondu
Gaby, que j'aurais du préciser ce que je voulais dire. Je sais que
swap() prend une référence non constante, et que donc je dois
m'attendre à ce que son paramètre soit modifié.
Mais je trouve tout de même que lorsque l'on a un objet A a
modifier, et un objet B créé pour le modifier, plus clair d'écrire
A.swap( B ) ;
que
B.swap( A ) ;
Je m'attend plus à ce qu'un objet soit modifié par le message qu'on
lui envoit que le paramètre soit modifié par le message dont il est le
paramètre.
--drkm
|
|
| Back to top |
|
 |
Gabriel Dos Reis Guest
|
Posted: Sun Jul 11, 2004 2:57 am Post subject: Re: [Vider un std::vector<>] swap |
|
|
drkm <usenet.fclcxx (AT) fgeorges (DOT) org> writes:
[...]
| Quote: | C'est marrant. Je savais, en écrivznt l'article auquel a répondu
Gaby, que j'aurais du préciser ce que je voulais dire. Je sais que
swap() prend une référence non constante, et que donc je dois
m'attendre à ce que son paramètre soit modifié.
|
Je sais que tu le savais, c'est pour cela que je n'ai pas mentionné
« référence non-const ».
| Quote: | Mais je trouve tout de même que lorsque l'on a un objet A a
modifier, et un objet B créé pour le modifier, plus clair d'écrire
A.swap( B ) ;
que
B.swap( A ) ;
|
Mais, ils se modifient l'un et l'autre ! :-)
Il y a une légende urbaine assez persistante (bien que fausse) selon
laquelle C++ serait un langage orienté objet -- avec le corollaire que
tout serait dans la syntaxe. Cette légende a fait beaucoup de ravages
et va continuer à en faire pendant un bon moment :-(
C++ *supporte* la programmation orientée, ainsi que d'autres
philosophies de programmation. La distinction est tout
n'est pas OO en C++, en particulier ce n'est pas parce que tu utilises
une syntaxe pour écrire « OO » que dès que tu vois cette syntaxe,
quelqu'un a écrit « OO ». De fait, la STL n'est pas OO. Alors, les
raisonnomentss du genre « c'est pas naturel selon la syntaxe OO » n'ont
pas grand sens. La question serait plutôt « est-ce que c'est du C++
idiomatique ». La réponse est oui.
Comment vider la poubelle de « v » ? La construction idiomatique est
(1) prends une poubelle vide -- vector<T>()
(2) échange-la avec celle de v -- .swap(v)
Le tout donne « vector<T>().swap(v) »
| Quote: | Je m'attend plus à ce qu'un objet soit modifié par le message qu'on
lui envoit que le paramètre soit modifié par le message dont il est le
paramètre.
|
t'as pas encore été corrompu par les apôtres OO des getters ? ;-)
-- Gaby
|
|
| Back to top |
|
 |
drkm Guest
|
Posted: Sun Jul 11, 2004 3:08 am Post subject: Re: [Vider un std::vector<>] swap |
|
|
drkm <usenet.fclcxx (AT) fgeorges (DOT) org> writes:
| Quote: | Je m'attend plus à ce qu'un objet soit modifié par le message qu'on
lui envoit que le paramètre soit modifié par le message dont il est le
paramètre.
|
Mais 1/ je sais que cela est subjectif et 2/ non, je n'avais pas vu
ton " ".
:-$
--drkm
|
|
| Back to top |
|
 |
Vincent Lascaux Guest
|
Posted: Sun Jul 11, 2004 11:16 am Post subject: Re: [Vider un std::vector<>] swap |
|
|
| Quote: | | Mais je trouve tout de même que lorsque l'on a un objet A a
| modifier, et un objet B créé pour le modifier, plus clair d'écrire
|
| A.swap( B ) ;
|
| que
|
| B.swap( A ) ;
Mais, ils se modifient l'un et l'autre !
|
Et c'est bien pour ca (comme on est tous d'accord que les deux écritures
sont équivalentes) qu'on se demande laquelle des deux est la plus lisible
(et c'est pas la peine de répondre "Mais on va pas se demander laquelle est
la plus lisible, puisqu'elles sont équivalentes")
| Quote: | Comment vider la poubelle de « v » ? La construction idiomatique est
(1) prends une poubelle vide -- vector<T>()
(2) échange-la avec celle de v -- .swap(v)
Le tout donne « vector<T>().swap(v) »
|
C'est ton point de vue... Moi je trouve ca plus lisible de procéder comme ca
:
(1) prends v
(2) vide le dans une poubelle vide
Justement parcequ'on parle plus souvent de v que de la poubelle vide (dont
on se fiche pas mal)
Et ca ca donne v.swap(vector<T>())
--
Vincent
|
|
| Back to top |
|
 |
Gabriel Dos Reis Guest
|
Posted: Sun Jul 11, 2004 11:35 am Post subject: Re: [Vider un std::vector<>] swap |
|
|
"Vincent Lascaux" <nospam (AT) nospam (DOT) org> writes:
| Quote: | | Mais je trouve tout de même que lorsque l'on a un objet A a
| modifier, et un objet B créé pour le modifier, plus clair d'écrire
|
| A.swap( B ) ;
|
| que
|
| B.swap( A ) ;
Mais, ils se modifient l'un et l'autre ! :-)
Et c'est bien pour ca (comme on est tous d'accord que les deux écritures
sont équivalentes) qu'on se demande laquelle des deux est la plus lisible
|
Non, ce n'est pas le propos initial. Il était
au lieu de :
v.swap( vector<T>() ) ;
qui semble plus naturel,
^^^^^^^
Ne déforme pas les propos en cours de discussion, cela pourrait se voir.
-- Gaby
|
|
| Back to top |
|
 |
|
|
You cannot post new topics in this forum You cannot reply to topics in this forum You cannot edit your posts in this forum You cannot delete your posts in this forum You cannot vote in polls in this forum
|
|