Comment est-ce que j'utilise for_each pour sortir en cout?

Est-il plus simple façon de le faire?

for_each(v_Numbers.begin(), v_Numbers.end(), bind1st(operator<<, cout));

Sans explicite for boucle, si possible.

EDIT:

Comment faire pour std::cin avec un std::vector si possible? (Comment lire n éléments seulement)?

source d'informationauteur nakiya

  1. 27

    Que vous pourriez réaliser cela à l'aide de std::copy dans un std::ostream_iterator:

    std::vector<int> v_Numbers; //suppose this is the type
//put numbers in
std::copy(v_Numbers.begin(), v_Numbers.end(),
          std::ostream_iterator<int>(cout));

    Il serait encore mieux si vous ajoutez un peu de suffixe:

    std::copy(v_Numbers.begin(), v_Numbers.end(),
          std::ostream_iterator<int>(cout, "\n"));

    Cela suppose que votre conteneur est un vector<int>de sorte que vous aurez à les remplacer que la partie avec le type approprié.

    Modifier sur la lecture d'entrée:

    À l'inverse, vous pouvez copier à partir d'une gamme de std::istream_iterator dans un vector à l'aide de std::back_inserter:

    std::vector<int> v_Numbers;
std::copy(std::istream_iterator<int>(cin), std::istream_iterator<int>(),
          std::back_inserter(v_Numbers));

    Si vous voulez lire de n éléments seulement, regardez cette question.

  2. 9

    Une autre option — Coup de pouce.Lambda.

    for_each(v.begin(), v.end(), cout << boost::lambda::_1);
  3. 7

    Yep, mais vous devez utiliser std::algorithme de copie:

    #include <iostream>
#include <iterator>
#include <vector>

int main()
{
    std::vector<int> a;
    //fill a...
    std::copy(a.begin(), a.end(), std::ostream_iterator<int>(std::cout));
}
  4. 3

    yup, à l'aide d'expressions lambda (C++ 11), nous pouvons procédés d'impression en ligne de chaque élément d'un conteneur STL pour cout.

    #include <iostream>   //cout
#include <vector>     //vector
#include <algorithm>  //for_each
#include <iterator>   //istream_iterator
using namespace std;

int main()
{
   std::vector<int> v(10,2);
   std::for_each(v.begin(), v.end(), [](int i)->void {std::cout << i <<endl;});
   return 0;
}

    Pour la lecture "n" valeurs de cin de vecteur,

     int main()
 {
   std::vector<int> v;

   int elementsToRead;
   cin>>elementsToRead;  //Number of elements to copy

   //Reading from istream
   std::istream_iterator<int> ii2(std::cin);
   std::copy_n(ii2, elementsToRead, std::back_inserter(v));

   //printing updated vector
   std::for_each(v.begin(), v.end(), [](int i)->void {cout << i <<endl;});

   return 0;
}

    (ou) en utilisant l'expression Lambda

    std::for_each(std::istream_iterator<int>(cin),std::istream_iterator<int>(),[&v](int i)->void { v.push_back(i);});

    Pour en savoir plus sur la Lambda expression @ Qu'est ce qu'une lambda expression en C++11?

  5. 0

    Pas toujours approprié de l'entreprise dans le code, mais pour le bien de l'énumération des options - si vous avez vraiment trouver d'autres for_each /std::copy, etc. des solutions trop bavard, vous pourriez écrire:

    std::ostream& operator(std::ostream& os, const std::vector<My_Type>& v)
{
     //pick one of the other implementations for here...
    std::copy(std::istream_iterator<My_Type>(os), std::istream_iterator<My_Type>(),   
          std::back_inserter(v_Numbers));   
}

    C'est beaucoup plus agréable si vous êtes bien élevé (;-p), assez pour ne surchargez votre instanciation de vecteur (ce qui nécessite My_Type être plus qu'un typedef-à-dire de type int, mais il n'est pas difficile de créer basé sur un modèle de classe pour créer de nouveaux types d'emballage d'un type arbitraire). Sinon, si quelqu'un d'autre fait la même chose ailleurs dans votre unité de traduction, la diffusion en continu peut devenir ambigu.