Sens de const

Yoxoman wrote:

Où j'ai un problème,
c'est cette distinction entre « erase » et « remove ». Parce
qu'en fin de compte, list<>::erase() et list<>::remove font
exactement la même chose -- la seule différence, c'est dans leur
manière de choisir l'élément ou les éléments à enlever.

Ils ne font pas *exactement* la même chose, heureusement.

Et qu'est-ce qu'ils font de différent ? list<>::erase() ôte des
éléments de la liste. list<>::remove() ôte des éléments de la
liste. La seule différence, c'est la manière de désigner les
éléments.

Et cela peut justifier leur différence terminologique : dans
leurs actions, erase et remove ne s'appliquent pas à la même
structure.

Ils s'appliquent tous les deux à list<>. Obligatoire, en fin de
compte, parce qu'elles sont des fonctions membre.

De la même manière qu'on efface *le* tableau et qu'on enlève
*quelque chose sur le* tableau, list<>::erase s'applique à la
liste elle-même (ou à une de ses parties), tandis que
list<>::remove s'applique à ses éléments.

Toutes les deux s'appliquent aux list<>. Toutes les deux en
ôtent des éléments. Puisque les collections STL contiennent
toujours par valeur, tous les deux détruisent les éléments
qu'elles ôtent. AMHA, c'est un effet naturel de la contenance
par valeur (qui est elle un effet naturel de la façon que
travaille le C++), et pas une caractèristique sémantique
importante à signaler dans le nom. Mais de toute façon, elles
le font toutes les deux, de la même façon.

list<>::erase a une sémantique orientée ensemble : on invalide
une partie de la liste, en bloc.

list<>::remove a une sémantique orientée élément : on invalide
des éléments déterminés de l'ensemble "liste".

Toutes les deux ôte des éléments déterminés. Elles ne diffèrent
que dans la façon à désigner les éléments.

Et en passant... elles n'« invalide » pas les éléments ; elles
les ôtent carrément, en les enlevant et en les détruisant.

Et évidemment, le fait que std::remove() n'enlève rien.

Parce que les algorithmes n'en ont pas le droit.

C'est une restriction arbitraire:-).

En fait, c'est une restriction due à la structure de la
bibliothèque. Avec une autre structure, on pourrait imaginer
qu'un algorithme modifie la topologie de la suite -- les
collections de Java le font, par exemple.

Est-ce une bonne idée ? Je ne sais pas. La structure de OSE, par
exemple, le permettra techniquement, mais l'interface pour le
supporter n'a pas été prévue sur l'itérateur (en fait,
OTC_Modifier).

Mais l'action est tout de même comparable à celle de
list<>::remove, donc il peut sembler normal d'avoir le même
nom.

L'action de déplacer un objet dans une suite est comparable à
l'action de l'ôter de la suite ? Tu m'étonnes de plus en plus.

--
James Kanze GABI Software
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34

Yoxoman wrote:

Où j'ai un problème,
c'est cette distinction entre « erase » et « remove ». Parce
qu'en fin de compte, list<>::erase() et list<>::remove font
exactement la même chose -- la seule différence, c'est dans leur
manière de choisir l'élément ou les éléments à enlever.

Ils ne font pas *exactement* la même chose, heureusement.

Et qu'est-ce qu'ils font de différent ? list<>::erase() ôte des
éléments de la liste. list<>::remove() ôte des éléments de la
liste. La seule différence, c'est la manière de désigner les
éléments.

Nicolas Sarkozy et Olivier Besancenot font exactement la même chose : de
la politique.

Tout dépend du degré de précision que tu donnes à la *chose*. Pour moi,
il y a une différence entre ôter des éléments déterminés (au sens où
*je* détermine), et ôter des éléments qui correspondent à une partie
déterminée de la liste.

Et cela peut justifier leur différence terminologique : dans
leurs actions, erase et remove ne s'appliquent pas à la même
structure.

Ils s'appliquent tous les deux à list<>. Obligatoire, en fin de
compte, parce qu'elles sont des fonctions membre.

J'avais remarqué, merci. Ce que je veux dire, c'est que list<>::erase
s'oriente (sémantiquement) vers la liste elle-même, tandis que list
<>::remove s'oriente (sémantiquement) vers les éléments de la liste.

Et je trouve que ça correspond bien avec la différence de niveau
auxquels s'appliquent les termes effacer et enlever.

