Re: Use of std::vector slower than arrays?

Hi.

I was writing a bignum package in C++. I noticed that a version of an
addition routine I had written using std::vector was a lot slower than
one using simple "C-style" arrays, and this
raises the question: is using std::vector slower than using arrays???

This is the code for the simple C-style add function using C-style
arrays and pointers.

// Element-by-element array add.
Digit arradd(Digit *a, Digit *b, Digit *c, int len)
{
   // set up pointers
   Digit *ap(a), *bp(b), *cp(c);

   // loop through the digits
   Digit carry(0);
   while(len--)
   {
      Digit tmp(*bp + *cp + carry); // add b/c's digits
      carry = carry ? (tmp <= *bp) : (tmp < *bp); // check overflow/
carry
      *ap = tmp; // set result
      ap++; bp++; cp++; // increment pointers
   }

   return(carry);
}

This is the code for the one using std::vector:

// Addition using std::vector.
Digit vecadd(std::vector<Digit> *a,
            const std::vector<Digit> *b,
            const std::vector<Digit> *c,
            int len)
{
   // set up iterators
   std::vector<Digit>::iterator ai(a->begin());
   std::vector<Digit>::const_iterator bi(b->begin());
   std::vector<Digit>::const_iterator ci(c->begin());

   // loop through the digits
   Digit carry(0);
   while(len--)
   {
      Digit tmp(*bi + *ci + carry); // add b/c's digits
      carry = carry ? (tmp <= *bi) : (tmp < *bi); // check overflow/
carry
      *ai = tmp; // set result
      ai++; bi++; ci++; // increment iterators
   }

   return(carry);
}

(Note: These routines assume all inputs are of the same length.
That's because they're just for testing purposes. Also, "Digit"
is a machine-word length type, for my machine it'd be 32 bits
long, so each one represents 32 bits of the number. The ordering
is little-endian, so the least-significant digit comes first.)

The timings show the simple array-based approach takes 4
seconds for 100 million operations on 128 bit numbers on my
machine. The one with std::vector, though, takes a whopping
40-41 seconds -- a 10x performance hit! OUCH!!! Why is that?
Is there any way to get around that? I was told(*) it is better to use
std::vector than using arrays, as it encapsulates the low-level
pointer stuff, making the software less prone to bugs. But in this
program, I need speed.

(*) See this post:
http://groups.google.com/group/comp.lang.c++/msg/a66278b77597d648