Wie groß ist die Leistungslücke bei Verwendung von Arrays oder std :: -Vektoren in C ++?

In unserem C ++ - Kurs wird empfohlen, keine C ++ - Arrays mehr für neue Projekte zu verwenden. Soweit ich weiß, schlägt Stroustroup selbst vor, keine Arrays zu verwenden. Aber gibt es signifikante Leistungsunterschiede?

Die Verwendung von C ++ - Arrays mit new( dh die Verwendung dynamischer Arrays) sollte vermieden werden. Es gibt das Problem, dass Sie die Größe im Auge behalten müssen und sie manuell löschen und alle Arten von Reinigungsarbeiten durchführen müssen.

Es wird auch davon abgeraten, Arrays auf dem Stapel zu verwenden, da Sie keine Bereichsprüfung durchführen und beim Weitergeben des Arrays alle Informationen über seine Größe verloren gehen (Konvertierung von Array in Zeiger). boost::arrayIn diesem Fall sollten Sie ein C ++ - Array in eine kleine Klasse sizeeinschließen und eine Funktion und Iteratoren bereitstellen , um darüber zu iterieren.

Nun die std :: vector vs. native C ++ - Arrays (aus dem Internet):

// Comparison of assembly code generated for basic indexing, dereferencing, 
// and increment operations on vectors and arrays/pointers.

// Assembly code was generated by gcc 4.1.0 invoked with  g++ -O3 -S  on a 
// x86_64-suse-linux machine.

#include <vector>

struct S
{
  int padding;

  std::vector<int> v;
  int * p;
  std::vector<int>::iterator i;
};

int pointer_index (S & s) { return s.p[3]; }
  // movq    32(%rdi), %rax
  // movl    12(%rax), %eax
  // ret

int vector_index (S & s) { return s.v[3]; }
  // movq    8(%rdi), %rax
  // movl    12(%rax), %eax
  // ret

// Conclusion: Indexing a vector is the same damn thing as indexing a pointer.

int pointer_deref (S & s) { return *s.p; }
  // movq    32(%rdi), %rax
  // movl    (%rax), %eax
  // ret

int iterator_deref (S & s) { return *s.i; }
  // movq    40(%rdi), %rax
  // movl    (%rax), %eax
  // ret

// Conclusion: Dereferencing a vector iterator is the same damn thing 
// as dereferencing a pointer.

void pointer_increment (S & s) { ++s.p; }
  // addq    $4, 32(%rdi)
  // ret

void iterator_increment (S & s) { ++s.i; }
  // addq    $4, 40(%rdi)
  // ret

// Conclusion: Incrementing a vector iterator is the same damn thing as 
// incrementing a pointer.

Hinweis: Wenn Sie Arrays mit newund Nicht-Klassenobjekten (wie Plain int) oder Klassen ohne benutzerdefinierten Konstruktor zuweisen und Ihre Elemente zunächst nicht initialisieren newmöchten, kann die Verwendung von zugewiesenen Arrays Leistungsvorteile haben, da std::vectoralle Elemente mit initialisiert werden Standardwerte (z. B. 0 für int) bei der Erstellung (Dank an @bernie für die Erinnerung an mich).

Präambel für Mikrooptimierer

Merken:

"Programmierer verschwenden enorm viel Zeit damit, über die Geschwindigkeit unkritischer Teile ihrer Programme nachzudenken oder sich darüber Gedanken zu machen, und diese Effizienzversuche wirken sich tatsächlich stark negativ aus, wenn Debugging und Wartung in Betracht gezogen werden. Wir sollten beispielsweise kleine Effizienzvorteile vergessen." 97% der Zeit: Vorzeitige Optimierung ist die Wurzel allen Übels. Dennoch sollten wir unsere Chancen in diesen kritischen 3% nicht verpassen. "

(Dank Metamorphose für das vollständige Zitat)

Verwenden Sie kein C-Array anstelle eines Vektors (oder was auch immer), nur weil Sie glauben, dass es schneller ist, da es niedriger sein soll. Du würdest dich irren.

