Question STL - for_each

fred wrote:

je voudrai savoir dans ce cas :

class c_Summe : public t_summe_pro_rech
{
public :
c_Summe(int a= 0,int b= 0, double c=0.0, double d=0.0, double
e=0.0, char *f='')
{ exp_anz= a; sdg_anz= b; gewicht= c; vd= d; preis= e;

strcpy(lpfx,f); }

Quels sont ces exp_anz, etc. ? Je ne les vois définis nul part.

public :
void Init() { exp_anz= 0; sdg_anz= 0; gewicht= 0.0; vd= 0.0;
preis= 0.0; *lpfx=''; }

c_Summe operator() (const pair<int,t_summe_pro_rech> var) {
exp_anz+= var.second.exp_anz; sdg_anz+= var.second.sdg_anz;
gewicht+= var.second.gewicht; vd+= var.second.vd;
preis+= var.second.preis; }
};

ensuit l'appel :

c_Summe X=for_each( Array.begin(); Array.end();c_Summe);

for_each( array.begin(), array.end(), c_Summe() ) ;

for_each est une foncion ; les paramètres sont donc séparés par
des ';'. Et le troisième paramètre est une valeur ou un objet,
non un type.

Aussi, il faut se méfier un peu des objets fonctionnels qui ont
un état. Ici, je ne crois pas que tu aies un problème -- il n'y
a rien de garanti par la norme, mais je crois que l'intention
est claire que les auteurs ont voulu que ça marche, même s'ils
ne l'ont pas réelement dit. Mais ça ne vaut que pour for_each,
non pour les autres fonctions.

---------------------------------------------------

Ma question est : pourquoi avoir redéfinie l'opérateur () ???

Parce que c'est l'operator() que for_each va appeler sur chaque
objet.

Comment fonctionne l'appel ?

Comment comment fonctionne l'appel ? Comme un appel ordinaire.
L'intérêt de l'operator(), c'est qu'on peut utiliser l'objet
avec la syntaxe d'une fonction.

p.s: Question 2 : est il possible de faire une recherche sur
le deuxieme element d'un type map ? genre .. for_each(
mapArray.find_first_of( elem2.string="xxx";end ....;fct) ???

Non avec for_each, mais find fait une récherche linéaire, et
avec find_if, c'est toi qui définis la condition. Je ne me
rappelle pas de l'avoir fait avec un map, mais je m'en sers bien
sur des struct { Enum e, char const* n }, soit pour chercher
selon l'enum, soit pour chercher le nom. (Ici, j'utilise bien un
struct, avec des types C primitifs, pour avoir une
initialisation statique.) Il suffit de définir les bons
prédicats. Et se tenir compte du type renvoyé par un itérateur
sur map : map<>::value_type, un std::pair dont le premier
élément est le clé, et le deuxième la valeur.

--
James Kanze mailto: james.kanze@free.fr
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 pl. Pierre Sémard, 78210 St.-Cyr-l'École, France +33 (0)1 30 23 00 34