कैसे C++

Question

में कई तार जोड़ने के लिए मुझे पता है के रूप में है कि सी ++ केवल 2 तार एक साथ जोड़ने की अनुमति देता, यानी: s = s1 + s2

लेकिन यह कैसे मैं कई तार एक साथ जोड़ सकते हैं? पसंद:

s = s1 + s2 + s3 + s4 + ... + sn 

Answer 1

आप std :: स्ट्रिंग वर्ग की स्ट्रिंग वस्तुओं संलग्न करने के लिए प्रयास कर रहे हैं के लिए, यह काम करना चाहिए।

string s1 = "string1"; 
string s2 = "string2"; 
string s3 = "string3"; 

string s = s1 + s2 + s3; 

या

string s = string("s1") + string("s2") + string("s3") ... 

Answer 2

सबसे पहले, आप + स्न चीज़ को ठीक कर सकते हैं। हालांकि यह घातीय क्वाड्रैडिक (टिप्पणियां देखें) लेने वाला है, यह मानते हुए कि आप C12+ 03 पर std::basic_string<t> स्ट्रिंग का उपयोग कर रहे हैं।

आप ओ 12 (एन) समय में अपनी स्ट्रिंग को जोड़ने के लिए std::basic_string<t>::reserve के साथ संगीत कार्यक्रम में std::basic_string<t>::append का उपयोग कर सकते हैं।

संपादित करें: उदाहरण के

string a; 
//either 
a.append(s1).append(s2).append(s3); 
//or 
a.append("I'm a string!").append("I am another string!"); 

Answer 3

s = s1 + s2 + s3 + .. + sn; 

काम हालांकि यह (एक अच्छा अनुकूलन संकलक की मदद करनी चाहिए) temporaries का एक बहुत बना सकते हैं जाएगा क्योंकि यह प्रभावी रूप से मान लिया जाएगा:

string tmp1 = s1 + s2; 
string tmp2 = tmp1 + s3; 
string tmp3 = tmp2 + s4; 
... 
s = tmpn + sn; 

एक वैकल्पिक तरीका है कि अस्थायी बनाने की गारंटी नहीं है तों है:

s = s1; 
s += s2; 
s += s3; 
... 
s += sn; 

Answer 4

std::ostringstream कि के लिए निर्माण, उदाहरण के here देखते हैं। यह आसान है:

std::ostringstream out; 
out << "a" << "b" << "c" << .... << "z"; 
std::string str(out.str()); 

Answer 5

एक स्ट्रिंग

strlen बनाने के लिए तार, चार * और चार के जोड़ने के लिए एक टेम्पलेट का उपयोग करें: -

#include <iostream> 
#include <cstring> 

// it_pair to wrap a pair of iterators for a for(:) loop 
template<typename IT> 
class it_pair 
    { 
    IT b; 
    IT e; 
public: 
    auto begin() const 
     { 
     return b; 
     } 
    auto end() const 
     { 
     return e; 
     } 
    }; 

// string length 
template<typename S> auto strlen(const S& s) -> decltype(s.size()) 
    { 
    return s.size(); 
    } 

auto strlen(char c) -> size_t 
    { 
    return 1u; 
    } 

auto strlen(const std::initializer_list<char>& il) -> size_t 
    { 
    return il.size(); 
    } 

template<typename IT> 
auto strlen(const it_pair<IT>& p) 
    { 
    auto len = size_t{}; 
    for(const auto& s:p) 
     len += strlen(s); 
    return len; 
    } 

template<typename S, typename ...SS> auto strlen(S s, SS&... ss) -> size_t 
    { 
    return strlen(s) + strlen(ss...); 
    } 

जोड़कर तार

// terminate recursion 
template<typename TA, typename TB> 
void append(TA& a, TB& b) 
    { 
    a.append(b); 
    } 

// special case for a character 
template<> 
void append<std::string, const char>(std::string& a, const char& b) 
    { 
    a.append(1, b); 
    } 

// special case for a collection of strings 
template<typename TA, typename TB> 
void append(TA& a, const it_pair<TB>& p) 
    { 
    for(const auto& x: p) 
     a.append(x); 
    } 

// recursion append 
template<typename TA, typename TB, typename ...TT> 
void append(TA& a, TB& b, TT&... tt) 
    { 
    append(a, b); 
    append(a, tt...); 
    } 

template<typename ...TT> 
std::string string_add(const TT& ... tt) 
    { 
    std::string s; 
    s.reserve(strlen(tt...)); 
    append(s, tt...); 
    return s; 
    } 

template<typename IT> 
auto make_it_pair(IT b, IT e) 
    { 
    return it_pair<IT>{b, e}; 
    } 

template<typename T> 
auto make_it_pair(const T& t) 
    { 
    using namespace std; 
    return make_it_pair(cbegin(t), cend(t)); 
    } 

मुख्य उदाहरण

int main() 
    { 
    const char * s[] = {"vw", "xyz"}; 
    std::vector<std::string> v{"l", "mn", "opqr"}; 
    std::string a("a"); 
    std::string b("bc"); 
    std::string c("def"); 
    std::cout << string_add(a, b+c, "ghij", make_it_pair(v), 'k', make_it_pair(s)); 
    }