Verwenden Sie standardmäßig den Vektor (oder den an Ihre Anforderungen angepassten sicheren Container). Wenn Ihr Profiler ein Problem angibt, prüfen Sie, ob Sie ihn optimieren können, indem Sie entweder einen besseren Algorithmus verwenden oder den Container ändern.

Dies heißt, wir können zur ursprünglichen Frage zurückkehren.

Statisches / dynamisches Array?

Die C ++ - Array-Klassen verhalten sich besser als das C-Array auf niedriger Ebene, da sie viel über sich selbst wissen und Fragen beantworten können, die C-Arrays nicht beantworten können. Sie können nach sich selbst putzen. Und was noch wichtiger ist: Sie werden normalerweise mithilfe von Vorlagen und / oder Inlining geschrieben. Dies bedeutet, dass das, was beim Debuggen von viel Code erscheint, in wenig oder gar keinen Code aufgelöst wird, der im Release-Build erstellt wurde, was keinen Unterschied zu ihrer integrierten, weniger sicheren Konkurrenz bedeutet.

Alles in allem fällt es in zwei Kategorien:

Dynamische Arrays

Die Verwendung eines Zeigers auf ein malloc-ed / new-ed-Array ist bestenfalls so schnell wie die std :: vector-Version und viel weniger sicher (siehe Litbs Beitrag ).

Verwenden Sie also einen std :: vector.

Statische Arrays

Die Verwendung eines statischen Arrays ist bestenfalls:

• so schnell wie die std :: array version
• und viel weniger sicher.

Verwenden Sie also ein std :: array .

Nicht initialisierter Speicher

Manchmal verursacht die Verwendung eines vectoranstelle eines Rohpuffers sichtbare Kosten, da der vectorPuffer bei der Erstellung initialisiert wird, während der Code, den er ersetzt, dies nicht tat, wie bernie in seiner Antwort bemerkte .

Wenn dies der Fall ist, können Sie damit umgehen, indem Sie ein unique_ptranstelle von a verwenden vectoroder, wenn der Fall in Ihrer Codeline nicht außergewöhnlich ist, tatsächlich eine Klasse schreiben buffer_owner, die diesen Speicher besitzt, und Ihnen einen einfachen und sicheren Zugriff darauf gewähren, einschließlich Boni wie Größenänderung (mit realloc?) oder was auch immer Sie brauchen.

Vektoren sind Arrays unter der Haube. Die Leistung ist die gleiche.

Ein Punkt, an dem Sie auf ein Leistungsproblem stoßen können, besteht darin, den Vektor zunächst nicht richtig zu dimensionieren.

Wenn sich ein Vektor füllt, ändert sich seine Größe selbst, und dies kann eine neue Array-Zuordnung implizieren, gefolgt von n Kopierkonstruktoren, gefolgt von ungefähr n Destruktoraufrufen, gefolgt von einem Array-Löschen.

Wenn Ihr Konstrukt / Destrukt teuer ist, ist es viel besser, den Vektor zunächst auf die richtige Größe zu bringen.

Es gibt eine einfache Möglichkeit, dies zu demonstrieren. Erstellen Sie eine einfache Klasse, die anzeigt, wann sie erstellt / zerstört / kopiert / zugewiesen wurde. Erstellen Sie einen Vektor dieser Dinge und schieben Sie sie auf das hintere Ende des Vektors. Wenn sich der Vektor füllt, tritt eine Aktivitätskaskade auf, wenn sich die Größe des Vektors ändert. Versuchen Sie es dann erneut mit dem Vektor, der auf die erwartete Anzahl von Elementen dimensioniert ist. Sie werden den Unterschied sehen.

Um auf etwas zu antworten, sagte Mehrdad :

Es kann jedoch Fälle geben, in denen Sie noch Arrays benötigen. Bei der Schnittstelle mit Low-Level-Code (dh Assembly) oder alten Bibliotheken, für die Arrays erforderlich sind, können Sie möglicherweise keine Vektoren verwenden.

