Std :: string performance for handling short strings

I've allowed you to expand your test program a bit. Specifically, I added code to make it generate its data internally and not depend on an external file, added synchronization code to isolate the string being processed, and if it did both C ++ and C versions of string manipulation in the same volume the same launch, so it immediately gave results that I could compare. This gave me the following code:

#include <iostream>
#include <fstream>
#include <vector>
#include <string>

#include <cstdlib>
#include <cstring>

#include <ctime>

char* compose_c(const char* name, const char* domain)
{
    char* res = (char*) malloc(strlen(name)+strlen(domain)+2);
    char* p = strcpy(res,name);

    p += strlen(name);
    *p = '@';
    strcpy(p+1,domain);

    return res;
}

std::string rand_string(int size){
    std::string ret;

    for (int i = 0; i < size; i++)
        ret.push_back(rand() % 10 + '0');
    return ret;
}

struct address {
    std::string email, domain;

    address() : email(rand_string(5)), domain(rand_string(4) + ".com") { }
};

struct composed {
    std::string addr;
    composed(address const &a) : addr(a.email + "@" + a.domain) {}
};

void report(clock_t d, std::string const &label){
    std::cout << double(d) / CLOCKS_PER_SEC << " seconds for " << label << "\n";
}

int main(int argc, char **argv) {
    static const int NUM = 1024 * 1024;

    std::vector<address> addresses(NUM);

    clock_t start = clock();
    {
        std::vector<composed> c{ addresses.begin(), addresses.end() };
    }
    report(clock() - start, "C++");

    std::vector<char *> c_results(addresses.size());

    clock_t start_c = clock();
    for (int i = 0; i < addresses.size(); i++)
        c_results[i] = compose_c(addresses[i].email.c_str(), addresses[i].domain.c_str());
    for (char *c : c_results)
        free(c);
    report(clock() - start_c, "C");
}

      

        
        
        
      

    

Then I compiled it with VC ++ 2013, x64 using flags: -O2b2 -GL -EHsc

. When I ran this, I got the result:

0.071 seconds for C++
0.12 seconds for C

      

        
        
        
      

    

While there are some run-to-run options, these are pretty representative results - C code takes almost (but not quite) twice as much as C ++ code.

Note that this is despite the fact that I did give the C version a slightly unfair advantage. The time for C ++ code includes not only the execution time of string manipulations, but also the time to create and destroy the vector to store the results. For C code, I prepare the vector ahead of time and then only generate code to create and destroy the strings themselves.

To keep this result from being accidental, I also tried changing some of the explanatory variables. For example, increasing the number of address lines that we compose by a factor of 10 increased the total time, but had little effect on the ratio:

0.714 seconds for C++
1.206 seconds for C

      

        
        
        
      

    

Likewise, changing the order to run the C code first and the C ++ code that ran second had no discernible effect.

Suppose I have to add: it's true that since it means this code doesn't actually use the function compose_cpp

as the original did, instead it needs to include the functionality in the constructor for composed

. For completeness, I wrote a version using compose_cpp

, for example:

std::vector<std::string> composed;
composed.reserve(NUM);

clock_t start = clock();

for (auto const &a : addresses)
    composed.push_back(compose_cpp(a.email, a.domain));

      

        
        
        
      

    

This actually improves the timing a bit, but my guess is that it is mainly due to the time travel to create the vector itself from the time code and doesn't really matter to take care of it:

0.631 seconds for C++
1.21 seconds for C

      

        
        
        
      

    

These results are highly dependent on the standard implementation of the library, in particular because it std::string

implements short string optimizations. Running the same code on the same hardware, but using an implementation that this optimization lacks (nuwen MinGW distribution gcc 4.9.1, in my case) gives completely different results:

2.689 seconds for C++
1.131 seconds for C

      

        
        
        
      

    

In this case, the C code is slightly faster than the VC ++ code, but the C ++ code slowed down by about 4 times. I've tried several different compiler flags (-O2 versus -O3, etc.), but they only had minimal effect - for this test, the lack of short string optimization clearly dominates the other factors.

Bottom line: I think this confirms that C ++ code can be significantly faster than C code, but achieving that speed largely depends on the quality of the implementation. If the implementation does not provide short string optimizations, the C ++ code may be 2x slower rather than 2x faster than the C version.