Bonjour,

J'ai cherché des justifications au fait que cette surcharge n'existe
pas. Et je n'en ai pas trouvé, hormis le fait que l'inexistance de la
clé entraîne l'ajout d'une paire dans la map.

Pourquoi ?
Existe-t-il une méthode élégante pour contourner ce manque ?
Peut-être que je me trompe dans mon interprétation de ce qu'est une
map, et que donc je n'utilises pas le bon outil ?

Merci
--
Mickaël Wolff aka Lupus Michaelis
http://lupusmic.org

Mickaël Wolff <mickael.wolff@laposte.net> writes:

> Bonjour,
>
> J'ai cherché des justifications au fait que cette surcharge n'existe
> pas. Et je n'en ai pas trouvé, hormis le fait que l'inexistance de la
> clé entraîne l'ajout d'une paire dans la map.
>
> Pourquoi ?

Parce que l'inexistance de la clé entraîne l'ajout d'une paire dans
la map.


> Existe-t-il une méthode élégante pour contourner ce manque ?

Tu peux utiliser map::find.


> Peut-être que je me trompe dans mon interprétation de ce qu'est une
> map, et que donc je n'utilises pas le bon outil ?

Je ne sais pas, c'est quoi pour toi une map?


--
__Pascal Bourguignon__ http://www.informatimago.com/

Pour moi, la grande question n'a jamais été: «Qui suis-je? Où vais-je?»
comme l'a formulé si adroitement notre ami Pascal, mais plutôt:
«Comment vais-je m'en tirer?» -- Jean Yanne

Mickaël Wolff <mickael.wolff@laposte.net> writes:

| Bonjour,
|
| J'ai cherché des justifications au fait que cette surcharge n'existe
| pas. Et je n'en ai pas trouvé, hormis le fait que l'inexistance de la
| clé entraîne l'ajout d'une paire dans la map.
|
| Pourquoi ?

operator[] est défini en terme de recherche+insertion.

-- Gaby

Si on ne veut pas que l'inexistence entraine l'ajout de la clé, qu'est
ce qui sera retourné si on fait un accès et que la clé demandée n'est
pas présente? Ce n'est pas possible.
Du coup, l'ajout est obligatoire, et on ne peut pas fournir d'opérateur
en const
> Bonjour,
>
> J'ai cherché des justifications au fait que cette surcharge n'existe
> pas. Et je n'en ai pas trouvé, hormis le fait que l'inexistance de la
> clé entraîne l'ajout d'une paire dans la map.
>
> Pourquoi ?
> Existe-t-il une méthode élégante pour contourner ce manque ?
> Peut-être que je me trompe dans mon interprétation de ce qu'est une
> map, et que donc je n'utilises pas le bon outil ?
>
> Merci
>

Pascal Bourguignon a écrit :

> Parce que l'inexistance de la clé entraîne l'ajout d'une paire dans
> la map.

Certes, mais pourquoi ajouter une paire ? Pourquoi ne pas lancer une
exception ?

>> Existe-t-il une méthode élégante pour contourner ce manque ?
>
> Tu peux utiliser map::find.

Non, j'ai essayé. il n'y a pas de map::find const

> Je ne sais pas, c'est quoi pour toi une map?

Je le prenais comme un tableau associatif, qui renvoie une valeur pour
une clé associée à une valeur

--
Mickaël Wolff aka Lupus Michaelis
http://lupusmic.org

On Mon, 21 Apr 2008 02:53:09 +0200, Mickaël Wolff :

> Certes, mais pourquoi ajouter une paire ? Pourquoi ne pas lancer une
>exception ?

L'opérateur non-const [] ajoute une paire si nécessaire, pour qu'on
puisse écrire :

map<int,int> m;
m[3]= 5;

Une conséquence immédiate (et peut-être malheureuse) est que le code
ci-dessous ajoute également une paire dans le map<> :

map<int,int> m;
cout << m[4];

En C++, le mot-clé "const" sert avant tout à avoir un message d'erreur
(à la compilation) si on modifie un élément qui, logiquement, n'a pas
à être modifié. En particulier, l'ajout ou le retrait d'un "const"
(tout comme de "public"/"private") ne devrait pas changer sensiblement
le comportement du programme.

Ainsi, si j'écris

map<int,int> m const;
cout << m[4];

j'ai une erreur à la compilation. C'est logique, map:perator[] n'a
pas été prévu pour être utilisé comme ça.
Si, par l'ajout du "const", le comportement du programme avait été
silencieusement modifié, avec à la clé une exception lancée de temps
en temps, ce serait un cauchemar pour le programmeur.

On Mon, 21 Apr 2008 02:53:09 +0200, Mickaël Wolff
<mickael.wolff@laposte.net>:

> Non, j'ai essayé. il n'y a pas de map::find const

Bien sûr que si, heureusement !
Tu dois même pouvoir écrire quelque chose comme ça :

template <class Cle, class Valeur, class Less>
Valeur GetDansMap (std::map <Cle, Valeur, Less> const& map_,
Cle const& cle, Valeur const& valeur_par_defaut= Valeur())
{
typename std::map <Cle, Valeur, Less>::const_iterator
it= map_.find (cle);
if (it == map_.end())
{
return valeur_par_defaut;
}
else
{
return (*it).second;
}
}

ou bien :

template <class Cle, class Valeur, class Less>
Valeur GetDansMap (std::map <Cle, Valeur, Less> const& map_,
Cle const& cle)
{
typename std::map <Cle, Valeur, Less>::const_iterator
it= map_.find (cle);
if (it == map_.end())
{
throw quelque_chose;
}
else
{
return (*it).second;
}
}



Tu peux aussi écrire ton propre map :


template <class Cle, class Valeur> class MonMap
{
public:
void Set (Cle const& cle, Valeur const& valeur)
{ data[cle]= valeur; }

Valeur const& Get (Cle const& cle) const
{
Data::const_iterator it= data.find (cle);
if (it == data.end())
{
throw quelque_chose;
}
return (*it).second;
}

Valeur const& operator[] (Cle const& cle) const
{ return Get(cle); }

private:
typedef typename std::map<Cle,Valeur> Data;
Data data;
};

Mickaël Wolff <mickael.wolff@laposte.net> writes:

| Pascal Bourguignon a écrit :
|
| > Parce que l'inexistance de la clé entraîne l'ajout d'une paire dans
| > la map.
|
| Certes, mais pourquoi ajouter une paire ? Pourquoi ne pas lancer une
| exception ?

Peux-tu montrer le genre de codes typiques que tu écrirais avec ça ?
Pourquoi cela est-il meilleur qu'utiliser find() ou binary_search() ?

-- Gaby