Twitter iPhone pliant OnePlus 11 PS5 Disney+ Orange Livebox Windows 11

clé ad-hoc pour un map

13 réponses
Avatar
heyji2
Bonjour,=20

Je suis en train de travailler sur des map dont j'ai d=E9fini la cl=E9 suiv=
ante.

class MRange
{
private:
char * a;
size_t s;
public:
MRange(void * a, size_t size);
friend bool operator(const MRange &left, const MRange &right) {
return (left.a + left.s <=3D right.a);}
};


=E7a m'a tout l'air de fonctionner comme attendu, notamment deux MRange "di=
ff=E9rent" du type MRange(0x0,10) et MRange(0x1,5) sont en fait consid=E9r=
=E9s comme =E9gaux (m=EAme cl=E9) dans le map suivant:=20

std::map<MRange,int> memory;

Ceci provient du fait que (et c'est l=E0 que je ne ma=EEtrise pas trop) l'o=
p=E9rateur =3D=3D est d=E9duit de la d=E9finition de l'op=E9rateur < (au mo=
ins dans le fonctionnement du map).=20

Ma question est donc la suivante: Que se passe-t-il si je red=E9finit l'op=
=E9rateur =3D=3D comme ci-dessous ? Cela risque-t-il de changer l'ordre de =
mon map ? Et si non, est-ce garanti ?

friend bool operator=3D=3D(const MRange & left, const MRange &right)
{
return ((left.a=3D=3Dright.a) && (left.s =3D=3D right.s))
}

Merci pour vos lumi=E8res.=20

AG.


=20

3 réponses

1 2
Avatar
heyji2
Le mardi 25 septembre 2012 13:01:02 UTC+2, Marc Boyer a écrit :

Sinon, quelle est l'autre objectif que tu n'as pas donné ?



Bon allez, je déballe parce que ça intéresse:

Je veux juste ranger dans un container des intervalles disjoints. Mais je v eux aussi pouvoir, lors de l'insertion d'un intervalle quelconque, vérifi er s'il recouvre un ou plusieurs intervalles déjà insérés auquel ca s il me faut retirer ces intervalles, calculer les intersections, construir e autant d'intervalles disjoints, puis réinsérer ces nouveaux intervall es.

Je ne connaissais pas les "arbres d'intervalle" d'Alain, peut être est-ce un cas particulier de ces conteneurs. Il faut que je regarde de plus prè s car ça pourrait m'éviter beaucoup de code.

@Alain: j'avais lu la doc sur les intervalles de Boost, et je n'y ai vu nu l part la mention "strict weak ordering". De fait, ça n'est pas possible car il faut que les intervalles soient disjoints. ils fournissent un compar ateur approchant, qui jette une exception lorsque la comparaison est indé cidable, mais ça n'est pas utilisable dans un map pour autant.
Avatar
Heyji
Le mardi 25 septembre 2012 11:17:09 UTC+2, Alain Ketterlin a écrit :
http://stackoverflow.com/questions/5407814/c-interval-tree-implementation
Il semble que Boost l'ait fait.
-- Alain.



Oui Alain, je crois que c'est exactement ce dont j'ai besoin: interval_map.

Merci beaucoup !
Avatar
Alain Ketterlin
writes:

Le mardi 25 septembre 2012 13:01:02 UTC+2, Marc Boyer a écrit :

Sinon, quelle est l'autre objectif que tu n'as pas donné ?



Je veux juste ranger dans un container des intervalles disjoints. Mais
je veux aussi pouvoir, lors de l'insertion d'un intervalle quelconque,
vérifier s'il recouvre un ou plusieurs intervalles déjà in sérés auquel
cas il me faut retirer ces intervalles, calculer les intersections,
construire autant d'intervalles disjoints, puis réinsérer ces n ouveaux
intervalles.



Pour le coup, c'est moi qui n'avais pas totalement compris.

Tu peux utiliser des arbres d'intervalle, mais c'est un peu dommage si
les intervalles sont vraiment disjoints : dans ce cas, la borne inf (ou
sup) suffit pour garder l'ordre, et tu peux utiliser (a.right <
b.left || b.right < a.left ) pour la comparaison.

Par contre, tu as une opération (qui n'est pas find) qui consiste à  
chercher tous les intervalles qui intersectent le nouveau[a,b]. Il doit
y avoir un moyen de faire ça avec lower_bound([-infini,b]) et
upper_bound([a,+infini]). Ensuite il faut traverser ce "range" et
tester. Je dis ça sans avoir vraiment réfléchi.

Je ne connaissais pas les "arbres d'intervalle" d'Alain, peut être
est-ce un cas particulier de ces conteneurs. Il faut que je regarde de
plus près car ça pourrait m'éviter beaucoup de code.



Je n'y suis pour rien :-)

@Alain: j'avais lu la doc sur les intervalles de Boost, et je n'y ai
vu nul part la mention "strict weak ordering". De fait, ça n'est pas
possible car il faut que les intervalles soient disjoints. ils
fournissent un comparateur approchant, qui jette une exception lorsque
la comparaison est indécidable, mais ça n'est pas utilisable da ns un
map pour autant.



C'est une notion utilisée par la STL (un concept), je ne suis pas sà »r
que tout le monde y fasse référence.

-- Alain.
1 2