स्ट्रिंग के वेक्टर को एक स्ट्रिंग में कैसे फंसाना है (सुरुचिपूर्ण तरीके से)

Question 1

मैं एक स्ट्रिंग में स्ट्रिंग के एक वेक्टर को फंसाने के लिए सबसे सुंदर तरीके की तलाश कर रहा हूं। नीचे अब मैं उपयोग कर रहा हूँ समाधान है:

static std::string& implode(const std::vector<std::string>& elems, char delim, std::string& s)
{
    for (std::vector<std::string>::const_iterator ii = elems.begin(); ii != elems.end(); ++ii)
    {
        s += (*ii);
        if ( ii + 1 != elems.end() ) {
            s += delim;
        }
    }

    return s;
}

static std::string implode(const std::vector<std::string>& elems, char delim)
{
    std::string s;
    return implode(elems, delim, s);
}

क्या कोई अन्य व्यक्ति वहाँ है?

Question 2

उपयोग करें boost::algorithm::join(..):

#include <boost/algorithm/string/join.hpp>
...
std::string joinedString = boost::algorithm::join(elems, delim);

यह प्रश्न भी देखें ।

Question 3

std::vector<std::string> strings;

const char* const delim = ", ";

std::ostringstream imploded;
std::copy(strings.begin(), strings.end(),
           std::ostream_iterator<std::string>(imploded, delim));

(शामिल <string>, <vector>, <sstream>और <iterator>)

यदि आप एक साफ अंत चाहते हैं (कोई अनुगामी सीमांकक) यहाँ एक नज़र है

Question 4

आपको आउटपुट बनाने के std::ostringstreamबजाय उपयोग करना चाहिए std::string(तब आप str()स्ट्रिंग प्राप्त करने के लिए अंत में इसकी विधि को कॉल कर सकते हैं , इसलिए आपके इंटरफ़ेस को बदलने की आवश्यकता नहीं है, केवल अस्थायी है s)।

वहां से, आप उपयोग करने के लिए बदल सकते हैं std::ostream_iterator, जैसे:

copy(elems.begin(), elems.end(), ostream_iterator<string>(s, delim));

लेकिन इसकी दो समस्याएं हैं:

delimअब एक const char*के बजाय एक होने की जरूरत है char। कोई बड़ी बात नहीं।
std::ostream_iteratorअंतिम सहित हर एक तत्व के बाद परिसीमन लिखता है। तो आपको या तो अंतिम छोर को मिटाना होगा, या अपने स्वयं के संस्करण को लिखना होगा जिसमें यह झुंझलाहट नहीं है। यदि आपके पास इस तरह की चीजों की आवश्यकता है, तो आपके पास बहुत से कोड होने चाहिए; अन्यथा पूरी गड़बड़ी से बचा जा सकता है (यानी उपयोग करें ostringstreamलेकिन नहीं ostream_iterator)।

Question 5

क्योंकि मुझे वन-लाइनर्स से प्यार है (वे सभी प्रकार के अजीब सामानों के लिए बहुत उपयोगी हैं, जैसा कि आप अंत में देखेंगे), यहाँ std का उपयोग कर एक समाधान है :: संचय और C ++ 11 लैंबडा:

std::accumulate(alist.begin(), alist.end(), std::string(), 
    [](const std::string& a, const std::string& b) -> std::string { 
        return a + (a.length() > 0 ? "," : "") + b; 
    } )

मैं इस सिंटैक्स को स्ट्रीम ऑपरेटर के साथ उपयोगी मानता हूं, जहां मैं स्ट्रीम ऑपरेशन से सभी प्रकार के अजीब तर्क को दायरे से बाहर नहीं करना चाहता, बस एक साधारण स्ट्रिंग में शामिल होने के लिए। उदाहरण के लिए इस रिटर्न स्टेटमेंट पर विचार करें कि स्ट्रीम ऑपरेटर्स (std का उपयोग करके स्ट्रिंग);

return (dynamic_cast<ostringstream&>(ostringstream()
    << "List content: " << endl
    << std::accumulate(alist.begin(), alist.end(), std::string(), 
        [](const std::string& a, const std::string& b) -> std::string { 
            return a + (a.length() > 0 ? "," : "") + b; 
        } ) << endl
    << "Maybe some more stuff" << endl
    )).str();

अपडेट करें:

