Re: about new and delete

Sam wrote:


  With how many elements?

  Sure, std::list may be faster when we have 10 elements. However, it
quickly becomes slower when the amount of elements grows even slightly.
And I'm not talking about a million elements. In my system the cutoff
point seems to be about 30 elements: When there are at least that many
elements, std::vector becomes faster than std::list. Of course the
larger the amount of elements, the faster std::vector will be compared
to std::list.

  So if the original poster wants to handle, for example, 32 elements,
using std::list will be a complete loss in all possible ways. Not only
will it be slower, but the code will be more complicated.

  (Not that it really matters with 32 elements anyways. However, it does
matter if the amount of elements grows much larger, let's say for
example 1000 elements. In that case std::vector beats std::list by a
factor of 10.)

  And no, I did the test fair and square. I did not "cheat" by using
reserve() or reusing a std::vector instance on the outer scope: I
instantiated a std::vector at each loop and destroyed it at the end, the
same as with the std::list.

  For comparison, I also used std::deque. Here's the program:

//--------------------------------------------------------------------------
#include <list>
#include <vector>
#include <ctime>
#include <iostream>

int main()
{
    const int iterations = 1000000;
    const int elements = 26;

    int sum = 0;

    std::clock_t iClock = std::clock();
    for(int iteration = 0; iteration < iterations; ++iteration)
    {
        std::list<int> l;
        for(int i = 0; i < elements; ++i) l.push_back(i);
        for(std::list<int>::iterator b = l.begin(), e = l.end();
            b != e; ++b)
            sum += *b;
    }
    std::cout << double(std::clock() - iClock) / CLOCKS_PER_SEC
              << std::endl;

    iClock = std::clock();
    for(int iteration = 0; iteration < iterations; ++iteration)
    {
        std::vector<int> v;
        for(int i = 0; i < elements; ++i) v.push_back(i);
        const size_t amount = v.size();
        for(size_t i = 0; i < amount; ++i)
            sum += v[i];
    }
    std::cout << double(std::clock() - iClock) / CLOCKS_PER_SEC
              << std::endl;

    iClock = std::clock();
    for(int iteration = 0; iteration < iterations; ++iteration)
    {
        std::deque<int> v;
        for(int i = 0; i < elements; ++i) v.push_back(i);
        const size_t amount = v.size();
        for(size_t i = 0; i < amount; ++i)
            sum += v[i];
    }
    std::cout << double(std::clock() - iClock) / CLOCKS_PER_SEC
              << std::endl;

    return sum;
}
//--------------------------------------------------------------------------

  (I calculate and return the 'sum' from main to make sure the compiler
doesn't optimize anything away.)

  I compiled it with "-O3 -march=native". Here are some results:

10 elements:
std::list: 0.82 seconds.
std::vector: 1.4 seconds.
std::deque: 0.34 seconds.

26 elements:
std::list: 2.2 seconds.
std::vector: 2.12 seconds.
std::deque: 0.42 seconds.

100 elements:
std::list: 8.25 seconds.
std::vector: 3.14 seconds.
std::deque: 0.78 seconds.

1000 elements:
std::list: 79.8 seconds.
std::vector: 7.18 seconds.
std::deque: 8.46 seconds.

  Not surprisingly std::deque beats the other two hands down when the
amount of elements is smallish. (When the amount of elements grows
significantly, std::vector catches up with its lower constant factors.)

  Most importantly, std::deque beats your proposed solution in this
particular case (ie. about 10 elements) in all possible counts.


  However, when splicing is not required, std::list offers no value added.


  Now you'll have to explain why less code = better performance in the
case of std::deque, which you seem to blissfully ignore as an
alternative. (Note how you can use std::deque in the exact same way as
you can use std::vector, so there's no penalty with regard to code
clarity and simplicity.)


  Why would I use the verbose std::list when std::deque beats it hands
down and is easier to use?