Discussion :

[Invité]

Bonjour,

std::for_each compris dans l'en-tête algorithm applique une fonction aux éléments d'une séquence. std::for_each prend 3 paramètres :

1. Un itérateur marquant le début de la séquence à parcourir.
2. Un second itérateur marquant la fin de la séquence à parcourir.
3. Un pointeur vers la fonction à appliquer sur chaque éléments de la séquence parcourue.

Le 3ème paramètre, doit être un pointeur vers une fonction qui ne doit posséder qu'un paramètre dont le type et le même que celui des éléments de la séquence parcourue...

J'ai pas fait d'erreurs j'espère ?

Mes question sont les suivantes :

• Si la séquence parcourue contient des éléments de type différents, comment y appliquer une fonction ? Je connais peut-être la réponse, mais je veux confirmer : templates...
• Si je veux appliquer une fonctions ayant plusieurs paramètres, comment faire ? J'ai entendu parler de foncteur... Je sais que c'est une classe qui surcharge l'opérateur des parenthèse, mais a part ça je vois pas trop comment procéder...

Merci à ceux qui sauront m'éclaircir sur le sujet...

[ElGat0]

Je suis pas sûr du tout que ça marche si ta séquence contient des éléments "différents" puisque pour ça il te faudrait un conteneur d'objets hétérogènes...Comment tu ferais ?


Par contre pour des fonctions à plusieurs variables, tu peux tout simplement utiliser par exemple transform() dont l'une des surcharges est capable de parcourir deux séquences en même temps : un exemple là (on additionne deux vecteurs terme à terme).

[Invité]

Bonjour,
Pour être une peu plus precis le troisième argument est une objet auquel on peut applique l'operateur parenthèse. std::for_each renvoie d'ailleurs cet objet.
Pour ce qui est des foncteurs, ils conservent leurs arguments dans des variables membre, généralement initialisées par le constructeur. Par exemple voici une foncteur qui crée à partir d'une séquence, un vecteur contenant les valeurs de chaques élément de la séquence + un entier n :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
 
class Ajouteur
{
   int n_;
   std::vector<int> entiers_;
public:
   Ajouteur(int n):n_(n){}
 
   void operator()(int valeur)
   {
        entiers_.push_back(valeur+n_);
   }
 
   std::vector<int> getEntiers()
   {
       return entiers_;
   }
};
 
// et s'utilise ainsi :
void f(std::list<int> entiers)
{
   Ajouteur aj = std::for_each(entiers.begin(), entiers.end(), Ajouteur(5));
   std::vector<int> nouveauxEntiers = aj.getEntiers();
}

Pour ce qui est d'une séquence non-homogène, ça n'existe pas en C++(enfin on peut la simuler).

Il faut aussi noter plusieurs points:
-le standard offre deux classes binder1st et binder2nd qui permettent(facilement) de transformer une fonction à deux arguments en une fonction à une argument en lui donnant l'un des arguments par *defaut*.
-il existe énormement d'algorithmes standards plus spécialisés que for_each et qui offrent généralement de meilleur solution à ton problème.

Tu peux(dois?) aussi regarder par ici

[JolyLoic]