जैसा कि @plexando द्वारा टिप्पणियों में बताया गया है, उपरोक्त कोड दुर्व्यवहार से ग्रस्त है जब सरणी इस तथ्य के कारण खाली तारों से शुरू होती है कि "पहले रन" के लिए चेक पिछले रन से गायब है, जिसके परिणामस्वरूप कोई अतिरिक्त वर्ण नहीं है, और यह भी। सभी रन पर "पहले रन" के लिए एक चेक चलाना अजीब है (यानी कोड अंडर-अनुकूलित है)।

इन दोनों समस्याओं का समाधान आसान है यदि हम इस तथ्य के लिए जानते हैं कि सूची में कम से कम एक तत्व है। OTOH, अगर हम एक तथ्य यह है कि सूची के लिए पता नहीं है कम से कम एक तत्व है, तो हम रन और भी छोटा कर सकते हैं।

मुझे लगता है कि परिणामी कोड बहुत सुंदर नहीं है, इसलिए मैं इसे यहां सही समाधान के रूप में जोड़ रहा हूं , लेकिन मुझे लगता है कि ऊपर चर्चा अभी भी पूरी तरह से है:

alist.empty() ? "" : /* leave early if there are no items in the list
  std::accumulate( /* otherwise, accumulate */
    ++alist.begin(), alist.end(), /* the range 2nd to after-last */
    *alist.begin(), /* and start accumulating with the first item */
    [](auto& a, auto& b) { return a + "," + b; });

टिप्पणियाँ:

पहले तत्व तक सीधी पहुंच का समर्थन करने वाले कंटेनरों के लिए, संभवतः तीसरे तर्कों के लिए इसका उपयोग करना बेहतर है, इसलिए alist[0]वैक्टर के लिए।
टिप्पणियों और चैट में चर्चा के अनुसार, लैम्बडा अभी भी कुछ कॉपी करता है। इसके बजाय (कम सुंदर) लंबोदा का उपयोग करके इसे कम किया जा सकता है: [](auto&& a, auto&& b) -> auto& { a += ','; a += b; return a; })जो (जीसीसी 10 पर) x10 से अधिक के प्रदर्शन में सुधार करता है। सुझाव के लिए @Deduplicator का धन्यवाद। मैं अभी भी यह पता लगाने की कोशिश कर रहा हूं कि यहां क्या हो रहा है।

Question 6

सरल बेवकूफ समाधान के बारे में क्या?

std::string String::join(const std::vector<std::string> &lst, const std::string &delim)
{
    std::string ret;
    for(const auto &s : lst) {
        if(!ret.empty())
            ret += delim;
        ret += s;
    }
    return ret;
}

Question 7

string join(const vector<string>& vec, const char* delim)
{
    stringstream res;
    copy(vec.begin(), vec.end(), ostream_iterator<string>(res, delim));
    return res.str();
}

Question 8

मैं इस एक-लाइनर संचय (कोई अनुगामी सीमांकक) का उपयोग करना पसंद करता हूं:

std::accumulate(
    std::next(elems.begin()), 
    elems.end(), 
    elems[0], 
    [](std::string a, std::string b) {
        return a + delimiter + b;
    }
);

Question 9

विशेष रूप से बड़े संग्रहों के साथ, आप जाँच करना चाहते हैं कि क्या आप अभी भी पहले तत्व को जोड़ रहे हैं या नहीं कि कोई अनुगामी विभाजक सुनिश्चित न हो ...

तो खाली या एकल-तत्व सूची के लिए, कोई पुनरावृत्ति बिल्कुल नहीं है।

खाली श्रेणियां तुच्छ हैं: "" लौटें।

एकल तत्व या बहु-तत्व को पूरी तरह से नियंत्रित किया जा सकता है accumulate:

auto join = [](const auto &&range, const auto separator) {
    if (range.empty()) return std::string();

    return std::accumulate(
         next(begin(range)), // there is at least 1 element, so OK.
         end(range),

         range[0], // the initial value

         [&separator](auto result, const auto &value) {
             return result + separator + value;
         });
};

रनिंग सैंपल ( C ++ 14 की आवश्यकता है ): http://cpp.sh/8uspd

Question 10

एक संस्करण जो उपयोग करता है std::accumulate:

#include <numeric>
#include <iostream>
#include <string>

