Lier Vs Lambda?

Comme vous l'avez dit, la reliure et les lambdas ne sont pas tout à fait exactement visent le même objectif.

Par exemple, pour l'aide et de la composition des algorithmes de la STL, les lambdas sont les grands vainqueurs, à mon humble avis.

Pour illustrer, je me souviens vraiment une drôle de réponse, ici, sur un débordement de pile, où quelqu'un a demandé des idées pour de hex numéros de magie, (comme 0xDEADBEEF, 0xCAFEBABE, 0xDEADDEAD etc.) et on m'a dit que si il a été un vrai programmeur C++ il aurait tout simplement de téléchargement d'une liste de mots anglais et de l'utilisation d'un simple one-liner de C++ 🙂

#include <iterator>
#include <string>
#include <algorithm>
#include <iostream>
#include <fstream>
#include <boost/lambda/lambda.hpp>
#include <boost/lambda/bind.hpp>

int main()
{
    using namespace boost::lambda;
    std::ifstream ifs("wordsEn.txt");
    std::remove_copy_if(
        std::istream_iterator<std::string>(ifs),
        std::istream_iterator<std::string>(),
        std::ostream_iterator<std::string>(std::cout, "\n"),
        bind(&std::string::size, _1) != 8u
            ||
        bind(
            static_cast<std::string::size_type (std::string::*)(const char*, std::string::size_type) const>(
                &std::string::find_first_not_of
            ),
            _1,
            "abcdef",
            0u
        ) != std::string::npos
    );
}

Cet extrait de code, dans le plus pur C++98, ouvrez les mots anglais fichier, l'analyse de chaque mot et de l'impression que ceux qui de longueur 8 avec 'a', 'b', 'c', 'd', 'e' ou 'f' lettres.

Maintenant, tournez sur C++0X et lambda :

#include <iterator>
#include <string>
#include <algorithm>
#include <iostream>
#include <fstream>

int main()
{
 std::ifstream ifs("wordsEn.txt");
 std::copy_if(
    std::istream_iterator<std::string>(ifs),
    std::istream_iterator<std::string>(),
    std::ostream_iterator<std::string>(std::cout, "\n"),
    [](const std::string& s)
    {
       return (s.size() == 8 && 
               s.find_first_not_of("abcdef") == std::string::npos);
    }
 );
}

C'est encore un peu lourd à lire (principalement en raison de la istream_iterator d'affaires), mais beaucoup plus simple que le bind version 🙂

Le C++ 0x lamdba syntaxe est plus lisible que la liaison de la syntaxe. Une fois que vous obtenez dans plus de 2-3 niveau lier, vous code devient assez bien illisible et difficile à maintenir. Je préfère la version plus intuitive lambda syntaxe.

Je pense que c'est plus une question de goût. Les gens que de saisir rapidement de nouvelles technologies, ou sont familiers avec la programmation fonctionnelle préféreront probablement lambda de la syntaxe, tandis que les plus conservatrices, les programmeurs vont définitivement préfèrent lier, car il est plus à la hauteur avec la traditionnelle syntaxe C++.

Une telle décision doit être faite en collaboration avec les personnes qui vont travailler avec le code, probablement par le biais d'un vote à la majorité.

Qui ne change pas le fait, cependant, que la lambda syntaxe est beaucoup plus puissant et plus propre.