좋은 질문입니다. 나는 벡터 테스트를 빠르게 할 수있는 간단한 수정을 기대하기 위해 여기에왔다. 예상대로 작동하지 않았습니다!

최적화가 도움이되지만 충분하지 않습니다. 최적화를 통해 UseArray와 UseVector의 성능 차이는 여전히 2 배입니다. 흥미롭게도 UseVector는 최적화없이 UseVectorPushBack보다 상당히 느 렸습니다.

# g++ -Wall -Wextra -pedantic -o vector vector.cpp
# ./vector
UseArray completed in 20.68 seconds
UseVector completed in 120.509 seconds
UseVectorPushBack completed in 37.654 seconds
The whole thing completed in 178.845 seconds
# g++ -Wall -Wextra -pedantic -O3 -o vector vector.cpp
# ./vector
UseArray completed in 3.09 seconds
UseVector completed in 6.09 seconds
UseVectorPushBack completed in 9.847 seconds
The whole thing completed in 19.028 seconds

아이디어 # 1-malloc 대신 new [] 사용

객체가 생성되도록 UseArray로 변경 malloc()을 시도했습니다 new[]. 개별 필드 할당에서 Pixel 인스턴스 할당으로 변경 내부 루프 변수의 이름을로 바꿉니다 j.

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

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

        // Same speed as malloc().
        Pixel * pixels = new Pixel[dimension * dimension];

        for(int j = 0 ; j < dimension * dimension; ++j)
            pixels[j] = Pixel(255, 0, 0);

        delete[] pixels;
    }
}

놀랍게도 (나에게), 그러한 변화들 중 어느 것도 변화를 일으키지 않았습니다. new[]기본적으로 변경되어 모든 픽셀이 구성되는 것은 아닙니다 . gcc는를 사용할 때 기본 생성자 호출을 최적화 할 수 new[]있지만 사용할 때는 최적화 하지 않는 것 같습니다 vector.

아이디어 # 2-반복되는 연산자 [] 호출 제거

또한 트리플 operator[]조회를 제거 하고에 대한 참조를 캐시 하려고 했습니다 pixels[j]. 실제로 UseVector 속도가 느려졌습니다! 죄송합니다.

for(int j = 0; j < dimension * dimension; ++j)
{
    // Slower than accessing pixels[j] three times.
    Pixel &pixel = pixels[j];
    pixel.r = 255;
    pixel.g = 0;
    pixel.b = 0;
}

# ./vector 
UseArray completed in 3.226 seconds
UseVector completed in 7.54 seconds
UseVectorPushBack completed in 9.859 seconds
The whole thing completed in 20.626 seconds

아이디어 # 3-생성자 제거

생성자를 완전히 제거하는 것은 어떻습니까? 그러면 gcc는 벡터가 생성 될 때 모든 객체의 구성을 최적화 할 수 있습니다. Pixel을 다음과 같이 변경하면 어떻게됩니까?

struct Pixel
{
    unsigned char r, g, b;
};

결과 : 약 10 % 더 빠릅니다. 배열보다 여전히 느립니다. 흠.

# ./vector 
UseArray completed in 3.239 seconds
UseVector completed in 5.567 seconds

아이디어 # 4-루프 인덱스 대신 반복자를 사용

어떻게 사용에 대한 vector<Pixel>::iterator대신 루프 인덱스의?

for (std::vector<Pixel>::iterator j = pixels.begin(); j != pixels.end(); ++j)
{
    j->r = 255;
    j->g = 0;
    j->b = 0;
}

결과:

# ./vector 
UseArray completed in 3.264 seconds
UseVector completed in 5.443 seconds

아뇨, 다르지 않습니다. 적어도 느리지 않습니다. 나는 이것이 Pixel&참조를 사용한 # 2와 비슷한 성능을 가질 것이라고 생각했다 .

결론

일부 스마트 쿠키는 벡터를 배열만큼 빠르게 루프하는 방법을 알아 내더라도의 기본 동작을 잘 설명하지 못합니다 std::vector. 컴파일러는 모든 C ++를 최적화하고 STL 컨테이너를 원시 배열만큼 빠르게 만들 수있을만큼 똑똑합니다.

