Wie viele Strings in C++

Question

hinzufügen Wie ich weiß, dass C++ nur 2 Strings hinzufügen können zusammen, das heißt: s = s1 + s2

Aber wie kann ich viele Strings zusammen fügen? Wie:

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

Answer 1

Wenn Sie versuchen, String-Objekte von std :: string Klasse anhängen, sollte diese Arbeit.

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

string s = s1 + s2 + s3; 

ODER

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

Answer 2

Vor allem können Sie die + sn Sache gut machen. Obwohl es dauert exponentiell Quadradik (siehe Kommentare) Zeit unter der Annahme, dass Sie std::basic_string<t> Strings auf C++ 03 verwenden.

Sie können std::basic_string<t>::append zusammen mit std::basic_string<t>::reserve verwenden, um Ihre Zeichenfolge in O (n) -Zeit zu verketten.

EDIT: Zum Beispiel

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; 

funktionieren, obwohl es eine Menge von Provisorien (ein guter optimierenden Compiler sollte helfen) schaffen könnte, weil es effektiv wie interpretiert wird:

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

Ein alternativer Weg, der garantiert nicht temporari erstellt wird es ist:

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

Answer 4

std::ostringstream ist dafür zu bauen, siehe Beispiel here. Es ist einfach:

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

Answer 5

Vorlage verwenden Strings hinzuzufügen, char * und char die eine Zeichenfolge

Strlen zu bilden: -

#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...); 
    } 

anhängt Saiten

// 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)); 
    } 

Haupt Beispiel

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)); 
    }