std::transform à l'aide de C++0x expression lambda

Comment cela est possible en C++0x?

std::vector<double> myv1;
std::transform(myv1.begin(), myv1.end(), myv1.begin(),
               std::bind1st(std::multiplies<double>(),3));

Question d'origine et la solution est ici.

  • ....a cette prise de ce post? stackoverflow.com/questions/3885095/...
  • oui, je me suis lié à cette ci-dessus
  • ah, ok. raté
  • mon mauvais, c'était une modification dans l'intérêt de la divulgation complète
  • Pourquoi ne pas simplement for_each(begin(myv1), end(myv1), [](double& a) { a *= 3; }?
  • for_each ne pas modifier les éléments - j'ai essayé cette solution à l'original q - voir stackoverflow.com/questions/662845/...
  • Townsend: Comme indiqué dans le fil de discussion lié, for_each est bien sûr autorisés pour modifier la non-const éléments de votre séquence de non-modification se réfère à la structure du conteneur qui nous laisser intact.
  • Vous devriez ajouter que comme une réponse. Je vais supprimer le mien.
  • Merci - voici pour vous 😉

InformationsquelleAutor Steve Townsend | 2010-10-07
  1. 34
    std::transform(myv1.begin(), myv1.end(), myv1.begin(), 
   [](double d) -> double { return d * 3; });
    • -> double est inutile; il est automatiquement déduite.
    • il est censé le faire, mais les compilateurs parfois ignorer ce fait. Vaut mieux en mettre dans tous les temps.
    • Une autre façon de qui est: std::transform(myv1.begin(), myv1.end(),myv1.begin(),myv1.end(), std::bind(std::multiplies<double>(),_1,3));
    InformationsquelleAutor Crazy Eddie
  2. 28

    Il suffit de faire comme Dario dit:

    for_each(begin(myv1), end(myv1), [](double& a) { a *= 3; });

    for_each est autorisé à modifier les éléments, en disant qu'il ne peut pas est un mythe.

    • +1 parce que cela semble un ajustement plus naturel pour moi dans la question d'origine
    • +1 pour le "for_each est autorisé à modifier les éléments." J'ai participé à un très vif débat sur il y a des années.
    InformationsquelleAutor GManNickG
  3. 28

    La principale motivation initiale pour l'utilisation fonctionnelle de style pour ces cas en C++ a été, "aaagh! itérateur de la boucle!", et C++0x supprime que la motivation avec la gamme de base pour la déclaration. Je sais qu'une partie de la point de la question était de savoir le lambda de la syntaxe, mais je pense que la réponse à la question "Comment est-ce fait dans C++0x?" est:

    for(double &a : myv1) { a *= 3; }

    Il n'y a pas de réelle fonction d'objet, mais si ça vous aide pourrait prétendre que { a *= 3; } est un très abrégée lambda. Pour l'ergonomie, il revient à la même chose de toute façon, même si le projet de norme définit basés sur la plage, pour un équivalent for boucle.

    • Ah yah. En général, je oublier que depuis que je ne pas utiliser un compilateur qui la prend en charge. 🙁 Certainement la meilleure solution.
    • quel est le nom de cette construction? Je ne suis pas encore familier avec ce qui est dans C++0x.
    • "de la gamme, en fonction de l'énoncé", 6.5.4 dans n3090. Ajouté à la réponse.
    • Townsend. Je pense que c'est appelé "variait de boucle'. En Java, ce même concept est appelé foreach =/
    InformationsquelleAutor Steve Jessop
  4. 8

    À l'aide d'une mutable approche, nous pouvons utiliser for_each directement mettre à jour les éléments de la séquence par le biais de références.

    for_each(begin(myv1), end(myv1), [](double& a) { a *= 3; });

    Il y a eu un débat passe si for_each est en fait autorisés à modifier des éléments comme on les appelle les "non-mutation" de l'algorithme.

    Ce que cela signifie est for_each n'est pas autorisé à modifier le séquence il opère sur (qui se réfère à des changements de la séquence structure - c'est à dire d'invalider les itérateurs). Cela ne veut pas dire nous ne pouvons pas modifier la non-const éléments du vecteur comme d'habitude - la structure elle-même est épargnée par ces opérations.

    InformationsquelleAutor Dario
  5. 5

    Comme ceci:

    vector<double> myv1;
transform(myv1.begin(), myv1.end(), myv1.begin(), [](double v)
{
    return v*3.0;
});
    • Je trouve que la mise en forme assez déroutant.
    • À chacun son propre, je suppose. Tho je m'empresse de souligner que la mienne est la mise en forme correcte. 🙂
    • +1 pour le fait à l'aide d'un littéral double pour la constante. 😉
    InformationsquelleAutor John Dibling
  6. 1

    Je suis en utilisant VS2012 qui soutiennent le C++11 lier adaptateur. Pour lier le premier élément de la fonction binaire (comme bind1st utiliser pour le faire), vous devez ajouter une
    _1 (espace réservé à l'argument). Besoin d'inclure la fonctionnelle pour lier. 

    using namespace std::placeholders;
std::transform( myv1.begin(), myv1.end(), myv1.begin(),
                 std::bind( std::multiplies<double>(),3,_1));
    InformationsquelleAutor Elligno