Une remarque en passant : Si tu as la chance d'utiliser un compilateur moderne (par exemple un gcc récent, un visual studio 2010...) une solution bien plus simple qu'un foncteur existe (en fait, c'est est un, mais il est généré automatiquement pour toi) : Une fonction lambda.

Autrement, un conteneur non homogène, il n'y a pas en C++. Le plus proche utilisé est souvent un conteneur de pointeurs sur une classe de base.

pour applique une fonction avec plusieurs paramètres, tu peux créer un foncteur à la main, ou utiliser bind (soit std::tr1::bind, soit boost::bind).

[Goten]

Et même si t'as pas un compilateur moderne, ça s'émule très bien avec boost.phoenix...

[Invité]

Merci pour vos réponse, je suis sous Windows vista 32 bit avec MinGW comment compilateur pour informations...

Un conteneur de type hétérogène n'existe pas en C++ ? Mais on peut le simuler, avec un tableau de pointeur par exemple, ou encore un tableau d'objets enfant d'une classe mère...

@ElGat0 : transform() me semble pas mal
@Joe Dralliam : tu connais quelque chose de plus performant que for_each ?
@Goten : tu as un exemples d'utilisation de boost.phoenix ?

[Invité]

Va voir le tutoriel : il fait vraiment le point sur ce qui est des algorithmes standards et de tout ce qui va avec. Pour boost.phoenix c'est par là.
Sinon tu as quelle version de MinGW ? (Les lambdas ne sont disponible que depuis la version 4.5)

[Invité]

Je vais faire un tour sur le tutoriel que tu as cité... Mais je doute qu'il m'aide sur le problème énoncé ci-dessus... Je verrais bien de toute les façons.

[3DArchi]

Ta séquence contient des éléments homogènes dans le sens où le foncteur associé à std::for_each ne sera invoqué que sur une seule signature, celle du type de ton conteneur. Si tu veux vraiment avoir un parcours hétérogène, cela devra se faire soit en 2 coups, soit tu dois envisager autre chose qu'un algo de la STL pour mettre en place des choses comme un visiteur (avec ses limites).

[Goten]

Ou des lambda polymorphiques ..

[Invité]

Si tu veux vraiment avoir un parcours hétérogène, cela devra se faire soit en 2 coups

J'opte pour cette solution... Mais si par exemple, la séquence parcourue, n'est pas homogène... Un seul type... Comment faire, pour appliquer une fonctions avec plusieurs paramètres dans un std::for_each ?

Sinon, c'est quoi des lambdas ? Un Y à l'envers...

[3DArchi]

Comment faire, pour appliquer une fonctions avec plusieurs paramètres dans un std::for_each ?

Euh, il me semble que les solutions t'ont été exposées :
-> foncteur avec paramètre à la construction ;
-> fonction/foncteur avec bind (boost::bind ou std::tr1::bind) ;
-> lambda.
Soit :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
#include <iostream>
#include <vector>
#include <algorithm>
#include <boost/bind.hpp>
 
void additionner(int const lhs_, int const rhs_)
{
    std::cout<<lhs_<<" + "<<rhs_<<" = "<<lhs_+rhs_<<"\n";
}
 
struct foncteur
{
    foncteur(int const rhs_):rhs(rhs_){}
 
    void operator()(int i_)const
    {
        additionner(i_,rhs);
    }
    private:
    int const rhs;
};
 
int main()
{
    std::vector<int> v = {0,1,2,3,4,5,6,7,8,9};// uniquement C++0x :D
 
    // foncteur (C++ actuel) :
    std::for_each(
        v.begin(),
        v.end(),
        foncteur(10)
    );
 
    // bind (C++ actuel) :
    std::for_each(
        v.begin(),
        v.end(),
        boost::bind(additionner,_1,100)
    );
 
    // lambda (C++0x mais transcriptible avec boost) :
    std::for_each( 
        v.begin(),
        v.end(),
        [](int const lhs_){additionner(lhs_,1000);}
    );
 
    return 0;
}

Sinon, c'est quoi des lambdas ? Un Y à l'envers...

(vient du lambda-calcul où tout est fonction).
En gros, une fonction lambda, c'est une fonction anonyme (pas de noms et de déclaration comme une fonction classique), définie à la volée là où on en a besoin, et manipulable comme un objet.

[Invité]

En gros, une fonction lambda, c'est une fonction anonyme (pas de noms et de déclaration comme une fonction classique), définie à la volée là où on en a besoin, et manipulable comme un objet.

Merci pour le code d'exemple, c'est un peu plus clair, cependant, pour en revenir aux fonctions lambda, je ne comprend pas dans ton code pourquoi tu mets "[]"... tu surcharges l'opérateur [] ? Non je ne pense pas... Tu pourrais m'en dire plus ? Merci.

[koala01]

Merci pour le code d'exemple, c'est un peu plus clair, cependant, pour en revenir aux fonctions lambda, je ne comprend pas dans ton code pourquoi tu mets "[]"... tu surcharges l'opérateur [] ? Non je ne pense pas... Tu pourrais m'en dire plus ? Merci.

C'est la syntaxe assez particulière des "lambda expressions", qui n'a rien à voir avec l'opérateur [] qui se définit avec operator[](/*parametres éventuels */)

elle prend la forme de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

[capture] (paramètres) -> type de retour { actions }

pour être complet, [] est appelé ici en anglais "lambda introducer" (introducteur d'expression lambda )

[ElGat0]

Pour plus de détails sur les lambdas, qui sont vraiment pratiques, y'a pas mal de doc un peu partout mais je la trouve assez souvent un peu douteuse : soit qu'elle s'appuie sur celles de Boost (qui sont très bien sans doute, mais son appelées à disparaître pour le code récent), soit qu'elles spéculent un peu trop sur le contenu de la norme C++11...

La seule fois où j'avais trouvé une explication longue, simple et abondamment illustrée d'exemples c'est ici.

[Invité]

Merci pour vos réponses ! Sujet résolu. On en apprend tout les jours
Merci encore.