L'action d'effacer quelque chose se base sur ce quelque chose et
s'applique au contenu de ce quelque chose, alors que l'action d'enlever
quelque chose se base sur ce quelque chose et s'applique à ce quelque
chose lui-même.

Ce qui donne :

list<>::erase se base sur une partie de la liste et s'applique à son
contenu (ses éléments, qu'il ôte), alors que list<>::remove se base sur
des éléments déterminés (par moi) de la liste, et s'applique sur ces
éléments eux-mêmes (il les ôte).

C'est mon point de vue, et j'espère être clair. Je trouve que ça
justifie leur différence terminologique. C'est tout ce que je voulais
dire.

list<>::erase a une sémantique orientée ensemble : on invalide
une partie de la liste, en bloc.

list<>::remove a une sémantique orientée élément : on invalide
des éléments déterminés de l'ensemble "liste".

Toutes les deux ôte des éléments déterminés. Elles ne diffèrent
que dans la façon à désigner les éléments.

Déterminés par qui ? Dans list<>::erase, je ne détermine pas les
éléments à ôter. Par contre, je détermine la partie de la liste dont je
veux ôter les éléments.

Et en passant... elles n'« invalide » pas les éléments ; elles
les ôtent carrément, en les enlevant et en les détruisant.

Si tu veux.

Mais l'action est tout de même comparable à celle de
list<>::remove, donc il peut sembler normal d'avoir le même
nom.

L'action de déplacer un objet dans une suite est comparable à
l'action de l'ôter de la suite ? Tu m'étonnes de plus en plus.

Si les actions se résument pour toi à *ôter* et *déplacer*, non. C'est
bien sûr ailleurs qu'elles se comparent.

#include <iostream>
#include <list>
#include <iterator>

int main()
{
std::list<int> l;
typedef std::list<int>::iterator list_iter;

l.push_back(1);
l.push_back(2);
l.push_back(3);
l.push_back(2);

//l.remove(2); (1)
//list_iter it = std::remove(l.begin(), l.end(), 2); (2)

std::copy(l.begin(), l.end(),
std::ostream_iterator<int>(std::cout, " "));
}

avec (1), on obtient 1 3.
avec (2), on obtient 1 3 3 2, it désigne le troisième élément, et donc
la plage [l.begin(), it), c'est 1 3.

Je trouve ça comparable. Si ça t'étonne, tant pis.

--
"Yo!"
Martin Heidegger

Yoxoman wrote:

Yoxoman wrote:

Où j'ai un problème, c'est cette distinction entre «
erase » et « remove ». Parce qu'en fin de compte,
list<>::erase() et list<>::remove font exactement la
même chose -- la seule différence, c'est dans leur
manière de choisir l'élément ou les éléments à enlever.

Ils ne font pas *exactement* la même chose, heureusement.

Et qu'est-ce qu'ils font de différent ? list<>::erase() ôte
des éléments de la liste. list<>::remove() ôte des éléments
de la liste. La seule différence, c'est la manière de
désigner les éléments.

Nicolas Sarkozy et Olivier Besancenot font exactement la même
chose : de la politique.

Tout dépend du degré de précision que tu donnes à la *chose*.
Pour moi, il y a une différence entre ôter des éléments
déterminés (au sens où *je* détermine), et ôter des éléments
qui correspondent à une partie déterminée de la liste.

On ôte des éléments déterminés dans les deux cas. La seule
différence, c'est dans la manière de les déterminer. Or, au
moins en anglais, les mots « remove » et « erase » n'ont aucun
rapport avec la manière de choisir ce qui est enlevé ou ce qui
est effacé.

(Si on voulait chercher plus loin, on dirait que « remove »
enleve l'élément complétement, tandis qu'« erase » ne fait que
l'effacer, en laissant le support. C-à-d qu'« erase » appelerait
le destructeur, mais ne libèrerait pas la mémoire. Mais il ne
faut pas exagérer.)

Mais en fin de compte, tu as esquivé la question : en quoi
est-ce que ces deux opérations diffèrent ? Qu'est-ce qu'ils font
de différent pour justifier un nom différent ?

Et cela peut justifier leur différence terminologique :
dans leurs actions, erase et remove ne s'appliquent pas à
la même structure.

Ils s'appliquent tous les deux à list<>. Obligatoire, en fin
de compte, parce qu'elles sont des fonctions membre.

J'avais remarqué, merci. Ce que je veux dire, c'est que
list<>::erase s'oriente (sémantiquement) vers la liste
elle-même, tandis que list <>::remove s'oriente
(sémantiquement) vers les éléments de la liste.

Ce qui veut dire quoi ? Tous les deux s'appliquent à une liste.
Tous les deux enlèvent des éléments de la liste, et donc
travaillent sur des éléments. (Si tu régardes l'implémentation,
tu verras probablement que tous les deux font appel à la même
fonction interne.)

Et je trouve que ça correspond bien avec la différence de
niveau auxquels s'appliquent les termes effacer et enlever.

Mais selon quel critère ? Tous les deux sont des verbes
transitifs, dont l'objet direct, ici, est l'élément. Si je
regarde le TLFI, effacer est « faire disparaître » ; une des
définitions de « enlever », c'est « Déplacer un objet en le
sortant de l'endroit qu'il occupe [...] en l'effaçant, en le
supprimant ».

Dans le contexte ici, je crois qu'on peut dire qu'« enlever » a
la signification donnée en paragraphe II.C du TLFI. Où le
premier exemple est « enlever un nom d'une liste [...] ». Ce qui
est exactement ce que fait list<>::erase() (et list<>::remove(),
évidemment, vue que les deux font la même chose).

Dans le cas d'« effacer », on n'est amené à considérer que les
significations du paragraphe I.A. (§II couvre les emplois
pronominaux, et §I.B les significations « Empêcher de
paraître@», qui ne me semble pas convenir non plus.) Or, parmi
les utilisations dans §I.A, la seule qui semblerait permise ici
est §I.A.1.b : « Éliminer, faire disparaître (quelque chose) ».
Et là non plus, pas le moindre soupçon que les critères de choix
de ce qu'on élimine entre en ligne de compte.

En somme, ta distinction d'« orientation » ne trouve pas de
justification dans la langue telle qu'elle s'emploie
généralement.

L'action d'effacer quelque chose se base sur ce quelque chose
et s'applique au contenu de ce quelque chose, alors que
l'action d'enlever quelque chose se base sur ce quelque chose
et s'applique à ce quelque chose lui-même.

Ce qui donne :

list<>::erase se base sur une partie de la liste et s'applique
à son contenu (ses éléments, qu'il ôte), alors que
list<>::remove se base sur des éléments déterminés (par moi)
de la liste, et s'applique sur ces éléments eux-mêmes (il les
ôte).

C'est moi qui détermine les éléments à enlever. Dans les deux
cas. Les deux fonctions s'applique à la liste, et enlever les
éléments -- évidemment (ou heureusement), elles opèrent aussi
sur les éléments : elles en appellent le destructeur, en libère
la mémoire, etc.

C'est mon point de vue, et j'espère être clair.

C'est ton point de vue, mais d'une part, je ne vois toujours pas
la différence que tu sembles y voir, et de l'autre, ton
utilisation des mots « effacer » et « enlever » ne correspond
pas à ce que décrit le TLFI.

Je trouve que ça justifie leur différence terminologique.
C'est tout ce que je voulais dire.

Mais pour ça, il faut que tu donnes aux mots une signification
qu'ils n'ont pas.

Il y a une différence dans les deux fonctions : la façon qu'on
désigne ce qui est à enlever. Ça, je crois que personne ne le
dispute. Mais ni « remove » ni « erase » ne contient la moindre
nuace à cet égard -- dans ce cas-ci, le choix d'un ou de l'autre
relève d'un goût personel, et l'un ou l'autre ferait également
bien l'affaire. C'est simplement l'utilisation des deux comme
synonymes qui me gène.

(En fait, quand j'ai écrit ma propre classe de liste, tout au
début, mon premier choix de nom pour cette fonction était
delete. C'est un mot technique, très précis. Mais le compilateur
n'était pas d'accord à ce que je l'utilise.)

list<>::erase a une sémantique orientée ensemble : on
invalide une partie de la liste, en bloc.

list<>::remove a une sémantique orientée élément : on
invalide des éléments déterminés de l'ensemble "liste".

Toutes les deux ôte des éléments déterminés. Elles ne
diffèrent que dans la façon à désigner les éléments.

Déterminés par qui ?

Par l'utilisateur. Dans tous les cas. Une fonction où c'est la
liste même qui détermine ce qu'elle veut enlever ne serait pas
particulièrement intéressante.

Dans list<>::erase, je ne détermine pas les éléments à ôter.

Bien sûr que si. C'est bien toi qui fournis l'itérateur ou les
itérateurs.

Par contre, je détermine la partie de la liste dont je veux
ôter les éléments.

Tout à fait. De même que dans le cas de list<>::remove(), c'est
moi qui détermine la condition d'effacement.

La chose qui diffère, ce n'est pas qui fait le choix, mais
comment on précise ce choix.

Mais l'action est tout de même comparable à celle de
list<>::remove, donc il peut sembler normal d'avoir le
même nom.

L'action de déplacer un objet dans une suite est comparable
à l'action de l'ôter de la suite ? Tu m'étonnes de plus en
plus.

Si les actions se résument pour toi à *ôter* et *déplacer*,
non.

Quelles sont les autres actions en question ?

En fait, il y a une signification de « remove » qui pourrait
convenir -- quelque chose du genre « he removed the elements to
the end of the sequence » est compréhensible en anglais. Mais il
lève la question : d'où ? (Je me rabats sur l'anglais et « The
American Heritage Dictionary » ici, parce qu'enlever et remove
ne sont pas tout à fait identiques dans leurs significations.)

Mais la première signification rest « To move from a place or
postion occupied », avec comme exemple « removed the cups from
the table ». Ici, la seule « place or position occupied » dont
il peut être question, c'est bien la suite. (Il y a aussi une
signification « to do away with; eliminate », qui pourrait
convenir dans son emploi dans list<>::remove.)

