Thread: Clearing a string

Lets say i need a c++ string to be cleared in a loop each looping.

Which one is better?

N°1

Code:

    for(j=0; j<=9; j++)    
    {
         string   current;        
         current+= dataset[array[j]];
    }

N°2

Code:

     string   current; 
     for(j=0; j<=9; j++)    
     {
         string = "";        
         current+= dataset[array[j]];
     }

I think about the second because the string wont get declared everytime but maybe its the same?

I think it might also make sense to use string.clear() if you are not going to use it after the loop. Avoiding creating expensive objects within a loop is a kind of optimization that you can do as you go along, since unlike many other premature optimizations, it doesn't particularly affect the readability and quality of the code.

Of course, it is also possible that this code is not called very often, and the strings in question will not be particularly large, so it really won't affect the observable performance of the program in any way, in which case you might stop worrying and follow the rule-of-thumb that the scope of variables should be limited to where they are used.

Hmm, interesting, thank you Memloop and Anon!

Actually it will be called more than a 1000 times so i guess ill be better off with string.clear().

Otherwise it would be declared a 1000 times on the stack as i understand.

Declaring something on the stack is a small problem. The larger problem is that for each of the 10 iterations, the string object declared in the loop would have to deallocate any dynamic memory, and allocate new memory for the next iteration. That's where the expense of a std::string comes from.

The clear method only marks the string internally as empty, but doesn't actually deallocate any memory. The capacity remains the same, and during the next iteration the same memory can be reused.

Another hidden cost might be if the string dynamically grows during the iteration. If you keep the same instance, it is quite likely that it grows to a sufficient size already during the first iteration, which means that any reallocations would be avoided during the following iterations.

(This applies to MingW's implementation of std::string.)

Well, you might be right. There is indeed often no need to squeeze out performance (and running this loop 1000 times might not be much indeed).

However, I think it is important to be aware of such issues (and I don't trust the compiler to be able to optimize such complicated operations - I suspect that it wouldn't even be legal for it to optimize constructors/destructors away in such contexts?).

Code:

#include <string>
#include <ctime>
#include <iostream>

using namespace std;

int main()
{
    clock_t start = clock();

    for (unsigned i = 0; i != 50000; ++i) {
        //string s;
        for (unsigned j = 0; j != 10; ++j) {
            string s;
            //s.clear();
            s += "Hello world";
            s += "Goodbye world!";
            s += "abcdefghijklmnopqrstuvwxyz";
        }
    }
    std::cout << clock() - start << '\n';
}

That's a really rough test. But depending on where the string is declared, my times are 328 and 796.

However, note that this is called 50000 times, with 1000 times the difference wouldn't even be measurable.