Was ist die effizienteste Methode zum initialisieren einer 3D-Vektor?

Ich habe einen 3D-Vektor mit Strings in C++:

vector<vector<vector<string>>> some_vector

Dass ich versuche zu finden ist eine schnelle Methode zum reservieren von Speicher für Sie.

Ich zu definieren versuchte es mit zwei verschiedenen Methoden wie folgt:

#include<vector>
#include<iostream>
#include<ctime>
using namespace std;

#define DIM1 100
#define DIM2 9
#define DIM3 120

int main()
{
    clock_t t1_start = clock();
    vector<vector<vector<string>>> vec1(DIM1, vector<vector<string>>(DIM2, vector<string>(DIM3)));
    clock_t t1_end = clock();
    double diff1 = (t1_end - t1_start) / double(CLOCKS_PER_SEC);

    clock_t t2_start = clock();
    vector<vector<vector<string>>> vec2;
    vec2.resize(DIM1);
    for(int i = 0; i < DIM1; i++)
    {
        vec2[i].resize(DIM2);
        for(int j = 0; j < DIM2; j++)
            vec2[i][j].resize(DIM3);
    }
    clock_t t2_end = clock();

    double diff2 = (t2_end - t2_start) / double(CLOCKS_PER_SEC);

    cout<<"1st definition used time: "<<diff1<<"s"<<endl;
    cout<<"2nd definition used time: "<<diff2<<"s"<<endl;
}

Ich erwarten, dass die erste Methode (vec1) schneller sein könnte als die 2. (vec2).

Aber es stellte sich heraus, dass die 1. Methode ist viel langsamer als die 2te. Auf meinem Rechner, die 1. Methode verwendet 0.245 Sekunden, während die 2. Methode verwendet 0.152 Sekunden.

Außerdem, wenn ich schalten Sie den Datentyp int, der 1. nahm man 0.058 Sekunden, und die 2. dauerte 0.004.

Kann ich wissen, was die Ursache dieser Differenz? Und ist es besser zuordnen von Speicher für einen 3D-Vektor?

Vielen Dank im Voraus.

Sind Sie mit einem optimierten bauen?
Was werden Sie tun, erfordert diese hohe Leistung für die Zuordnung Ihrer Daten Struktur? Wenn Sie etwas benötigen, das super-schnelle, dreidimensionale std::vector<>s kann nicht sein, was du bist suchen für.
Wenn die Dimensionen konstant sind, warum dann nicht std::array<std::array<std::array<std::string, DIM3>, DIM2>, DIM1> ?
Es könnte sein, weil es könnte mehr Kopien in den ersten Aufruf gegen den zweiten Anruf
Wenn Sie wechseln, um die Reihenfolge der tests, wie wirkt sich das auf das timing? (Und stellen Sie sicher, Optimierungen aktiviert sind.) Erwägen Sie die Verwendung einer bessere benchmarking-tool, verwendet ein high-precision timer und läuft viele Iterationen zu glätten verschiedene cache-und externe Umwelt-Effekte.
Danke für die Antwort. Dann, welche Art von Datenstruktur, die würden Sie empfehlen?
Gegeben, dass Sie haben nicht erklärt, warum Sie wollen, dass die Daten-Struktur, wie Sie gehen zu verwenden, oder aus welchem Grund die Initialisierung muss schnell sein, ich dachte, Sie sollten das tun, was die Antwort vorgeschlagen, und verwenden Sie einen einzigen chunk-Speicher haben, können Sie index dreidimensional.

InformationsquelleAutor ChangeMyName | 2013-08-05

c++performance vector

13

Kann ich wissen, was die Ursache dieser Differenz?

Die erste version, konstruiert ein 2-d Vektor, indem Sie eine 1-d-Vektor, und dann baut den 3-d-Vektor durch das kopieren. Dies könnte langsamer sein als die Größe der Vektoren, ohne Sie zu kopieren. Allerdings würde ich hoffen, dass der Unterschied sollte vernachlässigbar sein, wenn Sie Gebäude mit Optimierung.

Und ist dort besserer Weg, um Speicher für ein 3D-Vektor?