Überhaupt nicht wahr. Vektoren werden gut in Arrays / Zeiger zerlegt, wenn Sie Folgendes verwenden:

vector<double> vector;
vector.push_back(42);

double *array = &(*vector.begin());

// pass the array to whatever low-level code you have

Dies funktioniert für alle wichtigen STL-Implementierungen. Im nächsten Standard muss es funktionieren (auch wenn es heute gut funktioniert).

Sie haben noch weniger Gründe, einfache Arrays in C ++ 11 zu verwenden.

Es gibt 3 Arten von Arrays in der Natur, von den schnellsten bis zu den langsamsten, abhängig von den Funktionen, die sie haben (natürlich kann die Qualität der Implementierung die Dinge selbst für Fall 3 in der Liste sehr schnell machen):

1. Statisch mit der zur Kompilierungszeit bekannten Größe. --- ---.std::array<T, N>
2. Dynamisch mit zur Laufzeit bekannter Größe und ohne Größenänderung. Die typische Optimierung hierbei ist, dass das Array direkt im Stack zugeordnet werden kann. - Nicht verfügbar . Vielleicht dynarrayin C ++ TS nach C ++ 14. In C gibt es VLAs
3. Dynamisch und zur Laufzeit anpassbar. --- ---.std::vector<T>

Verwenden Sie für 1. einfache statische Arrays mit einer festen Anzahl von Elementenstd::array<T, N> in C ++ 11.

Für 2. Arrays mit fester Größe, die zur Laufzeit angegeben wurden, deren Größe sich jedoch nicht ändert, wird in C ++ 14 diskutiert, aber es wurde in eine technische Spezifikation verschoben und schließlich aus C ++ 14 erstellt.

Für 3. std::vector<T> wird normalerweise nach Speicher im Heap gefragt . Dies kann Auswirkungen auf die Leistung haben, obwohl Sie std::vector<T, MyAlloc<T>>die Situation mit einem benutzerdefinierten Allokator verbessern können. Der Vorteil gegenüber T mytype[] = new MyType[n];ist, dass Sie die Größe ändern können und dass es nicht wie bei einfachen Arrays in einen Zeiger zerfällt.

Verwenden Sie die genannten Standardbibliothekstypen, um zu vermeiden, dass Arrays in Zeiger zerfallen . Sie sparen Debugging-Zeit und die Leistung ist genau die gleiche wie bei einfachen Arrays, wenn Sie dieselben Funktionen verwenden.

Gehen Sie mit STL. Es gibt keine Leistungseinbußen. Die Algorithmen sind sehr effizient und können die Details, über die die meisten von uns nicht nachdenken würden, gut verarbeiten.

STL ist eine stark optimierte Bibliothek. Es wird sogar empfohlen, STL in Spielen zu verwenden, in denen möglicherweise eine hohe Leistung erforderlich ist. Arrays sind zu fehleranfällig, um für alltägliche Aufgaben verwendet zu werden. Die heutigen Compiler sind auch sehr intelligent und können mit STL wirklich exzellenten Code erzeugen. Wenn Sie wissen, was Sie tun, kann STL normalerweise die erforderliche Leistung erbringen. Wenn Sie beispielsweise Vektoren auf die erforderliche Größe initialisieren (wenn Sie dies von Anfang an wissen), können Sie im Grunde die Array-Leistung erzielen. Es kann jedoch Fälle geben, in denen Sie noch Arrays benötigen. Bei der Schnittstelle mit Low-Level-Code (dh Assembly) oder alten Bibliotheken, für die Arrays erforderlich sind, können Sie möglicherweise keine Vektoren verwenden.

Über Dulis Beitrag .

Die Schlussfolgerung ist, dass Arrays von Ganzzahlen schneller sind als Vektoren von Ganzzahlen (in meinem Beispiel fünfmal). Arrays und Vektoren sind jedoch für komplexere / nicht ausgerichtete Daten ungefähr gleich schnell.

