Konvertieren eines vector<int> in einen string

Verwendung von std::for_each und lambda können Sie etwas tun, interessant.

#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=',';
                   });
}

Sehen diese Frage für eine kleine Klasse, die ich schrieb. Diese werden nicht gedruckt das nachgestellte Komma. Auch wenn wir davon ausgehen, dass C++14 wird fortgesetzt um uns-range-basiert äquivalente algorithmen wie diese:

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
}

Andere alternative ist die Verwendung von std::copy und die ostream_iterator Klasse:

#include <iterator>  //ostream_iterator
#include <sstream>   //ostringstream
#include <algorithm> //copy

std::ostringstream stream;
std::copy(array.begin(), array.end(), std::ostream_iterator<>(stream));
std::string s=stream.str();
s.erase(s.length()-1);

Auch nicht so schön wie Python.
Für diesen Zweck habe ich eine join Funktion:

template <class T, class A>
T join(const A &begin, const A &end, const T &t)
{
  T result;
  for (A it=begin;
       it!=end;
       it++)
  {
    if (!result.empty())
      result.append(t);
    result.append(*it);
  }
  return result;
}

Dann verwendet es wie folgt:

std::string s=join(array.begin(), array.end(), std::string(","));

Könnte man Fragen, warum ich ging in die Iteratoren. Naja, eigentlich wollte ich umkehren, array, so habe ich es wie folgt:

std::string s=join(array.rbegin(), array.rend(), std::string(","));

Im Idealfall würde ich gerne die Vorlage zu dem Punkt, wo es ableiten kann, der char-Typ und die Verwendung von string-streams, aber ich konnte nicht herausfinden noch.

Dies ist nur ein Versuch, das Rätsel zu lösen gegeben durch 1800 INFORMATIONEN die Bemerkung auf seiner zweiten Lösung fehlt, genericity, nicht ein Versuch, die Frage zu beantworten:

template <class Str, class It>
Str join(It begin, const It end, const Str &sep)
{
  typedef typename Str::value_type     char_type;
  typedef typename Str::traits_type    traits_type;
  typedef typename Str::allocator_type allocator_type;
  typedef std::basic_ostringstream<char_type,traits_type,allocator_type>
                                       ostringstream_type;
  ostringstream_type result;

  if(begin!=end)
    result << *begin++;
  while(begin!=end) {
    result << sep;
    result << *begin++;
  }
  return result.str();
}

Funktioniert Auf Meiner Maschine(TM).

Wenn Sie wollen, zu tun std::cout << join(myVector, ",") << std::endl; können Sie etwas tun:

template <typename C, typename T> class MyJoiner
{
    C &c;
    T &s;
    MyJoiner(C &&container, T&& sep) : c(std::forward<C>(container)), s(std::forward<T>(sep)) {}
public:
    template<typename C, typename T> friend std::ostream& operator<<(std::ostream &o, MyJoiner<C, T> const &mj);
    template<typename C, typename T> friend MyJoiner<C, T> join(C &&container, T&& sep);
};

template<typename C, typename T> std::ostream& operator<<(std::ostream &o, MyJoiner<C, T> const &mj)
{
    auto i = mj.c.begin();
    if (i != mj.c.end())
    {
        o << *i++;
        while (i != mj.c.end())
        {
            o << mj.s << *i++;
        }
    }

    return o;
}

template<typename C, typename T> MyJoiner<C, T> join(C &&container, T&& sep)
{
    return MyJoiner<C, T>(std::forward<C>(container), std::forward<T>(sep));
}

Hinweis, diese Lösung ist die Verknüpfung direkt in den Ausgabe-stream anstatt eine sekundäre Puffer und wird mit jedem Typen, die einem operator<< auf einen ostream.

Funktioniert das auch, wo boost::algorithm::join() schlägt fehl, wenn Sie eine vector<char*> statt einer vector<string>.

Gibt es einige interessante versuche, bietet eine elegante Lösung für das problem. Ich hatte eine Idee, mit Vorlagen-streams, um effektiv zu beantworten, die OP ' s ursprüngliche dilemma. Das ist zwar ein Alter post, ich hoffe, dass die zukünftigen Nutzer, die stolpern das finden meine Lösung vorteilhaft.

Zunächst einige Antworten (darunter die akzeptierte Antwort) fördern nicht die re-usability. Da C++ nicht bieten eine elegante Weise zu verbinden Zeichenfolgen in der standard-Bibliothek (die ich gesehen habe), wird es wichtig, eines zu erstellen, die flexibel und wiederverwendbar. Hier ist meine Chance:

