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.
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.
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
Fabien LE LEZ
On Sat, 10 Jul 2004 14:00:05 +0200, drkm :
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 ?
On Sat, 10 Jul 2004 14:00:05 +0200, drkm <usenet.fclcxx@fgeorges.org>:
Mais
il me semble que 25.2.2/2 répond à ta question.
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 ?
drkm
Fabien LE LEZ writes:
On Sat, 10 Jul 2004 14:00:05 +0200, drkm :
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
Fabien LE LEZ <gramster@gramster.com> writes:
On Sat, 10 Jul 2004 14:00:05 +0200, drkm <usenet.fclcxx@fgeorges.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é.
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
drkm
drkm writes:
Fabien LE LEZ writes:
On Sat, 10 Jul 2004 14:00:05 +0200, drkm :
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
drkm <usenet.fclcxx@fgeorges.org> writes:
Fabien LE LEZ <gramster@gramster.com> writes:
On Sat, 10 Jul 2004 14:00:05 +0200, drkm <usenet.fclcxx@fgeorges.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.
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
Gabriel Dos Reis
drkm writes:
| 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 ?
| puisque l'on veut agir sur v.
C'est bien ce que fait la première version -- swap(v). ;-)
-- Gaby
drkm <usenet.fclcxx@fgeorges.org> writes:
| 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 ?
| puisque l'on veut agir sur v.
C'est bien ce que fait la première version -- swap(v). ;-)
| 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 ?
| puisque l'on veut agir sur v.
C'est bien ce que fait la première version -- swap(v). ;-)
-- Gaby
Vincent Lascaux
| 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)
| 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)
| 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)
Gabriel Dos Reis
"Vincent Lascaux" writes:
| > | 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.
| Je lis vector<T>().swap comme "vide" dans la premiere écriture
Là tu ne lis pas, tu épelles. C'est différent.
-- Gaby
"Vincent Lascaux" <nospam@nospam.org> writes:
| > | 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.
| Je lis vector<T>().swap comme "vide" dans la premiere écriture
| > | 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.
| Je lis vector<T>().swap comme "vide" dans la premiere écriture
Là tu ne lis pas, tu épelles. C'est différent.
-- Gaby
Franck Branjonneau
"Vincent Lascaux" écrivait:
| 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.
"Vincent Lascaux" <nospam@nospam.org> écrivait:
| 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.
| 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.
drkm
"Vincent Lascaux" writes:
| DR 101. Pourquoi :
| vector<T>().swap( v ) ;
| au lieu de :
| v.swap( vector<T>() ) ;
| qui semble plus naturel,
Vraiment ?
Oui.
| puisque l'on veut agir sur v.
C'est bien ce que fait la première version -- swap(v). ;-)
Oui.
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
"Vincent Lascaux" <nospam@nospam.org> writes:
| DR 101. Pourquoi :
| vector<T>().swap( v ) ;
| au lieu de :
| v.swap( vector<T>() ) ;
| qui semble plus naturel,
Vraiment ?
Oui.
| puisque l'on veut agir sur v.
C'est bien ce que fait la première version -- swap(v). ;-)
Oui.
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.
C'est bien ce que fait la première version -- swap(v). ;-)
Oui.
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.