Wenn Sie die Software im Debug-Modus kompilieren, werden viele Compiler die Accessor-Funktionen des Vektors nicht inline. Dadurch wird die Implementierung des STL-Vektors unter Umständen, bei denen die Leistung ein Problem darstellt, viel langsamer. Dies erleichtert auch das Debuggen des Codes, da Sie im Debugger sehen können, wie viel Speicher zugewiesen wurde.

Im optimierten Modus würde ich erwarten, dass sich der stl-Vektor der Effizienz eines Arrays nähert. Dies liegt daran, dass viele der Vektormethoden jetzt inline sind.

Die Verwendung eines std::vectorvs-Raw-Arrays hat definitiv Auswirkungen auf die Leistung, wenn Sie einen nicht initialisierten Puffer möchten (z. B. als Ziel für memcpy()). An std::vectorinitialisiert alle seine Elemente mit dem Standardkonstruktor. Ein Raw-Array wird nicht.

Die c ++ - Spezifikation für den std:vectorKonstruktor, der ein countArgument annimmt (es ist die dritte Form), lautet:

`Erstellt einen neuen Container aus einer Vielzahl von Datenquellen, optional unter Verwendung eines vom Benutzer bereitgestellten Allokator-Allokations.

3) Konstruiert den Container mit der Anzahl der standardmäßig eingefügten Instanzen von T. Es werden keine Kopien erstellt.

Komplexität

2-3) Linear in der Zählung

Für ein Raw-Array fallen diese Initialisierungskosten nicht an.

Siehe auch Wie kann ich vermeiden, dass std :: vector <> alle seine Elemente initialisiert?

Der Leistungsunterschied zwischen den beiden ist sehr stark von der Implementierung abhängig. Wenn Sie einen schlecht implementierten std :: vector mit einer optimalen Array-Implementierung vergleichen, gewinnt das Array, dreht es jedoch um und der Vektor gewinnt ...

Solange Sie Äpfel mit Äpfeln vergleichen (entweder haben sowohl das Array als auch der Vektor eine feste Anzahl von Elementen oder beide werden dynamisch in der Größe geändert), würde ich denken, dass der Leistungsunterschied vernachlässigbar ist, solange Sie die STL-Codierungspraxis befolgen. Vergessen Sie nicht, dass Sie mit Standard-C ++ - Containern auch die vorgefertigten Algorithmen verwenden können, die Teil der Standard-C ++ - Bibliothek sind. Die meisten von ihnen sind wahrscheinlich leistungsfähiger als die durchschnittliche Implementierung desselben Algorithmus, den Sie selbst erstellt haben .

IMHO gewinnt der Vektor in einem Debug-Szenario mit einer Debug-STL, da die meisten STL-Implementierungen mit einem geeigneten Debug-Modus zumindest die typischen Fehler hervorheben / kathcieren können, die von Menschen bei der Arbeit mit Standardcontainern gemacht wurden.

Vergessen Sie nicht, dass das Array und der Vektor dasselbe Speicherlayout verwenden, sodass Sie Vektoren verwenden können, um Daten an älteren C- oder C ++ - Code zu übergeben, der grundlegende Arrays erwartet. Denken Sie jedoch daran, dass die meisten Wetten in diesem Szenario ungültig sind und Sie sich wieder mit dem Rohspeicher beschäftigen.

Wenn Sie die Größe nicht dynamisch anpassen müssen, haben Sie den Speicheraufwand zum Speichern der Kapazität (ein Zeiger / size_t). Das ist es.

Es kann einen Randfall geben, in dem Sie einen Vektorzugriff innerhalb einer Inline-Funktion innerhalb einer Inline-Funktion haben, bei dem Sie über das hinausgegangen sind, was der Compiler inline macht, und einen Funktionsaufruf erzwingen. Das wäre so selten, dass man sich keine Sorgen machen sollte - im Allgemeinen würde ich litb zustimmen .

Ich bin überrascht, dass dies noch niemand erwähnt hat - machen Sie sich keine Sorgen um die Leistung, bis sich herausgestellt hat, dass es sich um ein Problem handelt, und setzen Sie dann einen Benchmark.

Ich würde argumentieren, dass das Hauptanliegen nicht die Leistung, sondern die Sicherheit ist. Sie können mit Arrays viele Fehler machen (z. B. Größenänderung in Betracht ziehen), bei denen ein Vektor Ihnen viel Schmerz ersparen würde.

Vektoren verwenden ein kleines bisschen mehr Speicher als Arrays, da sie die Größe des Arrays enthalten. Sie erhöhen auch die Festplattengröße von Programmen und wahrscheinlich den Speicherbedarf von Programmen. Diese Erhöhungen sind winzig, können jedoch von Bedeutung sein, wenn Sie mit einem eingebetteten System arbeiten. Obwohl die meisten Stellen, an denen diese Unterschiede von Bedeutung sind, Orte sind, an denen Sie C anstelle von C ++ verwenden würden.

Der folgende einfache Test:

Erklärung des Leistungstests für C ++ Array vs Vector

widerspricht den Schlussfolgerungen aus "Vergleich des Assembler-Codes, der für grundlegende Indizierungs-, Dereferenzierungs- und Inkrementierungsoperationen für Vektoren und Arrays / Zeiger generiert wurde".

Es muss einen Unterschied zwischen den Arrays und Vektoren geben. Der Test sagt es ... probieren Sie es einfach aus, der Code ist da ...

Manchmal sind Arrays tatsächlich besser als Vektoren. Wenn Sie immer einen Satz von Objekten mit fester Länge bearbeiten, sind Arrays besser. Betrachten Sie die folgenden Codefragmente:

int main() {
int v[3];
v[0]=1; v[1]=2;v[2]=3;
int sum;
int starttime=time(NULL);
cout << starttime << endl;
for (int i=0;i<50000;i++)
for (int j=0;j<10000;j++) {
X x(v);
sum+=x.first();
}
int endtime=time(NULL);
cout << endtime << endl;
cout << endtime - starttime << endl;

}

wo die Vektorversion von X ist

class X {
vector<int> vec;
public:
X(const vector<int>& v) {vec = v;}
int first() { return vec[0];}
};

und die Array-Version von X ist:

class X {
int f[3];

public:
X(int a[]) {f[0]=a[0]; f[1]=a[1];f[2]=a[2];}
int first() { return f[0];}
};

Die Array-Version von main () wird schneller sein, da wir den Overhead von "new" jedes Mal in der inneren Schleife vermeiden.

(Dieser Code wurde von mir in comp.lang.c ++ gepostet).

Wenn Sie Vektoren verwenden, um mehrdimensionales Verhalten darzustellen, gibt es einen Leistungseinbruch.

Verursachen 2d + -Vektoren einen Leistungseinbruch?

Das Wesentliche ist, dass jeder Subvektor mit Größeninformationen einen geringen Overhead aufweist und nicht unbedingt eine Serialisierung der Daten erfolgt (wie dies bei mehrdimensionalen c-Arrays der Fall ist). Dieser Mangel an Serialisierung kann mehr als nur Möglichkeiten zur Mikrooptimierung bieten. Wenn Sie mehrdimensionale Arrays erstellen, ist es möglicherweise am besten, std :: vector zu erweitern und Ihre eigene Funktion zum Abrufen / Setzen / Ändern der Größe von Bits zu verwenden.

Unter der Annahme eines Arrays mit fester Länge (z. B. int* v = new int[1000];vs std::vector<int> v(1000);, wobei die Größe vauf 1000 festgelegt bleibt) ist die Geschwindigkeit, auf die wirklich zugegriffen werden kann (oder zumindest für mich, wenn ich mich in einem ähnlichen Dilemma befand), die Geschwindigkeit des Zugriffs auf ein Array Element. Ich habe den Vektorcode der STL nachgeschlagen und Folgendes gefunden:

const_reference
operator[](size_type __n) const
{ return *(this->_M_impl._M_start + __n); }

Diese Funktion wird mit Sicherheit vom Compiler eingebunden. Solange Sie also vnur den Zugriff auf seine Elemente planen, operator[]sollte es keinen wirklichen Leistungsunterschied geben.