Comment ajouter de nombreuses chaînes en c ++

Que je sais que C++ permet seulement d'ajouter 2 cordes en même temps, je.e:
s = s1 + s2

Mais comment puis-je ajouter plusieurs chaînes? Comme:

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

source d'informationauteur root

  1. 10

    Si vous essayez d'ajouter une chaîne d'objets de la classe std::string, cela devrait fonctionner.

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

string s = s1 + s2 + s3;

    OU

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

    Tout d'abord, vous pouvez faire de +sn chose de bien. Si il va prendre un exponentielle quadradic(voir commentaires) de temps en supposant que vous êtes en utilisant std::basic_string<t> chaînes de caractères en C++03.

    Vous pouvez utiliser le std::basic_string<t>::append de concert avec std::basic_string<t>::reserve pour concaténer votre chaîne en O(n) fois.

    EDIT: Par exemple

    string a;
//either
a.append(s1).append(s2).append(s3);
//or
a.append("I'm a string!").append("I am another string!");
  3. 5
    s = s1 + s2 + s3 + .. + sn;

    fonctionnera bien qu'il pourrait créer un grand nombre de temporaires (un bon compilateur d'optimisation devrait aider) car il va effectivement être interprété comme:

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

    Une autre façon qui est garanti de ne pas créer temporaires est:

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

    std::ostringstream est de construire pour cela, voir l'exemple ici. C'est facile:

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

    Utiliser un modèle pour ajouter des chaînes, char* et char pour former une chaîne

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

    ajout de chaînes de

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

    principal exemple

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