C'est bien sûr ailleurs qu'elles se comparent.

#include <iostream>
#include <list>
#include <iterator>

int main()
{
std::list<int> l;
typedef std::list<int>::iterator list_iter;

l.push_back(1);
l.push_back(2);
l.push_back(3);
l.push_back(2);

//l.remove(2); (1)
//list_iter it = std::remove(l.begin(), l.end(), 2); (2)

std::copy(l.begin(), l.end(),
std::ostream_iterator<int>(std::cout, " "));
}

avec (1), on obtient 1 3.
avec (2), on obtient 1 3 3 2, it désigne le troisième élément, e t donc
la plage [l.begin(), it), c'est 1 3.

Je trouve ça comparable. Si ça t'étonne, tant pis.

On peut les utiliser pour atteindre les mêmes fins, dans certains
cas. C'est loin de signifier qu'elles font la même chose.

--
James Kanze GABI Software
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34

Tout dépend du degré de précision que tu donnes à la *chose*.
Pour moi, il y a une différence entre ôter des éléments
déterminés (au sens où *je* détermine), et ôter des éléments
qui correspondent à une partie déterminée de la liste.

On ôte des éléments déterminés dans les deux cas.

Je ne suis pas d'accord. On peut chipoter sur le sens du verbe
"déterminer", mais je pense qu'en appliquant list<>::erase sur une
partie d'une centaine de termes, on ne determine pas les éléments en
question.