//Replace with your namespace //
namespace my {
    //Templated join which can be used on any combination of streams, iterators and base types //
    template <typename TStream, typename TIter, typename TSeperator>
    TStream& join(TStream& stream, TIter begin, TIter end, TSeperator seperator) {
        //A flag which, when true, has next iteration prepend our seperator to the stream //
        bool sep = false;                       
        //Begin iterating through our list //
        for (TIter i = begin; i != end; ++i) {
            //If we need to prepend a seperator, do it //
            if (sep) stream << seperator;
            //Stream the next value held by our iterator //
            stream << *i;
            //Flag that next loops needs a seperator //
            sep = true;
        }
        //As a convenience, we return a reference to the passed stream //
        return stream;
    }
}

Jetzt zu benutzen, könnte man einfach etwas tun, wie die folgenden:

//Load some data //
std::vector<int> params;
params.push_back(1);
params.push_back(2);
params.push_back(3);
params.push_back(4);

//Store and print our results to standard out //
std::stringstream param_stream;
std::cout << my::join(param_stream, params.begin(), params.end(), ",").str() << std::endl;

//A quick and dirty way to print directly to standard out //
my::join(std::cout, params.begin(), params.end(), ",") << std::endl;

Beachten Sie, wie die Verwendung von streams macht diese Lösung, die unglaublich flexibel, da können wir speichern unser Ergebnis in ein stringstream, um diese später zurückfordern, oder wir können schreiben Sie direkt an die Standardausgabe, eine Datei oder sogar eine Netzwerk-Verbindung umgesetzt als stream. Der Typ, der gedruckt wird, muss einfach iteratable und kompatibel mit den Quell-stream. STL stellt verschiedene streams, die kompatibel mit einer großen Auswahl von Arten. So konnte man wirklich in die Stadt gehen mit diesem. Aus der Spitze von meinem Kopf, Ihre vector von int, float, double, string, unsigned int, SomeObject* und vieles mehr.

Habe ich eine helper-header-Datei fügen Sie eine erweiterte join-Unterstützung.

Fügen Sie einfach den code unten, um Ihre Allgemeine header-Datei und schließen Sie Sie, wenn nötig.

Beispiele:

/* An example for a mapping function. */
ostream&
map_numbers(ostream& os, const void* payload, generic_primitive data)
{
    static string names[] = {"Zero", "One", "Two", "Three", "Four"};
    os << names[data.as_int];
    const string* post = reinterpret_cast<const string*>(payload);
    if (post) {
        os << " " << *post;
    }
    return os;
}

int main() {
    int arr[] = {0,1,2,3,4};
    vector<int> vec(arr, arr + 5);
    cout << vec << endl; /* Outputs: '0 1 2 3 4' */
    cout << join(vec.begin(), vec.end()) << endl; /* Outputs: '0 1 2 3 4' */
    cout << join(vec.begin(), vec.begin() + 2) << endl; /* Outputs: '0 1 2' */
    cout << join(vec.begin(), vec.end(), ", ") << endl; /* Outputs: '0, 1, 2, 3, 4' */
    cout << join(vec.begin(), vec.end(), ", ", map_numbers) << endl; /* Outputs: 'Zero, One, Two, Three, Four' */
    string post = "Mississippi";
    cout << join(vec.begin() + 1, vec.end(), ", ", map_numbers, &post) << endl; /* Outputs: 'One Mississippi, Two mississippi, Three mississippi, Four mississippi' */
    return 0;
}

Den code hinter der Szene:

#include <iostream>
#include <vector>
#include <list>
#include <set>
#include <unordered_set>
using namespace std;

#define GENERIC_PRIMITIVE_CLASS_BUILDER(T) generic_primitive(const T& v) { value.as_##T = v; }
#define GENERIC_PRIMITIVE_TYPE_BUILDER(T) T as_##T;

typedef void* ptr;

/** A union that could contain a primitive or void*,
 *    used for generic function pointers.
 * TODO: add more primitive types as needed.
 */
struct generic_primitive {
    GENERIC_PRIMITIVE_CLASS_BUILDER(int);
    GENERIC_PRIMITIVE_CLASS_BUILDER(ptr);
    union {
        GENERIC_PRIMITIVE_TYPE_BUILDER(int);
        GENERIC_PRIMITIVE_TYPE_BUILDER(ptr);
    };
};

typedef ostream& (*mapping_funct_t)(ostream&, const void*, generic_primitive);
template<typename T>
class Join {
public:
    Join(const T& begin, const T& end,
            const string& separator = " ",
            mapping_funct_t mapping = 0,
            const void* payload = 0):
            m_begin(begin),
            m_end(end),
            m_separator(separator),
            m_mapping(mapping),
            m_payload(payload) {}

