How to construct a std::string from a std::vector<string>?
c++, stdstring, stl, string-concatenation, stringstream
Solution
C++03
std::string s;
for (std::vector<std::string>::const_iterator i = v.begin(); i != v.end(); ++i)
s += *i;
return s;
C++11 (the MSVC 2010 subset)
std::string s;
std::for_each(v.begin(), v.end(), [&](const std::string &piece){ s += piece; });
return s;
C++11
std::string s;
for (const auto &piece : v) s += piece;
return s;
Don't use `std::accumulate` for string concatenation, it is a classic Schlemiel the Painter's algorithm, even worse than the usual example using `strcat` in C. Without C++11 move semantics, it incurs two unnecessary copies of the accumulator for each element of the vector. Even with move semantics, it still incurs one unnecessary copy of the accumulator for each element.
The three examples above are O(n).
`std::accumulate` is O(n²) for strings.
You could make `std::accumulate` O(n) for strings by supplying a custom functor:
std::string s = std::accumulate(v.begin(), v.end(), std::string{},
[](std::string &s, const std::string &piece) -> decltype(auto) { return s += piece; });
Note that `s` must be a reference to non-const, the lambda return type must be a reference (hence `decltype(auto)`), and the body must use `+=` not `+`.
C++20
In the current draft of what is expected to become C++20, the definition of `std::accumulate` has been altered to use `std::move` when appending to the accumulator, so from C++20 onwards, `accumulate` will be O(n) for strings, and can be used as a one-liner:
std::string s = std::accumulate(v.begin(), v.end(), std::string{});
Problem
I'd like to build a `std::string` from a `std::vector<std::string>`. I could use `std::stringsteam`, but imagine there is a shorter way: ``` std::string string_from_vector(const std::vector<std::string> &pieces) { std::stringstream ss; for(std::vector<std::string>::const_iterator itr = pieces.begin(); itr != pieces.end(); ++itr) { ss << *itr; } return ss.str(); } ``` How else might I do this?