Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
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
On May 2, 6:32 pm, pokali...@yahoo.fr 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:james.kanze@gmail.com
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
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
On 3 mai, 07:56, James Kanze wrote:
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
On 3 mai, 07:56, James Kanze <james.ka...@gmail.com> wrote:
On May 2, 6:32 pm, pokali...@yahoo.fr 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:james.ka...@gmail.com
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
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
On 3 mai, 16:01, wrote:
On 3 mai, 07:56, James Kanze wrote:
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
On 3 mai, 16:01, pokali...@yahoo.fr wrote:
On 3 mai, 07:56, James Kanze <james.ka...@gmail.com> wrote:
On May 2, 6:32 pm, pokali...@yahoo.fr 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:james.ka...@gmail.com
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
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
On May 3, 5:01 pm, wrote:
On 3 mai, 07:56, James Kanze wrote:
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 ) ; }
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
On May 3, 5:01 pm, pokali...@yahoo.fr wrote:
On 3 mai, 07:56, James Kanze <james.ka...@gmail.com> wrote:
On May 2, 6:32 pm, pokali...@yahoo.fr 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 ) ;
}
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:james.kanze@gmail.com
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
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 ) ; }
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
On May 4, 11:38 am, wrote:
On 3 mai, 16:01, wrote:
On 3 mai, 07:56, James Kanze wrote:
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
On May 4, 11:38 am, pokali...@yahoo.fr wrote:
On 3 mai, 16:01, pokali...@yahoo.fr wrote:
On 3 mai, 07:56, James Kanze <james.ka...@gmail.com> wrote:
On May 2, 6:32 pm, pokali...@yahoo.fr 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:james.kanze@gmail.com
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