La seule
différence, c'est dans la manière de les déterminer. Or, au
moins en anglais, les mots « remove » et « erase » n'ont aucun
rapport avec la manière de choisir ce qui est enlevé ou ce qui
est effacé.
(Si on voulait chercher plus loin, on dirait que « remove »
enleve l'élément complétement, tandis qu'« erase » ne fait que
l'effacer, en laissant le support. C-à-d qu'« erase » appelerait
le destructeur, mais ne libèrerait pas la mémoire. Mais il ne
faut pas exagérer.)

Bof.

Mais en fin de compte, tu as esquivé la question : en quoi
est-ce que ces deux opérations diffèrent ? Qu'est-ce qu'ils font
de différent pour justifier un nom différent ?

?

-- A la question "en quoi est-ce que les deux opérations diffèrent ?" :

* D'un point de vue sémantique, je ne vois pas ce que je peux dire de
plus que ce que j'ai déjà dit.

Les concepteurs de la STL ont fait de choix d'utiliser le terme "erase"
pour désigner une fonction qui efface une partie *déterminée* (par
l'utilisateur) d'une liste (singleton, intervalle). L'utilisateur
regarde sa liste, et, s'il a besoin d'en ôter un bloc, il se dit : je
vais utiliser "erase". Ca tombe bien (choix ou hasard, mystère), le
terme "erase", dans le langage courant, peut s'appliquer sur ce type de
structure. En effet, on dit bien "erase the blackboard". Alors qu'on ne
dirait pas "remove the blackboard", sauf pour signifier autre chose.
(désolé pour le blackboard, je ne suis pas bilingue, mais je suppose que
ça s'applique à toute surface sur laquelle on peut marquer quelque
chose).

D'un autre côté, ils ont fait le choix d'utiliser le terme "remove" pour
désigner une fonction qui efface tous les éléments que l'utilisateur
*détermine*. L'utilisateur regarde sa liste, et, s'il a besoin d'ôter
des éléments particuliers, il se dit : je vais utiliser "remove".

* D'un point de vue pratique, par exemple :

Soit le problème suivant : on a une liste d'entiers. Ecrire une
fonction qui ôte de la liste tous les éléments qui sont après le premier
zéro (celui-ci compris) de la liste, s'il existe.

Voici ce que ma très modeste compétence en C++ me permet de faire :

#include <iostream>
#include <list>
#include <iterator>

void erase_after_zero(std::list<int>& l)
{
typedef std::list<int>::iterator list_iter;

list_iter it = std::find(l.begin(), l.end(), 0);
if (it != l.end()) {
l.erase(it, l.end());
}
}

// test
int main()
{
std::list<int> l;

l.push_back(2);
l.push_back(0);
l.push_back(1);
l.push_back(2);

erase_after_zero(l);

std::copy(l.begin(), l.end(),
std::ostream_iterator<int>(std::cout, " "));
}

Qui affiche 2. OK.

Tu fais comment, avec list<>::remove ?

-- A la question "qu'est-ce qui justifie un nom différent ?" :

La différence sémantique.

Pourquoi ne pas avoir gardé le terme "erase" pour list<>::remove, ou
l'inverse ? Peut-être pour appuyer sur la différence sémantique entre
les deux fonctions (partie déterminée <-> valeur déterminée).

Aurait-on pu echanger les deux noms ? Bof. Le terme "erase" s'applique
bien à la fonction list<>::erase, car ils suggèrent tous deux une
dualité surface <-> marquage, ou ensemble <-> élément : effacer une
surface, et hop le marquage disparait ; list<>::erase une partie de la
liste, et hop les éléments disparaissent.
Pour list<>::remove, on n'a pas besoin de cette dualité. On a juste des
éléments, et on retire ceux d'une certaine forme.

J'avais remarqué, merci. Ce que je veux dire, c'est que
list<>::erase s'oriente (sémantiquement) vers la liste
elle-même, tandis que list <>::remove s'oriente
(sémantiquement) vers les éléments de la liste.

Ce qui veut dire quoi ? Tous les deux s'appliquent à une liste.

Au niveau C++, oui. Mais tout ce que ça, ça signifie, c'est que les
fonction sont dans la même portée.

[...]

Et je trouve que ça correspond bien avec la différence de
niveau auxquels s'appliquent les termes effacer et enlever.

Mais selon quel critère ? Tous les deux sont des verbes
transitifs, dont l'objet direct, ici, est l'élément. Si je
regarde le TLFI, effacer est « faire disparaître » ;

Je dois dire ici que je suis parti sur une mauvaise définition de
"effacer". Pour d'obscures raisons, j'ai pensé que la définition
première du terme s'appliquait à une surface dont on faisait disparaitre
les marques (pour reprendre les mots du TLFI). Par exemple : "effacer le
tableau". Alors que la définition exacte voudrait apparemment qu'on
écrive "effacer *ce qu'il y a sur* le tableau". Je remarque que ce
racourci n'apparait même pas la définition. Soit.

Cependant, l'abus reste valable, et au cas où tu n'aurais pas compris,
c'est sur celui-ci que je me base. Tu as d'ailleurs fait mention d'un
"erase the blackboard" dans un post précédent, si je ne m'abuse. Tu
conviendra sans doute qu'il n'a pas le même sens qu'un "remove the
blackboard", qu'il faudrait transformer en "remove *all that is on* the
blackboard".

L'abus est classique. Par exemple, sur le lien

http://www.sgi.com/tech/stl/List.html

au niveau de list<>::erase avec comme argument deux itérateurs, on lit
bien "Erases the range [first, last)", et non "Erases the elements in
the range [first, last)".

une des
définitions de « enlever », c'est « Déplacer un objet en le
sortant de l'endroit qu'il occupe [...] en l'effaçant, en le
supprimant ».
Dans le contexte ici, je crois qu'on peut dire qu'« enlever » a
la signification donnée en paragraphe II.C du TLFI. Où le
premier exemple est « enlever un nom d'une liste [...] ». Ce qui
est exactement ce que fait list<>::erase()

Non. Si le nom apparait plusieurs fois, un appel à cette fonction ne
marchera pas. Il faudrait plusieurs appels, ce qui n'a plus de sens.

(et list<>::remove(),
évidemment, vue que les deux font la même chose).

Ca n'engage que toi.

Dans le cas d'« effacer », on n'est amené à considérer que les
significations du paragraphe I.A. (§II couvre les emplois
pronominaux, et §I.B les significations « Empêcher de
paraître@», qui ne me semble pas convenir non plus.) Or, parmi
les utilisations dans §I.A, la seule qui semblerait permise ici
est §I.A.1.b : « Éliminer, faire disparaître (quelque chose) ».
Et là non plus, pas le moindre soupçon que les critères de choix
de ce qu'on élimine entre en ligne de compte.

Moi, je choisirais la première (I.A.1.a) : "faire disparaitre totalement
(ce qui est tracé ou marqué sur une surface)". Parce que la partie entre
parenthèses fait apparaitre cette dualité entre ensemble (la surface) et
les éléments (les marques). C'est celle qui permet l'abus "effacer une
feuille", "effacer un mur"...

En somme, ta distinction d'« orientation » ne trouve pas de
justification dans la langue telle qu'elle s'emploie
généralement.

Si. Pas dans sa définition exacte, mais dans des abus courants.
N'emploie-t-on pas généralement l'expression "effacer le
tableau" ?

L'action d'effacer quelque chose se base sur ce quelque chose
et s'applique au contenu de ce quelque chose, alors que
l'action d'enlever quelque chose se base sur ce quelque chose
et s'applique à ce quelque chose lui-même.

Ce qui donne :

list<>::erase se base sur une partie de la liste et s'applique
à son contenu (ses éléments, qu'il ôte), alors que
list<>::remove se base sur des éléments déterminés (par moi)
de la liste, et s'applique sur ces éléments eux-mêmes (il les
ôte).

C'est moi qui détermine les éléments à enlever. Dans les deux
cas.

Pas d'accord.

[...]

Je trouve que ça justifie leur différence terminologique.
C'est tout ce que je voulais dire.

Mais pour ça, il faut que tu donnes aux mots une signification
qu'ils n'ont pas.

...dans le dictionnaire. Bien que je serais étonné qu'aucun
dictionnaire n'en fasse mention.

[...]

Déterminés par qui ?

Par l'utilisateur. Dans tous les cas. Une fonction où c'est la
liste même qui détermine ce qu'elle veut enlever ne serait pas
particulièrement intéressante.

Pas besoin de déterminer un élément pour l'enlever.

Dans list<>::erase, je ne détermine pas les éléments à ôter.

Bien sûr que si. C'est bien toi qui fournis l'itérateur ou les
itérateurs.

Et les itérateurs correspondent à une position. Ce que je determine,
c'est la position, pas ce qui se trouve à cette position, que je le
sache ou non.

[...]

Si les actions se résument pour toi à *ôter* et *déplacer*,
non.

Quelles sont les autres actions en question ?

Je ne dis pas qu'il y a d'autres actions, je dis que les actions ne se
résument pas *forcément* à "ôter" et "déplacer".

Ton "ôter" pourrait devenir "ôter les éléments qui correspondent à une
certaine valeur", et ton "déplacer" pourrait devenir "remplacer les
éléments de telle sorte que la liste tronquée à un intervalle commençant
par begin() corresponde à celle qu'on aurait construit en ôtant les
éléments qui correspondent à une certaine valeur. Conserver la valeur
des éléments qui sont en dehors de l'intervalle" (j'ai pas trouvé mieux,
désolé).

Du coup, ça devient comparable.

Au fait, je ne comprend pas ton emploi du terme "déplacer" pour
std::remove.

[...]

Je trouve ça comparable. Si ça t'étonne, tant pis.

On peut les utiliser pour atteindre les mêmes fins, dans certains
cas. C'est loin de signifier qu'elles font la même chose.

Qui a dit qu'elles faisaient la même chose ? Moi, j'ai dit qu'elles
étaient comparables.

--
"Yo!"
Martin Heidegger