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.