C++ <vector> reserve-Funktion

C++-Containerklasse <vector>


reservewird in vector verwendet, umSpeicher vorab zu reservierenwichtige Funktion, die die Leistung beim Hinzufügen von Elementen erheblich verbessern kann.

reserveist eine Memberfunktion der Containerklasse, die verwendet wird, umSpeicherplatz für mindestens n Elemente zu reservierenDies ändert nicht die Größe des Containers, sondern reserviert vorab genügend Speicher, um häufige Neuzuweisungen zu vermeiden, wenn später Elemente hinzugefügt werden.

reserveist eine Schlüsselfunktion zur Optimierung der vector-Leistung, besonders geeignet für Szenarien, in denen eine große Anzahl von Elementen hinzugefügt werden muss.

Wortdefinitionen: reservebedeutet "reserve", d. h., genügend Speicher vorab zu reservieren.


Grundlegende Syntax und Parameter

reserveist eine Memberfunktion der Container-Klasse, und Sie müssen die Anzahl der zu reservierenden Elemente angeben.

Syntaxformat

void reserve(size_type n);

Parameterbeschreibung

  • Parameter: n
    • Typ:size_type(vorzeichenloser Ganzzahldatentyp, normalerweisesize_t)
    • Beschreibung: Die Mindestanzahl an Elementen, die Sie reservieren möchten. Der Container wird mindestens genügend Speicher allokieren, um n Elemente aufzunehmen.

Funktionsbeschreibung

  • Rückgabewert: void(Kein Rückgabewert).
  • AuswirkungDer Container wird Speicher neu allokieren, sodass seine Kapazität mindestens n beträgt. Die Größe des Containerssize()wird sich nicht ändern und wird die ursprüngliche Anzahl an Elementen bleiben.
  • HinweisWenn n kleiner als die aktuelle Kapazität ist,reservewird nichts unternommen. Wenn n größer als die aktuelle Kapazität ist, wird Speicher neu allokiert.

Beispiel

Lassen Sie uns [es] anhand einer Reihe von Beispielen gründlich meistern.reserveVerwendung.

Beispiel 1: Grundlegende Verwendung - Speicher vorab allokieren

Beispiel

#include <iostream>
#include <vector>

int main() {
    // Einen leeren Vektor erstellen
    std::vector<int> numbers;

    std::cout << "Anfangszustand - Größe: " << numbers.size()
              << ", Kapazität: " << numbers.capacity() << std::endl;

    // Speicher für 100 Elemente reservieren
    numbers.reserve(100);

    std::cout << "Nach reserve(100) - Größe: " << numbers.size()
              << ", Kapazität: " << numbers.capacity() << std::endl;

    // Elemente hinzufügen
    for(int i = 0; i < 10; ++i) {
        numbers.push_back(i);
    }

    std::cout << "Nach dem Hinzufügen von 10 Elementen - Größe: " << numbers.size()
              << ", Kapazität: " << numbers.capacity() << std::endl;

    return 0;
}

Erwartete Ausgabe:

初始状态 - size: 0, capacity: 0
reserve(100) 后 - size: 0, capacity: 100
添加 10 个元素后 - size: 10, capacity: 100

Codeanalyse:

  1. reserve(100)Speicherplatz, der 100 Elemente aufnehmen kann, wurde vorab zugewiesen.
  2. size()ist immer noch 0, da noch keine Elemente hinzugefügt wurden.
  3. Nach dem Hinzufügen von 10 Elementen ist die Kapazität immer noch 100, und es ist keine Speicher-Neuallokation aufgetreten.

Beispiel 2: Verwendung von reserve zur Optimierung des Hinzufügens großer Datenmengen

Für Szenarien, in denen eine große Anzahl von Elementen hinzugefügt werden muss, kann die Verwendung von [reserve] im Vorausreservedie Leistung erheblich verbessern.

Beispiel

#include <iostream>
#include <vector>
#include <chrono>

int main() {
    const int N = 100000;

    // Ohne Verwendung von reserve
    std::vector<int> v1;
    auto start1 = std::chrono::high_resolution_clock::now();
    for(int i = 0; i < N; ++i) {
        v1.push_back(i);
    }
    auto end1 = std::chrono::high_resolution_clock::now();
    auto duration1 = std::chrono::duration_cast<std::chrono::microseconds>(end1 - start1);

    // Verwendung von reserve
    std::vector<int> v2;
    v2.reserve(N);
    auto start2 = std::chrono::high_resolution_clock::now();
    for(int i = 0; i < N; ++i) {
        v2.push_back(i);
    }
    auto end2 = std::chrono::high_resolution_clock::now();
    auto duration2 = std::chrono::duration_cast<std::chrono::microseconds>(end2 - start2);

    std::cout << "Benötigte Zeit ohne reserve: " << duration1.count() << " Mikrosekunden" << std::endl;
    std::cout << "Benötigte Zeit mit reserve: " << duration2.count() << " Mikrosekunden" << std::endl;
    std::cout << "Leistungsverbesserung: " << (double)duration1.count() / duration2.count() << "x" << std::endl;

    return 0;
}