struct infix {
  std::string sep;
  infix(const std::string& sep) : sep(sep) {}
  std::string operator()(const std::string& lhs, const std::string& rhs) {
    std::string rz(lhs);
    if(!lhs.empty() && !rhs.empty())
      rz += sep;
    rz += rhs;
    return rz;
  }
};

int main() {
  std::string a[] = { "Hello", "World", "is", "a", "program" };
  std::string sum = std::accumulate(a, a+5, std::string(), infix(", "));
  std::cout << sum << "\n";
}

Question 11

यहाँ एक और है जो अंतिम तत्व के बाद सीमांकक नहीं जोड़ता है:

std::string concat_strings(const std::vector<std::string> &elements,
                           const std::string &separator)
{       
    if (!elements.empty())
    {
        std::stringstream ss;
        auto it = elements.cbegin();
        while (true)
        {
            ss << *it++;
            if (it != elements.cend())
                ss << separator;
            else
                return ss.str();
        }       
    }
    return "";

Question 12

एक अन्य प्रश्न के उत्तर के भाग का उपयोग करना , आपको एक सम्मिलित अल्पविराम के बिना विभाजक के आधार पर, इसमें शामिल होने देता है,

उपयोग:

std::vector<std::string> input_str = std::vector<std::string>({"a", "b", "c"});
std::string result = string_join(input_str, ",");
printf("%s", result.c_str());
/// a,b,c

कोड:

std::string string_join(const std::vector<std::string>& elements, const char* const separator)
{
    switch (elements.size())
    {
        case 0:
            return "";
        case 1:
            return elements[0];
        default:
            std::ostringstream os;
            std::copy(elements.begin(), elements.end() - 1, std::ostream_iterator<std::string>(os, separator));
            os << *elements.rbegin();
            return os.str();
    }
}

Question 13

यहाँ मैं क्या उपयोग कर रहा हूँ, सरल और लचीला

string joinList(vector<string> arr, string delimiter)
{
    if (arr.empty()) return "";

    string str;
    for (auto i : arr)
        str += i + delimiter;
    str = str.substr(0, str.size() - delimiter.size());
    return str;
}

का उपयोग कर:

string a = joinList({ "a", "bbb", "c" }, "!@#");

उत्पादन:

a!@#bbb!@#c

Question 14

थोड़ा लंबा समाधान, लेकिन उपयोग नहीं करता है std::ostringstream, और अंतिम सीमांकक को हटाने के लिए हैक की आवश्यकता नहीं है।

http://www.ideone.com/hW1M9

और कोड:

struct appender
{
  appender(char d, std::string& sd, int ic) : delim(d), dest(sd), count(ic)
  {
    dest.reserve(2048);
  }

  void operator()(std::string const& copy)
  {
    dest.append(copy);
    if (--count)
      dest.append(1, delim);
  }

  char delim;
  mutable std::string& dest;
  mutable int count;
};

void implode(const std::vector<std::string>& elems, char delim, std::string& s)
{
  std::for_each(elems.begin(), elems.end(), appender(delim, s, elems.size()));
}

Question 15

टर्नरी ऑपरेटर के साथ एक संभावित समाधान ?:।

std::string join(const std::vector<std::string> & v, const std::string & delimiter = ", ") {
    std::string result;

    for (size_t i = 0; i < v.size(); ++i) {
        result += (i ? delimiter : "") + v[i]; 
    }

    return result;
}

join({"2", "4", "5"})आपको दे देंगे 2, 4, 5।

Question 16

Fmt से आप कर सकते हैं।

#include <fmt/format.h>
auto s = fmt::format("{}",fmt::join(elems,delim));

लेकिन मुझे नहीं पता कि ज्वाइन करने से यह std :: फॉर्मेट में आएगा।

Question 17

बस जोड़ दो !! स्ट्रिंग s = "";

for (int i = 0; i < doc.size(); i++)   //doc is the vector
    s += doc[i];

Question 18

यह कोशिश करो, लेकिन सूची के बजाय वेक्टर का उपयोग करना

template <class T>
std::string listToString(std::list<T> l){
    std::stringstream ss;
    for(std::list<int>::iterator it = l.begin(); it!=l.end(); ++it){
        ss << *it;
        if(std::distance(it,l.end())>1)
            ss << ", ";
    }
    return "[" + ss.str()+ "]";
}