A howl on the wind…

(There is also an opposite int-to-string performance test.)

A performance benchmark of which method is faster of converting an std::string to an integer. The goal is ending up with an integer with the value represented in an std::string.

The tested methods are:

• atoi()
• atol()
• strtol()
• std::stringstream
• std::stringstream, reusing the object
• boost::lexical_cast<int>()
• a hand-written naive loop

Source for the test is at speed-string-to-int.cpp with cycle.h.

The compilers are Microsoft Visual C++ 2010 Express as VC10 with _SECURE_SCL disabled, and GNU g++ 4.3.2.

Tests were run for converting 100000 string containing integers in the range -50000 to 50000. The result for atoi() is set as the baseline 100% and the other numbers is time spent relative to that. The naive loop wins by a large margin.

(There is also an opposite string-to-int performance test.)

(Updated 2010-03-05 to compare speeds of reusing the string object versus not, and to add strstream and boost::spirit::karma tests.)

A performance benchmark of which method is faster of converting an integer to an std::string. The goal is ending up with an std::string representation of the input integer.

The tested methods are:

• sprintf() into a char[] buffer, then std::string(buffer)
• snprintf() into a char[] buffer, then std::string(buffer)
• sprintf() into &std::string[0], and .resize() to fit
• snprintf() into &std::string[0], and .resize() to fit
• output to a std::stringstream, then std::string = stream.str()
• as above, but reusing the stringstream object
• std::strstream(&string[0]) then .resize(stream.pcount())
• std::string = boost::lexical_cast<std::string>()
• Boost.Spirit.Karma generate into a char[] buffer, then std::string(buffer)

Source for the test is at speed-convert-int-to-string.cpp with cycle.h.

The compilers are Microsoft Visual C++ 2010 Express as VC10 with _SECURE_SCL disabled, GNU g++ 4.3.2, and clang++ from svn.

Tests were run for converting 100000 integers in the range -50000 to 50000. The result for sprintf() is set as the baseline 100% and the other numbers is time spent relative to that.

Boost.Spirit.Karma is by far the fastest. It is also worth noting that reusing the string object makes the boost::lexical_cast solution slower, presumably because it ruins some optimization opportunities, so that is a case for checking whether reusing your objects really is faster…

The clang++ results are directly comparable with the g++ results; run on the same machine, and the sprintf() results deviate a mere 0.07%. clang++ could not compile the karma test, so that has been omitted.

A performance benchmark of which method is faster of finding all unique elements of a vector. The goal is having an ordered container with just the unique elements, where the tested methods are std::sort()+std::unique()+erase(), versus inserting into a separate std::set, versus inserting into std::unordered_set and then into std::set, and finally inserting into boost::unordered_set and then into std::set.

Source for the integer version is speed-find-unique-int.cpp with cycle.h.

The compilers are Microsoft Visual C++ 2010 Express as VC10 with _SECURE_SCL disabled, and GNU g++ 4.3.2.

Tests were run with 10000, 100000, 1000000, and 10000000 elements, of which 1000 are unique. For my own amusement I also tried 10000 and 32767 unique elements, but relative speeds were roughly the same.

The set.insert() column describes how much time was spent in relation to the same operation with sort()+unique()+erase(). For integers, this number is above 100% for all tests, meaning it is slower to use std::set.

And then there is the std::string version, source speed-find-unique-string.cpp with cycle.h.

For VC10, all is as expected from the integer results. However, for g++ it is considerably faster to use std::set.

I tried a test for g++ where I force a full string copy to get around g++’s copy-on-write implementation, but it didn’t change much.

http://tinodidriksen.com/uploads/code/cpp/dynamic-string-box.cpp

#include <iostream>
#include <algorithm>
#include <string>
#include <vector>

int main() {
    std::vector<std::string> strs;
    strs.push_back("Hello World!");
    strs.push_back("This is a text line.");
    strs.push_back("Shorter line.");

    size_t maxl = 0;
    for (size_t i = 0 ; i<strs.size() ; ++i) {
        maxl = std::max(maxl, strs[i].length());
    }

    std::cout << std::string(maxl+4, '*') << std::endl;
    for (size_t i = 0 ; i<strs.size() ; ++i) {
        std::cout << "* "
            << strs[i]
            << std::string(maxl-strs[i].length()+1, ' ')
            << "*" << std::endl;
    }
    std::cout << std::string(maxl+4, '*') << std::endl;
}