Könnte es besser sein, zu einem einzigen zusammenhängenden array, eingewickelt in eine Klasse, bietet multi-dimensional-Accessoren verfügen. Dadurch wäre die Zuordnung viel einfacher, und würde auch vermeiden, dass einige Zeiger-Dereferenzierung beim Zugriff auf Elemente (auf Kosten von ein bisschen Arithmetik). So etwas wie dieses:
```
template <typename T>
class vector3d {
public:
    vector3d(size_t d1=0, size_t d2=0, size_t d3=0, T const & t=T()) :
        d1(d1), d2(d2), d3(d3), data(d1*d2*d3, t)
    {}

    T & operator()(size_t i, size_t j, size_t k) {
        return data[i*d2*d3 + j*d3 + k];
    }

    T const & operator()(size_t i, size_t j, size_t k) const {
        return data[i*d2*d3 + j*d3 + k];
    }

private:
    size_t d1,d2,d3;
    std::vector<T> data;
};
```
- Bounds checking ist oft ein Grund, dass die Vektoren verwendet werden. Hinzufügen behauptet Ihren Mitarbeitern, dass jeder der Indizes unter Ihre dimension ist eine gute Idee.
- In der Tat, könnte dies tun, mit einem Bereich-geprüft at Funktion, und verschiedenen anderen bits und Stücke, mehr zu sein als eine Skizze, wie würden Sie implementieren Ihre eigenen container.
InformationsquelleAutor Mike Seymour
4

Ich denke, ich würde es optimieren, indem Sie Ihr einen großen block Speicher anstelle von vielen kleinen. Dieser ist nur 2D statt 3D, gibt aber die grundlegende Idee:
```
template <class T>
class matrix { 
    size_t columns_;
    std::vector<T> data;
public:
    matrix(size_t columns, size_t rows) : columns_(columns), data(columns*rows) {}

    T &operator()(size_t column, size_t row) { return data[row*columns_+column]; }
};
```
Für 3D, Sie benötigen, um mit "Ebenen" (oder so) zusammen mit Zeilen und Spalten, aber die Grundidee ist ziemlich das gleiche.

InformationsquelleAutor Jerry Coffin
0

Beim initialisieren einen Vektor der Vektoren in der ersten Methode, einen temporären Vektor zugeordnet ist, und dann kopiert in die äußere Vektor die gewünschte Anzahl von Zeiten. Dies bedeutet, dass Sie eine extra-Zuweisung, die ist unnötig und die neuen Elemente werden initialisiert durch kopieren der Wert aus einer anderen Datenstruktur, die verwendet mehr Speicher zugreift.

Größe der Vektoren gemäß der zweiten Methode wird mehr hässlich, sondern vermeidet die zusätzliche Zuteilung. Des weiteren wurde die neue Elemente werden erstellt, indem der Standardkonstruktor und brauchen nicht zu kopieren von anderen Vektoren. Diese werden auch schneller.

Wenn es auf Geschwindigkeit ankommt (und vielleicht ist es noch nicht, die vorzeitige Optimierung und alles, was), dann müssen Sie die zweite Methode verwenden (ODER ein single-block-Aufteilung, wie vorgeschlagen, durch die anderen Antworten). Ich habe nicht glauben, dass ein compiler kann einfach "optimieren" entfernt die Ineffizienz der ersten Methode.

InformationsquelleAutor Neil Kirk

Initialisierung eines 3D-string-Vektor wird initialisiert den Vektor-Struktur, die für jede dimension und für jeden index, zum Beispiel:

  vector<vector<vector<string> > > myvector; //declare the 3D vector
  for(k=0; k<3; k++)
  {
    myvector.push_back(vector<vector<string> >()); //initialize the first index with a 2D vector
    for(i=0; i<4; i++)
    {
      myvector[k].push_back(vector<string>()); //initialize the 2 index with a row of strings
      for(j=0; j<4; j++)
      {
         result = " whatever you want to insert in the vector element";
         myvector[k][i].push_back(result); //fulfill the last index regularly
      } 
    }
  }

InformationsquelleAutor fb77

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.