replace dans une map

Le
pokalimon
j ai besoin d utiliser l algorithm replace dans une map <int,string> M
mais je n arrive pas
sachant que la syntaxe de replace est

template < class ForwardIterator, class T >
void replace ( ForwardIterator first, ForwardIterator last,
const T& old_value, const T& new_value );
Vidéos High-Tech et Jeu Vidéo
Téléchargements
Vos réponses
Gagnez chaque mois un abonnement Premium avec GNT : Inscrivez-vous !
Trier par : date / pertinence
James Kanze
Le #306774
On May 2, 6:32 pm, wrote:
j ai besoin d utiliser l algorithm replace dans une map <int,string> M
mais je n arrive pas
sachant que la syntaxe de replace est

template < class ForwardIterator, class T >
void replace ( ForwardIterator first, ForwardIterator last,
const T& old_value, const T& new_value );


Tu ne peut pas ; replace exige que le « value_type » de
l'itérateur soit affectable, qui n'est pas le cas des itérateurs
d'un map. En fait, tous les algorithmes dans §25.2 exige qu'une
expression du genre « *i = x » soit légale, ce qui n'est pas
le cas pour les itérateurs d'un map (qui ont un « value_type »
de « std::pair< Key const, T > », et qui ne peuvent donc pas
être affecté).

--
James Kanze (GABI Software) email:
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

pokalimon
Le #306770
On 3 mai, 07:56, James Kanze
On May 2, 6:32 pm, wrote:

j ai besoin d utiliser l algorithm replace dans une map <int,string> M
mais je n arrive pas
sachant que la syntaxe de replace est
template < class ForwardIterator, class T >
void replace ( ForwardIterator first, ForwardIterator last,
const T& old_value, const T& new_value );


Tu ne peut pas ; replace exige que le « value_type » de
l'itérateur soit affectable, qui n'est pas le cas des itérateurs
d'un map. En fait, tous les algorithmes dans §25.2 exige qu'une
expression du genre « *i = x » soit légale, ce qui n'est pas
le cas pour les itérateurs d'un map (qui ont un « value_type »
de « std::pair< Key const, T > », et qui ne peuvent donc pas
être affecté).

--
James Kanze (GABI Software) email:
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



alors est ce qu on peut utiliser l algorithm replace_if si on definit
l operateur d affectation pour les pair<int,string>
merci de votre aide


pokalimon
Le #306768
On 3 mai, 16:01, wrote:
On 3 mai, 07:56, James Kanze


On May 2, 6:32 pm, wrote:

j ai besoin d utiliser l algorithm replace dans une map <int,string> M
mais je n arrive pas
sachant que la syntaxe de replace est
template < class ForwardIterator, class T >
void replace ( ForwardIterator first, ForwardIterator last,
const T& old_value, const T& new_value );


Tu ne peut pas ; replace exige que le « value_type » de
l'itérateur soit affectable, qui n'est pas le cas des itérateurs
d'un map. En fait, tous les algorithmes dans §25.2 exige qu'une
expression du genre « *i = x » soit légale, ce qui n'est pas
le cas pour les itérateurs d'un map (qui ont un « value_type »
de « std::pair< Key const, T > », et qui ne peuvent donc pas
être affecté).

--
James Kanze (GABI Software) email:
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


alors est ce qu on peut utiliser l algorithm replace_if si on definit
l operateur d affectation pour les pair<int,string>
merci de votre aide


de plus le value_type d une map est un pair<int,string> or si on
declare deux paires p1 et p2 alors on peut bien faire une opperation d
affectation
p1=p2; marche parfaitement alors c est affectable



James Kanze
Le #306766
On May 3, 5:01 pm, wrote:
On 3 mai, 07:56, James Kanze
On May 2, 6:32 pm, wrote:

j ai besoin d utiliser l algorithm replace dans une map <int,string> M
mais je n arrive pas
sachant que la syntaxe de replace est
template < class ForwardIterator, class T >
void replace ( ForwardIterator first, ForwardIterator last,
const T& old_value, const T& new_value );


Tu ne peut pas ; replace exige que le « value_type » de
l'itérateur soit affectable, qui n'est pas le cas des itérateurs
d'un map. En fait, tous les algorithmes dans §25.2 exige qu'une
expression du genre « *i = x » soit légale, ce qui n'est pas
le cas pour les itérateurs d'un map (qui ont un « value_type »
de « std::pair< Key const, T > », et qui ne peuvent donc pas
être affecté).


alors est ce qu on peut utiliser l algorithm replace_if si on definit
l operateur d affectation pour les pair<int,string>


Pour quoi faire ? L'affectation des std::pair est déjà définie,
et il n'y a aucun problème à faire replace_if sur une *séquence*
de std::pair<int,std::string>. Mais le value_type de
std::map<int,std::string>, c'est std::pair<int const,
std::string >, et ce const fait que l'affectation n'est pas
supportée.

La raison pour déclarée le value_type avec un premier élément
const, et ne pas en supporter l'affectation, est évident.
std::map garde ses éléments dans un ordre bien précis, et si tu
modifie le premier élément, l'ordre serait perturbé.

Si tu veux changer que les valeurs mappées, tu peux le faire
avec quelque chose du genre :

template< typename T >
class ReplaceSecond
{
public:
ReplaceSecond( T a, T b )
: myOld( a )
, myNew( b )
{
}

template< typename U >
void operator()( std::pair< U, T >& obj ) const
{
if ( obj.second == myOld ) {
obj.second = myNew ;
}
}
private:
T myOld ;
T myNew ;
} ;

template< typename T >
inline ReplaceSecond< T >
makeReplaceSecond( T const& a, T const& b )
{
return ReplaceSecond< T >( a, b ) ;
}

et puis :

std::for_each( m.begin(), m.end(),
makeReplaceSecond( std::string( "old" ),
std::string( "new" ) ) ) ;

Mais ce genre de chose n'a de valeur que si tu dois le faire
souvent. (ReplaceSecond peut servir chaque fois que tu veux
faire replace sur l'objet mappé.)

--
James Kanze (GABI Software) email:
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



James Kanze
Le #306765
On May 4, 11:38 am, wrote:
On 3 mai, 16:01, wrote:
On 3 mai, 07:56, James Kanze
On May 2, 6:32 pm, wrote:




[...]
de plus le value_type d une map est un pair<int,string>


Regarde encore. Le value_type d'une map, c'est pair< Key const,
T >. La clé est const.

or si on
declare deux paires p1 et p2 alors on peut bien faire une opperation d
affectation
p1=p2; marche parfaitement alors c est affectable


Un type avec un const dedans n'est jamais affectable.

--
James Kanze (GABI Software) email:
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



Publicité
Poster une réponse
Anonyme