Concat multiple C++ strings at once? - c++

Question

I'm new to C++ strings. Is there a way to concatenate more than two strings at once? Or I have to concat two strings at the time? My concern is that it probably needs to allocate memory on each operation, instead of only once for the final result.
Remember something like that in java, wonder if there is a method for that somewhere in std. Actually, std::stringstream might be it, but I don't know how exactly it works.

Answer 1

You can reserve the required space beforehand, avoiding reallocations.
std::string s0{/*...*/}, s1{/*...*/}, s2{/*...*/};
std::string sink;
sink.reserve(s0.size() + s1.size() + s2.size() + 1);
sink += s0;
sink += s1;
sink += s2;
You can make this nicer with a variadic string_cat function. Here's a C++17 implementation:
template <typename... Strings>
std::string string_cat(Strings&&... strings)
{
std::string result;
result.reserve((strings.size() + ...) + 1);
((result += std::forward<Strings>(strings)), ...);
return result;
}
Usage:
using namespace std::literals;
auto res = string_cat("a"s, "b"s, "c"s);
live example on wandbox

Answer 2

Yes, to avoid expensive memory waste use the stringstream
std::stringstream might be it, but I don't know how exactly it works.
this is how it works: include the sstream, create an object, append to it as much as you need using the stream operator << get the result as string calling the function str
example:
#include <sstream>
std::stringstream mySS;
mySS << "Hello" << " World!" << "end!!" << " Foo";
and when you are done
std::string stringResult = mySS.str();

Answer 3

You are correct that each concatenation could require an allocation. Consider an expression like this, where each variable is a string:
a = b + c + d + e;
This requires three concatenation operations and three temporaries, each of which requires a new allocation.
A simple solution is to use std::ostringstream, which should not require as many reallocations:
std::ostringstream ss;
ss << b << c << d << e;
a = ss.str();
However, if we are concatenating only strings, we can do one better, and allocate exactly the right size of string (C++11-compatible implementation):
std::size_t total_string_size()
{
return 1;
}
template <typename... T>
std::size_t total_string_size(std::string const &s, T const & ...tail)
{
return s.size() + total_string_size(tail...);
}
void concat_strings_impl(std::string &) { }
template <typename... T>
void concat_strings_impl(std::string &out, std::string const &s, T const & ...tail)
{
out += s;
concat_strings_impl(out, tail...);
}
template <typename... T>
void concat_strings(std::string &out, T const & ...strings)
{
out.clear();
out.reserve(total_string_size(strings...));
concat_strings_impl(out, strings...);
}
Now we can call concat_strings(a, b, c, d, e) to perform the equivalent of a = b + c + d + e; in a single reallocation. (Demo)

Answer 4

The only way to avoid multiple allocations is to tell the string how big it needs to become before concatenating.
For example, to join together all the strings stored in a vector (like a list):
std::string join(std::vector<std::string> const& v)
{
std::string r; // return string
// add up all the string sizes
std::size_t size = 0;
for(auto const& s: v)
size += s.size();
// reserve that much space all at once (one allocation)
r.reserve(size);
// now do the concatenations
for(auto const& s: v)
r += s;
return r;
}

Answer 5

You can concatenate multiple strings - no problem:
std::string hello = "Hello";
std::string cruel = "cruel";
std::string world = "world";
std::string result = hello + " " + cruel + " " + world;
Results in result holding the string "Hello cruel world".

Answer 6

If you are using the c-style strings (ie char*), then you can allocate once and cat a number of times. The strcat function takes a pointer to a destination address as a first argument. Thus if you make your destination string large enough, there will only be one alloc. Thus
char* dest = new char[100];
dest[0] = 0; //Zero length string to start
strcat(dest, str1);
strcat(dest, str2);
strcat(dest, str3);
If on the other hand you use std::string then + can be chained string1 + string2 + string3.