Simple question: If I have a string and I want to add to it head and tail strings (one in the beginning and the other at the end), what would be the best way to do it? Something like this:
std::string tmpstr("some string here");
std::string head("head");
std::string tail("tail");
tmpstr = head + tmpstr + tail;
Is there any better way to do it?
Thanks in advance.
If you were concerned about efficiency and wanted to avoid the temporary copies made by the + operator, then you could do:
tmpstr.insert(0, head);
tmpstr.append(tail);
And if you were even more concerned about efficiency, you might add
tmpstr.reserve(head.size() + tmpstr.size() + tail.size());
before doing the inserting/appending to ensure any reallocation only happens once.
However, your original code is simple and easy to read. Sometimes that's "better" than a more efficient but harder to read solution.
An altogether different approach:
#include <iostream>
#include <string>
#include <sstream>
int
main()
{
std::string tmpstr("some string here");
std::ostringstream out;
out << head << tmpstr << tail;
tmpstr = out.str(); // "headsome string heretail"
return 0;
}
An advantage of this approach is that you can mix any type for which operator<< is overloaded and place them into a string.
std::string tmpstr("some string here");
std::ostringstream out;
int head = tmpstr.length();
char sep = ',';
out << head << sep << tmpstr;
tmpstr = out.str(); // "16,some string here"
operator+()is always a temporary (rvalue). Absent of C++1x rvalue references, if you don't need to further modify the result, you can probably optimize away one superflous copying by storing the result in a const reference, instead of copying it into an object:const T& result = a + b;This will bind the temporary to the refrence and extend its lifetime accordingly. While your compiler might optimize out this one copy anyway (unlikely with strings, I'd say), so you might not gain anything, using this technique won't hurt performance.