결론은 컴파일러가를 사용할 때 no-op 기본 생성자 호출을 최적화 할 수 없다는 것 std::vector입니다. 일반을 사용하면 잘 new[]최적화됩니다. 그러나와는 아닙니다 std::vector. 코드를 다시 작성하여 만트라에 직면하는 생성자 호출을 제거 할 수 있다고해도 “컴파일러는 당신보다 똑똑합니다. STL은 평범한 C만큼 빠릅니다. 걱정하지 마십시오.”

답변

UseVector completed in 3.74482 seconds
UseArray completed in 3.70414 seconds

UseArray completed in 0.269 seconds
UseVector completed in 1.665 seconds
UseVectorPushBack completed in 7.309 seconds
The whole thing completed in 9.244 seconds

struct Pixel
{
    Pixel();
    Pixel(unsigned char r, unsigned char g, unsigned char b);

    unsigned char r, g, b;
};

#include "Pixel.h"

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

#include "Pixel.h"
[rest of test harness without class Pixel]
[UseArray now uses new/delete not malloc/free]

$ g++ -O3 -c -o Pixel.o Pixel.cc
$ g++ -O3 -c -o main.o main.cc
$ g++ -o main main.o Pixel.o

UseArray completed in 2.78 seconds
UseVector completed in 1.651 seconds
UseVectorPushBack completed in 7.826 seconds
The whole thing completed in 12.258 seconds

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

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

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

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

    int dimension = 999;
    Pixel * pixels = new Pixel[dimension * dimension];

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

UseArray completed in 0.254 seconds
UseVector completed in 0.249 seconds
UseVectorPushBack completed in 7.298 seconds
The whole thing completed in 7.802 seconds

void UseVectorCtor()
{
    TestTimer t("UseConstructor");

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

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

const size_t dimension = 1000;

void UseArray() {
    TestTimer t("UseArray");
    for(size_t j = 0; j < dimension; ++j) {
        Pixel* pixels = new Pixel[dimension * dimension];
        for(size_t i = 0 ; i < dimension * dimension; ++i) {
            pixels[i].r = 255;
            pixels[i].g = 0;
            pixels[i].b = (unsigned char) (i % 255);
        }
        delete[] pixels;
    }
}

void UseVector() {
    TestTimer t("UseVector");
    for(size_t j = 0; j < dimension; ++j) {
        std::vector<Pixel> pixels(dimension * dimension);
        for(size_t i = 0; i < dimension * dimension; ++i) {
            pixels[i].r = 255;
            pixels[i].g = 0;
            pixels[i].b = (unsigned char) (i % 255);
        }
    }
}

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

    UseArray();
    UseVector();

    return 0;
}

UseArray completed in 3.06 seconds
UseVector completed in 4.087 seconds
The whole thing completed in 10.14 seconds

class Tester {
public:
    static int count;
    static int count2;
    Tester() { count++; }
    Tester(const Tester&) { count2++; }
};
int Tester::count = 0;
int Tester::count2 = 0;

int main() {
    std::vector<Tester> myvec(300);
    printf("Default Constructed: %i\nCopy Constructed: %i\n", Tester::count, Tester::count2);

    return 0;
}

Default Constructed: 1
Copy Constructed: 300

Pixel pixel;
for (auto i = 0; i < N; ++i) vector[i] = pixel;

Pixel pixel;
for (auto i = 0; i < N; ++i) {
    vector[i].r = pixel.r;
    vector[i].g = pixel.g;
    vector[i].b = pixel.b;
}

int main() {
    Tester* myvec = new Tester[300];

    printf("Default Constructed: %i\nCopy Constructed:%i\n", Tester::count, Tester::count2);

    delete[] myvec;

    return 0;
}

Default Constructed: 300
Copy Constructed: 0

Pixel(const Pixel&) {}

UseArray completed in 2.617 seconds
UseVector completed in 2.682 seconds
The whole thing completed in 5.301 seconds