Konvertieren einer vector in einen String
https://stackoverflow.com/questions/1430757
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianFrage
Ich habe einen vector<int> Container, ganze Zahlen (zum Beispiel {1,2,3,4}) hat, und ich möchte auf einen String der Form konvertieren
"1,2,3,4"
Was ist der sauberste Weg, dass in C ++ zu tun? In Python ist dies, wie ich es tun würde:
>>> array = [1,2,3,4]
>>> ",".join(map(str,array))
'1,2,3,4'
Lösung
Auf jeden Fall nicht so elegant wie Python, aber nichts ganz so elegant wie Python in C ++.
Sie könnten eine stringstream verwenden ...
std::stringstream ss;
for(size_t i = 0; i < v.size(); ++i)
{
if(i != 0)
ss << ",";
ss << v[i];
}
std::string s = ss.str();
Sie können auch die Verwendung von std::for_each machen statt.
Andere Tipps
Mit std :: for_each und Lambda Sie etwas Interessantes tun.
#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=',';
});
}
Siehe diese Frage für eine kleine Klasse ich geschrieben habe. Dadurch wird das Komma nicht gedruckt. Auch wenn wir davon ausgehen, dass C ++ 14 wird auch weiterhin geben uns anhand Äquivalente von Algorithmen wie dieser Bereich:
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
}
Sie std :: verwenden können akkumulieren. Betrachten Sie das folgende Beispiel
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);
});
Eine weitere 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.
Zu diesem 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 aus:
std::string s=join(array.begin(), array.end(), std::string(","));
Sie fragen sich vielleicht, warum ich in den Iteratoren übergeben. Nun, eigentlich wollte ich das Array umkehren, so habe ich es wie folgt aus:
std::string s=join(array.rbegin(), array.rend(), std::string(","));
Idealerweise möchte ich den Punkt Vorlage aus, wo sie den Typ char entnehmen kann, und die Verwendung stringStröme, aber ich konnte das noch nicht herausgefunden.
Mit Boost und C 11 ++ dies wie dies erreicht werden könnte:
auto array = {1,2,3,4};
join(array | transformed(tostr), ",");
Nun, fast. Hier ist das vollständige Beispiel:
#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;
}
Kredit Praetorian .
Sie können einen beliebigen Wert Typ wie folgt behandeln:
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);
};
Dies ist nur ein Versuch, das Rätsel von 1800 INFORMATION Bemerkung auf seinem zweite Lösung fehlt Genericity, kein 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();
}
Works On My Machine (TM).
Viele template / Ideen. Mine ist nicht als generisches oder effizient, aber ich hatte gerade das gleiche Problem und wollte diese in die Mischung als etwas kurz und süß werfen. Es gewinnt auf kürzeste Anzahl der Zeilen ...:)
std::stringstream joinedValues;
for (auto value: array)
{
joinedValues << value << ",";
}
//Strip off the trailing comma
std::string result = joinedValues.str().substr(0,joinedValues.str().size()-1);
Wenn Sie std::cout << join(myVector, ",") << std::endl; tun möchten, können Sie so 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));
}
Beachten Sie, tut diese Lösung direkt in den Ausgabestrom zu verbinden, anstatt einen sekundären Puffer zu schaffen und mit irgendwelchen Typen arbeiten, die einen Operator haben << auf eine ostream.
Dies funktioniert auch, wo boost::algorithm::join() fehlschlägt, wenn Sie einen vector<char*> anstelle eines vector<string> haben.
Ich mag 1800 Antwort. Allerdings würde ich die erste Iteration aus der Schleife, wie als Ergebnis der Bewegung if-Anweisung nur einmal nach der ersten Iteration ändert
template <class T, class A>
T join(const A &begin, const A &end, const T &t)
{
T result;
A it = begin;
if (it != end)
{
result.append(*it);
++it;
}
for( ;
it!=end;
++it)
{
result.append(t);
result.append(*it);
}
return result;
}
Dies kann natürlich bis auf weniger Aussagen reduziert werden, wenn Sie mögen:
template <class T, class A>
T join(const A &begin, const A &end, const T &t)
{
T result;
A it = begin;
if (it != end)
result.append(*it++);
for( ; it!=end; ++it)
result.append(t).append(*it);
return result;
}
Es gibt einige interessante Versuche, eine elegante Lösung für das Problem bereitstellt. Ich hatte eine Idee Templat-Streams zu verwenden, um effektiv das ursprüngliche Dilemma OP zu beantworten. Obwohl dies eine alte Post, ich bin der Hoffnung, künftige Nutzer, die auf diese stolpern meine Lösung vorteilhaft.
findenZunächst einige Antworten (einschließlich der akzeptierten Antwort) nicht fördern Wiederverwendbarkeit. Da C ++ nicht über eine elegante Art und Weise zur Verfügung stellen, um Strings in der Standard-Bibliothek zu verbinden (die ich gesehen habe), ist es wichtig, eine zu schaffen, die flexibel und wiederverwendbar ist. Hier ist mein Schuss auf ihn:
// 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;
}
}
Nun, diese zu verwenden, könnte man einfach etwas tun, wie folgt aus:
// 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 Strömen dieser Lösung unglaublich flexibel macht, wie wir unser Ergebnis in einem string speichern können es später zurückfordern, oder wir können mit dem Standard aus, eine Datei oder sogar zu einer Netzwerkverbindung umgesetzt als auch direkt schreiben Strom. Die Art gedruckt wird, muß lediglich mit dem Quellstrom und iteratable kompatibel sein. STL bietet verschiedene Ströme, die mit einer großen Auswahl an Typen kompatibel sind. So könnte man wirklich mit dieser in der Stadt gehen. Aus der Spitze von meinem Kopf, kann Ihr Vektor von int, float, double, string, unsigned int, Someobject * und vieles mehr.
string s;
for (auto i : v)
s += (s.empty() ? "" : ",") + to_string(i);
Ich habe eine Helfer-Header-Datei erstellt eine Unterstützung erweitert hinzuzufügen beizutreten.
Fügen Sie einfach den Code unten, um Ihre allgemeine Header-Datei und es ist bei Bedarf.
Anwendungsbeispiele:
/* 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;
}
Der 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);
}
Hier ist eine generische C ++ 11-Lösung, die Sie tun können
int main() {
vector<int> v {1,2,3};
cout << join(v, ", ") << endl;
string s = join(v, '+').str();
}
Der Code lautet:
template<typename Iterable, typename Sep>
class Joiner {
const Iterable& i_;
const Sep& s_;
public:
Joiner(const Iterable& i, const Sep& s) : i_(i), s_(s) {}
std::string str() const {std::stringstream ss; ss << *this; return ss.str();}
template<typename I, typename S> friend std::ostream& operator<< (std::ostream& os, const Joiner<I,S>& j);
};
template<typename I, typename S>
std::ostream& operator<< (std::ostream& os, const Joiner<I,S>& j) {
auto elem = j.i_.begin();
if (elem != j.i_.end()) {
os << *elem;
++elem;
while (elem != j.i_.end()) {
os << j.s_ << *elem;
++elem;
}
}
return os;
}
template<typename I, typename S>
inline Joiner<I,S> join(const I& i, const S& s) {return Joiner<I,S>(i, s);}
Das folgende ist eine einfache und praktische Art und Weise Elemente in einem vector zu einem string zu konvertieren:
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();
}
Sie müssen sich für #include <sstream> ostringstream.
Die Erweiterung auf den Versuch von @sbi bei einer generische Lösung dass nicht beschränkt ist oder eine bestimmte Rückgabestring Typ std::vector<int> . Der Code unten dargestellt kann wie folgt verwendet werden:
std::vector<int> vec{ 1, 2, 3 };
// Call modern range-based overload.
auto str = join( vec, "," );
auto wideStr = join( vec, L"," );
// Call old-school iterator-based overload.
auto str = join( vec.begin(), vec.end(), "," );
auto wideStr = join( vec.begin(), vec.end(), L"," );
In dem ursprünglichen Code, Template-Argument Abzug funktioniert nicht den richtigen Rückkehr String-Typen zu erzeugen, wenn der Separator ein Zeichenfolgenliteral (wie in den Proben oben). In diesem Fall sind die typedefs wie Str::value_type im Funktionskörper nicht korrekt. Der Code geht davon aus, dass Str ist immer ein Typ wie std::basic_string, so dass es nicht offensichtlich für Stringliterale.
Um dies zu beheben, versucht der folgende Code nur den Charakter Typen aus dem Separator Argumente abzuleiten und verwendet, dass ein Standard-Return-String-Typen zu erzeugen. Dies wird erreicht, indem Live Demo bei Coliru
als @capone tat,
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 nennen wie folgt vor:
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 ;
}
wie Python:
>>> " ".join( map(str, [1,2,3,4]) )
Ich benutze so etwas wie diese
namespace std
{
// for strings join
string to_string( string value )
{
return value;
}
} // namespace std
namespace // anonymous
{
template< typename T >
std::string join( const std::vector<T>& values, char delimiter )
{
std::string result;
for( typename std::vector<T>::size_type idx = 0; idx < values.size(); ++idx )
{
if( idx != 0 )
result += delimiter;
result += std::to_string( values[idx] );
}
return result;
}
} // namespace anonymous
begann ich mit @ sbi Antwort, aber den meiste Zeit am Ende zu einem Strom des resultierenden String kochend so die unten stehende Lösung geschaffen, die ohne den Aufwand der Erstellung die vollständige Zeichenfolge im Speicher zu einem Strom geleitet werden kann.
Es wird 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 ist:
#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);
}
Ich habe schrieb den folgenden Code ein. Es ist in C # string.join basiert. Es arbeitet mit std :: string und std :: wstring und viele Arten von Vektoren. (Beispiele in den Kommentaren)
Nennen Sie es wie folgt aus:
std::vector<int> vVectorOfIds = {1, 2, 3, 4, 5};
std::wstring wstrStringForSQLIn = Join(vVectorOfIds, L',');
Code:
// Generic Join template (mimics string.Join() from C#)
// Written by RandomGuy (stackoverflow) 09-01-2017
// Based on Brian R. Bondy anwser here:
// http://stackoverflow.com/questions/1430757/c-vector-to-string
// Works with char, wchar_t, std::string and std::wstring delimiters
// Also works with a different types of vectors like ints, floats, longs
template<typename T, typename D>
auto Join(const std::vector<T> &vToMerge, const D &delimiter)
{
// We use std::conditional to get the correct type for the stringstream (char or wchar_t)
// stringstream = basic_stringstream<char>, wstringstream = basic_stringstream<wchar_t>
using strType =
std::conditional<
std::is_same<D, std::string>::value,
char,
std::conditional<
std::is_same<D, char>::value,
char,
wchar_t
>::type
>::type;
std::basic_stringstream<strType> ss;
for (size_t i = 0; i < vToMerge.size(); ++i)
{
if (i != 0)
ss << delimiter;
ss << vToMerge[i];
}
return ss.str();
}
