Convertir un vecteur<int> en chaîne de caractères

Question

J'ai un conteneur vector<int> qui a des entiers (par exemple {1,2,3,4}) et je voudrais le convertir en une chaîne de la forme

"1,2,3,4"

Quelle est la façon la plus propre de le faire en C++ ? En Python c'est comme ça que je le ferais :

>>> array = [1,2,3,4]
>>> ",".join(map(str,array))
'1,2,3,4'

Answer 1

Certainement pas aussi élégant que Python, mais rien n'est aussi élégant que Python en C++.

Vous pourriez utiliser un stringstream...

#include <sstream>
//...

std::stringstream ss;
for(size_t i = 0; i < v.size(); ++i)
{
  if(i != 0)
    ss << ",";
  ss << v[i];
}
std::string s = ss.str();

Vous pouvez également utiliser std::for_each la place.

Answer 2

En utilisant std : :for_each et lambda, vous pouvez faire quelque chose d'intéressant.

#include <iostream>
#include <sstream>

int main()
{
     int  array[] = {1,2,3,4};
     std::for_each(std::begin(array), std::end(array),
                   [&std::cout, sep=' '](int x) mutable {
                       out << sep << x; sep=',';
                   });
}

Voyez cette question pour un petit cours que j'ai écrit. Cela n'imprimera pas la virgule de fin. Aussi, si nous supposons que C++14 continuera à nous donner des équivalents basés sur la gamme d'algorithmes comme celui-ci :

namespace std {
   // I am assuming something like this in the C++14 standard
   // I have no idea if this is correct but it should be trivial to write if it  does not appear.
   template<typename C, typename I>
   void copy(C const& container, I outputIter) {copy(begin(container), end(container), outputIter);}
}
using POI = PrefexOutputIterator;   
int main()
{
     int  array[] = {1,2,3,4};
     std::copy(array, POI(std::cout, ","));
  // ",".join(map(str,array))               // closer
}

Answer 3

Vous pouvez utiliser std : :accumuler. Prenons l'exemple suivant

if (v.empty() 
    return std::string();
std::string s = std::accumulate(v.begin()+1, v.end(), std::to_string(v[0]),
                     [](const std::string& a, int b){
                           return a + ',' + std::to_string(b);
                     });

Answer 4

Avec Boost et C++11, cela pourrait être réalisé comme suit :

auto array = {1,2,3,4};
join(array | transformed(tostr), ",");

Eh bien, presque. Voici l'exemple complet :

#include <array>
#include <iostream>

#include <boost/algorithm/string/join.hpp>
#include <boost/range/adaptor/transformed.hpp>

int main() {
    using boost::algorithm::join;
    using boost::adaptors::transformed;
    auto tostr = static_cast<std::string(*)(int)>(std::to_string);

    auto array = {1,2,3,4};
    std::cout << join(array | transformed(tostr), ",") << std::endl;

    return 0;
}

Crédit à Praetorian.

Vous pouvez gérer n'importe quel type de valeur comme ceci :

template<class Container>
std::string join(Container const & container, std::string delimiter) {
  using boost::algorithm::join;
  using boost::adaptors::transformed;
  using value_type = typename Container::value_type;

  auto tostr = static_cast<std::string(*)(value_type)>(std::to_string);
  return join(container | transformed(tostr), delimiter);
};