Her zaman std::vector "bir dizi olarak," blah blah blah. uygulanan genel hikmeti olduğunu düşündüm Bugün gittim ve test, öyle değil gibi görünüyor:

İşte bazı test sonuçları:

UseArray completed in 2.619 seconds
UseVector completed in 9.284 seconds
UseVectorPushBack completed in 14.669 seconds
The whole thing completed in 26.591 seconds

Bu 3 - 4 kez daha yavaş! Gerçekten "vector birkaç nanosecs" yorum. daha yavaş olabilir için haklı çıkarmaz

Ve kullandığım kod:

#include <cstdlib>
#include <vector>

#include <iostream>
#include <string>

#include <boost/date_time/posix_time/ptime.hpp>
#include <boost/date_time/microsec_time_clock.hpp>

class TestTimer
{
public:
    TestTimer(const std::string & name) : name(name),
        start(boost::date_time::microsec_clock<boost::posix_time::ptime>::local_time())
    {
    }

    ~TestTimer()
    {
        using namespace std;
        using namespace boost;

        posix_time::ptime now(date_time::microsec_clock<posix_time::ptime>::local_time());
        posix_time::time_duration d = now - start;

        cout << name << " completed in " << d.total_milliseconds() / 1000.0 <<
            " seconds" << endl;
    }

private:
    std::string name;
    boost::posix_time::ptime start;
};

struct Pixel
{
    Pixel()
    {
    }

    Pixel(unsigned char r, unsigned char g, unsigned char b) : r(r), g(g), b(b)
    {
    }

    unsigned char r, g, b;
};

void UseVector()
{
    TestTimer t("UseVector");

    for(int i = 0; i < 1000;   i)
    {
        int dimension = 999;

        std::vector<Pixel> pixels;
        pixels.resize(dimension * dimension);

        for(int i = 0; i < dimension * dimension;   i)
        {
            pixels[i].r = 255;
            pixels[i].g = 0;
            pixels[i].b = 0;
        }
    }
}

void UseVectorPushBack()
{
    TestTimer t("UseVectorPushBack");

    for(int i = 0; i < 1000;   i)
    {
        int dimension = 999;

        std::vector<Pixel> pixels;
            pixels.reserve(dimension * dimension);

        for(int i = 0; i < dimension * dimension;   i)
            pixels.push_back(Pixel(255, 0, 0));
    }
}

void UseArray()
{
    TestTimer t("UseArray");

    for(int i = 0; i < 1000;   i)
    {
        int dimension = 999;

        Pixel * pixels = (Pixel *)malloc(sizeof(Pixel) * dimension * dimension);

        for(int i = 0 ; i < dimension * dimension;   i)
        {
            pixels[i].r = 255;
            pixels[i].g = 0;
            pixels[i].b = 0;
        }

        free(pixels);
    }
}

int main()
{
    TestTimer t1("The whole thing");

    UseArray();
    UseVector();
    UseVectorPushBack();

    return 0;
}

Ne yanlış falan mıyım? Ya az önce koptu bu performans efsane var mı?

Edit: MSVS2005 Serbest modu kullanıyorum.

MSVC, #define _SECURE_SCL 0 8 azaltır* *yarı yarıya (yere 4 saniye getirme). Bu gerçekten çok büyük IMO.

Aşağıdaki kullanarak:

-O3 Time.cpp -ben g <MyBoost>
./bir.dışarı
F 2.196 saniye içinde tamamlandı
UseVector 4.412 saniyede tamamladı
UseVectorPushBack 8.017 saniyede tamamladı
Her şeyi 14.626 saniyede tamamladı

Dizi vektör olarak iki kat daha hızlı.

Amavektör üzerinde çalışırken daha fazla detay kodu de bu beklenir baktıktan sonra; iki kez ve yalnızca bir kez. Not: yeniden boyutlandırdığınızda() sadece bellek ayrılırken de vektör üzerinden çalışan ve her üye kurucu çağırmıyorsun vektör.

Vektör yalnızca bir kez, her bir nesne başlatır, böylece yeniden Düzenlenmesi biraz kod:

 std::vector<Pixel>  pixels(dimensions * dimensions, Pixel(255,0,0));

Şimdi yine aynı zamanlama yapıyor:

-O3 Time.cpp -ben g <MyBoost>
./bir.dışarı
UseVector 2.216 saniye içinde tamamlandı

Vektör şimdi performans sadece biraz daha kötü bir dizi daha. IMO bu fark önemsİzdİr ve şeyler test ile ilgili bir sürü neden olabilir.

Ben de hesaba o sen değilsin düzgün başlatılıyor Yok Piksel nesne UseArrray() yöntemi olarak ne yapıcı/yıkıcı "değil," (bu olmayabilir bir sorun için bu basit bir sınıf ama bir şey biraz daha karmaşık (ıe ile işaretçileri veya üyeleri ile işaretçileri) sorunlara neden olur.