Cómo agregar muchas cadenas en C++

Question

Como sé que C++ sólo permite añadir 2 cadenas juntas, es decir: s = s1 + s2

Pero, ¿cómo puedo añadir muchas cadenas juntas? Me gusta:

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

Answer 1

Si usted está tratando de agregar objetos de cadena de clase std :: string, esto debería funcionar.

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

string s = s1 + s2 + s3; 

O

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

Answer 2

En primer lugar, puede hacer lo + sn bien. Aunque tardará exponencial quadradic (ver comentarios) tiempo suponiendo que está utilizando std::basic_string<t> cadenas en C++ 03.

Puede usar el std::basic_string<t>::append junto con std::basic_string<t>::reserve para concatenar su cadena en el tiempo O (n).

EDIT: Por ejemplo

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; 

funcionará aunque se podría crear una gran cantidad de provisionales (un buen compilador de optimización debería ayudar), ya que efectivamente se interpretará como:

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

Una manera alternativa que garantiza no crear temporari ES es:

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

Answer 4

std::ostringstream es construir para ello, véase el ejemplo here. Es muy fácil:

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

Answer 5

utilizar una plantilla para agregar cadenas, char * y carbón de formar una cadena

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

cadenas anexas

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

ejemplo principal

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