[ performance]--- string::operator+= vs. vector<char> push_back - c++

Question

I was testing the performance between these two operations, and on G++ 4.7.3, the string::operator+= version is about 2 times faster. My simple test:
What can be the cause of such a big difference?
g++ -O2 --std=c++11
#include <iostream>
#include <ctime>
#include <string>
#include <vector>
using namespace std;
class Timer {
public:
Timer(const std::string &label)
:label_(label)
{
begin_clock_ = clock();
cout <<label<<"- Timer starts!"<<endl;
}
~Timer() {
clock_t clock_used = clock() - begin_clock_;
cout<<label_<<"- Clock used:"<<clock_used
<<" Time:"<<clock_used/CLOCKS_PER_SEC<<endl;
}
private:
clock_t begin_clock_;
string label_;
};
int str(int loop)
{
Timer t("str");
string s;
for(int i=0;i<loop;++i)
s+=(i%2);
return s.length();
}
int vec(int loop)
{
Timer t("vec");
vector<bool> v;
for(int i=0;i<loop;++i)
v.push_back(i%2);
return v.size();
}
int main()
{
int loop = 1000000000;
int s1=str(loop);
int s2=vec(loop);
cout <<"s1="<<s1<<endl;
cout <<"s2="<<s2<<endl;
}

Answer 1

Strings and vectors both store their content contiguously. If there's not enough room for adding a new element, the capacity must be increased (memory allocation) and the existing content must be moved to the new location.
Hence, the performance should depend significantly on the allocation strategy of your implementation. If one container reserves bigger chunks when the current capacity is exhausted, it will be more efficient (less allocation, less moving).
Of course, the results are implementation dependent. In my tests, for example, the vector implementation was one third faster than the string variant.
Here how to see the effect:
int str(int loop)
{
Timer t("str");
string s;
size_t capa = 0, ncapa, alloc = 0; // coutners for monitoring allocations
long long mw = 0; //
for(int i = 0; i<loop; ++i){
if((ncapa = s.capacity()) != capa) // check if capacity increased
{ //
capa = ncapa; alloc++; mw += s.size(); //
} //
s += (i % 2);
}
cout << "allocations: " << alloc << " and elements moved: " << mw << endl;
return s.length();
}
On my compiler for example, for strings I got a capacity of 2, 4, 8, ... when for vectors it started immediately at 32,64, ...
Now, this doesn't explain all. If you want to see what part of the performance comes from allocation policy and what from other factors, you can siimply pre-allocate your string (s.reserve(loop);) and your vector (v.reserve(loop);) before starting to add any elements.