Codeanalyse:

  • Beim Hinzufügen von 100,000 Elementen kann die vorherige Verwendung von [reserve]reservedie Anzahl der Speicher-Neuallokationen erheblich reduzieren.
  • Dies kann bei der Verarbeitung großer Datenmengen spürbare Leistungsverbesserungen bringen.

Beispiel 3: Die korrekte Verwendung von reserve

Um dies vollständig zu nutzen,reservesollten Sie die erforderliche Kapazität im Voraus schätzen.

Beispiel

#include <iostream>
#include <vector>

int main() {
    // Angenommen, wir möchten Daten für 1000 Benutzer speichern
    struct User {
        std::string name;
        int age;
    };

    std::vector<User> users;
    users.reserve(1000); // Speicher vorab reservieren

    // Laden von Benutzerdaten simulieren
    for(int i = 0; i < 1000; ++i) {
        User u;
        u.name = "User" + std::to_string(i);
        u.age = 20 + (i % 50);
        users.push_back(u);
    }

    std::cout << "Anzahl der Benutzer: " << users.size() << std::endl;
    std::cout << "Kapazität: " << users.capacity() << std::endl;

    return 0;
}

Codeanalyse:

  • Für das Laden von Daten bekannter Größe ist die Verwendung von [reserve] im Vorausreservedie beste Vorgehensweise.
  • Dies vermeidet mehrfache Speicher-Neuallokationen und verbessert die Effizienz.

Beispiel 4: Unnötiges reserve vermeiden

reserveEs sollte nach tatsächlichem Bedarf verwendet werden; eine Überallokation verschwendet Speicher.

Beispiel

#include <iostream>
<vector>

int main() {
    // Falscher Ansatz: übermäßige Vorallokation
    std::vector<int> v1;
    v1.reserve(1000000); // Es werden nur 10 Elemente benötigt, aber wir haben Speicher für 1 Million vorab zugewiesen!

    for(int i = 0; i < 10; ++i) {
        v1.push_back(i);
    }

    std::cout << "Nur 10 Elemente benötigt - Größe: " << v1.size()
              << ", Kapazität: " << v1.capacity() << std::endl;

    // Richtiger Ansatz: nach Bedarf vorab zuweisen
    std::vector<int> v2;
    v2.reserve(10);

    for(int i = 0; i < 10; ++i) {
        v2.push_back(i);
    }

    std::cout << 10 Elemente benötigt - Größe: << v2.size()
              << ", Kapazität: " << v2.capacity() << std::endl;

    return 0;
}

Codeanalyse:

  • Übermäßige Vorallokation verschwendet Speicherplatz.
  • sollte basierend auf der tatsächlichen Anzahl der benötigten Elemente festgelegt werden.reservedes Parameters.

Beispiel 5: reserve und Kapazitätsprüfung

Sie können vor dem Hinzufügen von Elementen prüfen, ob die Kapazität ausreichend ist.

Beispiel

#include <iostream>
#include <vector>

void addElements(std::vector<int>& v, int count) {
    // Wenn die aktuelle Kapazität nicht ausreicht, genügend Speicher reservieren
    if(v.capacity() < v.size() + count) {
        v.reserve(v.size() + count);
    }

    // Elemente hinzufügen
    for(int i = 0; i < count; ++i) {
        v.push_back(v.size());
    }
}

int main() {
    std::vector<int> data;

    std::cout << "Anfängliche Größe: " << data.size()
              << ", Kapazität: " << data.capacity() << std::endl;

    addElements(data, 50);
    std::cout << Nach dem Hinzufügen von 50 - Größe: << data.size()
              << ", Kapazität: " << data.capacity() << std::endl;

    addElements(data, 50);
    std::cout << Nach dem Hinzufügen von weiteren 50 - Größe: << data.size()
              << ", Kapazität: " << data.capacity() << std::endl;

    return 0;
}

Codeanalyse:

  • Sie können die Kapazität innerhalb einer Funktion dynamisch prüfen und reservieren.
  • Dies stellt sicher, dass beim Hinzufügen von Elementen keine Speicherneuallokation erfolgt.

C++-Containerklasse <vector>

Weitere Erweiterungen