    ostream&
    apply(ostream& os) const
    {
        T begin = m_begin;
        T end = m_end;
        if (begin != end)
            if (m_mapping) {
                m_mapping(os, m_payload, *begin++);
            } else {
                os << *begin++;
            }
        while (begin != end) {
            os << m_separator;
            if (m_mapping) {
                m_mapping(os, m_payload, *begin++);
            } else {
                os << *begin++;
            }
        }
        return os;
    }
private:
    const T& m_begin;
    const T& m_end;
    const string m_separator;
    const mapping_funct_t m_mapping;
    const void* m_payload;
};

template <typename T>
Join<T>
join(const T& begin, const T& end,
     const string& separator = " ",
     ostream& (*mapping)(ostream&, const void*, generic_primitive) = 0,
     const void* payload = 0)
{
    return Join<T>(begin, end, separator, mapping, payload);
}

template<typename T>
ostream&
operator<<(ostream& os, const vector<T>& vec) {
    return join(vec.begin(), vec.end()).apply(os);
}

template<typename T>
ostream&
operator<<(ostream& os, const list<T>& lst) {
    return join(lst.begin(), lst.end()).apply(os);
}

template<typename T>
ostream&
operator<<(ostream& os, const set<T>& s) {
    return join(s.begin(), s.end()).apply(os);
}

template<typename T>
ostream&
operator<<(ostream& os, const Join<T>& vec) {
    return vec.apply(os);
}

Im folgenden ist eine einfache und praktische Art und Weise zu konvertieren Elemente, die in einem vector zu einem string:

std::string join(const std::vector<int>& numbers, const std::string& delimiter = ",") {
    std::ostringstream result;
    for (const auto number : numbers) {
        if (result.tellp() > 0) { //not first round
            result << delimiter;
        }
        result << number;
    }
    return result.str();
}

Müssen Sie #include <sstream> für ostringstream.

als @capone hat ,

std::string join(const std::vector<std::string> &str_list , 
                 const std::string &delim=" ")
{
    if(str_list.size() == 0) return "" ;
    return std::accumulate( str_list.cbegin() + 1, 
                            str_list.cend(), 
                            str_list.at(0) , 
                            [&delim](const std::string &a , const std::string &b)
                            { 
                                return a + delim + b ;
                            }  ) ; 
}

template <typename ST , typename TT>
std::vector<TT> map(TT (*op)(ST) , const vector<ST> &ori_vec)
{
    vector<TT> rst ;
    std::transform(ori_vec.cbegin() ,
                  ori_vec.cend() , back_inserter(rst) , 
                  [&op](const ST& val){ return op(val)  ;} ) ;
    return rst ;
}

Dann können wir den Aufruf wie folgt aus :

int main(int argc , char *argv[])
{
    vector<int> int_vec = {1,2,3,4} ;
    vector<string> str_vec = map<int,string>(to_string, int_vec) ;
    cout << join(str_vec) << endl ;
    return 0 ;
}

genau wie python :

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

Begann ich mit @sbi Antwort, aber die meiste Zeit endete Rohrleitungen den resultierenden string in einen stream, so erstellt die unter Lösung geleitet werden können, um einen Strom, ohne den overhead für das erzeugen der vollständigen Zeichenfolge im Arbeitsspeicher.

Ist es wie folgt verwendet:

#include "string_join.h"
#include <iostream>
#include <vector>

int main()
{
  std::vector<int> v = { 1, 2, 3, 4 };
  //String version
  std::string str = join(v, std::string(", "));
  std::cout << str << std::endl;
  //Directly piped to stream version
  std::cout << join(v, std::string(", ")) << std::endl;
}

Wo string_join.h:

#pragma once

#include <iterator>
#include <sstream>

template<typename Str, typename It>
class joined_strings
{
  private:
    const It begin, end;
    Str sep;

  public:
    typedef typename Str::value_type char_type;
    typedef typename Str::traits_type traits_type;
    typedef typename Str::allocator_type allocator_type;

  private:
    typedef std::basic_ostringstream<char_type, traits_type, allocator_type>
      ostringstream_type;

  public:
    joined_strings(It begin, const It end, const Str &sep)
      : begin(begin), end(end), sep(sep)
    {
    }

    operator Str() const
    {
      ostringstream_type result;
      result << *this;
      return result.str();
    }

    template<typename ostream_type>
    friend ostream_type& operator<<(
      ostream_type &ostr, const joined_strings<Str, It> &joined)
    {
      It it = joined.begin;
      if(it!=joined.end)
        ostr << *it;
      for(++it; it!=joined.end; ++it)
        ostr << joined.sep << *it;
      return ostr;
    }
};

template<typename Str, typename It>
inline joined_strings<Str, It> join(It begin, const It end, const Str &sep)
{
  return joined_strings<Str, It>(begin, end, sep);
}

template<typename Str, typename Container>
inline joined_strings<Str, typename Container::const_iterator> join(
  Container container, const Str &sep)
{
  return join(container.cbegin(), container.cend(), sep);
}