Hi,
thanks for trying to help, but I've just wrote a little benchmarking
program, which proves that its ALOT more than 10%
Here is the code (which works on windows, because it uses GetTickCount()):
DWORD now;
int limit = 1000000; //size of string
char temp; //used later to hold each char in the string
std::string blah; //create a string
blah.reserve(limit); //reserve limit size of memory
//File the string up with Xs, not used in the benchmark
for (int i = 0; i<limit; i++) {
blah.append("X");
}
now = GetTickCount(); //Used for timing
//Now we have a file full of Xs..
//In this example we won't print the X out, instead
//we will just set some varible it...kinda pointless :)
//but printf is slow and takes away what we are actually benchmarking
for (int i=0; i<limit; i++) {
temp = blah.at(i) ;
}
printf("Done 1 in %dms", GetTickCount() - now);
now = GetTickCount(); //Used for timing
//Now we do the same thing, but with c char pointers
char *blah_c = (char *)blah.c_str();
for (char *ptr = blah_c; ptr < blah_c + limit; ptr++) {
temp = *ptr;
}
printf("Done 2 in %dms\n", GetTickCount() - now);
Here are the results run 10 times:
Done 1 in 235ms Done 2 in 0ms
Done 1 in 235ms Done 2 in 15ms
Done 1 in 234ms Done 2 in 16ms
Done 1 in 234ms Done 2 in 0ms
Done 1 in 235ms Done 2 in 0ms
Done 1 in 265ms Done 2 in 0ms
Done 1 in 250ms Done 2 in 16ms
Done 1 in 234ms Done 2 in 16ms
Done 1 in 265ms Done 2 in 0ms
Done 1 in 234ms Done 2 in 0ms
You are welcome to point out any mistakes I've made, BUT the reason for
example 1 is slow is because its doing this:
blah.at(0)
//internal c array is currently pointed at 0
//work out 0 + 0
//set a c pointer to 0 + 0
//return memory that pointer is pointing at;
blah.at(1)
//internal c array is again pointed at 0
//work out 0 + 1
//set a c pointer to 0 + 1
//return memory that pointer is pointing at;
blah.at(2)
//internal c array is yet again pointed at 0
//work out 0 + 2
//set a c pointer to 0 + 2
//return memory that pointer is pointing at;
Now the code using the char pointer does this
*ptr
//return memory that ptr is pointing at;
ptr++;
//increment ptr;
*ptr
//return memory that ptr is pointing at;
ptr++
//increment ptr;
*ptr
//return memory that ptr is pointing at;
ptr++
//increment ptr;
If I was any good at asm I could most likly write that down in opcodes..
I can imagine that Iterators were designed to stop this being slow, because
the iterator keeps a internal pointer, just like my ptr did.
You suggested using find with iterators, this might be the solution to my
problem, but its getting late now and I have some other stuff to do now,
I'll try that out tommorow.
Thanks for the feedback
Andrew
"John Harrison" <jo*************@hotmail.com> wrote in message
news:2g************@uni-berlin.de...
|
| "Andrew Brampton" <an****@bramp.freeserve.co.uk> wrote in message
| news:Xi*******************@wards.force9.net...
| > Thanks for all the answers, but maybe I wasn't clear enough.
| >
| > Take for example this:
| > string blah = "1234567890";
| > for (int i=0; i<10; i++) {
| > printf( blah.at(i) );
| > }
| >
| > This can be improved in C by doing:
| > char [] blah = "1234567890"
| > for (char *ptr = blah; ptr < blah + 10; ptr++) {
| > printf( ptr );
|
| printf( *ptr );
|
| > }
| >
| > In such a trival example the speed incrase is negletable... but say the
| > string blah was a megabyte big, then the 2nd example will be alot
faster.
|
| No it wouldn't. You seem to have some misconception about how integer
| offsets and strings work together. Now sure the second example might be
10%
| faster on a small string, but if so it would be 10% faster on any length
of
| string.
|
| >
| > Now I was wondering if there was some similar way to do the 2nd example,
| but
| > in C++. Something I hope like this:
| > string blah = "1234567890";
| > string_pointer ptr = blah; //some magical class I wish exists
| > for (; ptr < blah.end() ; ptr++) {
| > printf( ptr )
| > }
| >
| > I know in this basic example the iterator would be used... but refer to
my
| > orginal question since I'm sure a iterator can't be used in that case.
| >
|
| You can use an iterator, use it in combination with std::find, instead of
| std::string::find_first_of
|
| But I really don't see what you are worred about, all these methods are
| essentially equivalent.
|
| john
|
|
