C++ <vector> capacity-Funktion

C++-Containerklasse <vector>

capacitywird in vector verwendet fürKapazität abfragendie Funktion, die die Größe des aktuell vom Container belegten Speicherplatzes zurückgibt.

capacityist eine Elementfunktion von Container-Klassen und wird verwendet fürGibt die Anzahl der Elemente zurück, die der aktuell zugewiesene Speicherplatz des Containers aufnehmen kann. Dieser Wert ist normalerweise größer oder gleichsize()。

capacitySpiegelt den vorab zugewiesenen Speicherplatz innerhalb des Vektors wider; das Verständnis davon hilft, die Programmleistung zu optimieren und unnötige Speicher-Neuzuweisung zu vermeiden.

Wortdefinitionen： capacityBedeutet "Kapazität", also die Anzahl der Elemente, die der Container aufnehmen kann.

Grundlegende Syntax und Parameter

capacityIst eine Elementfunktion der Containerklasse, und ihr Aufruf erfordert keine Parameter.

Syntaxformat

size_type capacity() const;

Parameterbeschreibung

  • Parameter: Keine Parameter
    • capacityakzeptiert keine Parameter.

Funktionsbeschreibung

  • Rückgabewert: gibt zurücksize_typeTyp (normalerweisesize_t), gibt die Anzahl der Elemente an, die der aktuell zugewiesene Speicherplatz des Containers aufnehmen kann.
  • Wirkung: Gibt eine nichtnegative ganze Zahl zurück, die den vom Container zugewiesenen Speicherplatz darstellt.
  • Hinweis： capacity()Gibt die Kapazität zurück, nicht die Anzahl der Elemente. Für die Anzahl der Elemente verwenden Siesize()Abrufen.

Beispiel

Lassen Sie uns dies anhand einer Reihe von Beispielen gründlich meistern.capacityVerwendung.

Beispiel 1: Grundlegende Verwendung - Anzeigen der Kapazität

Beispiel

#include <iostream>
#include <vector>

int main() {
    // Leerer Vektor
    std::vector<int> emptyVec;
    std::cout << "Leerer Vektor - Größe: " << emptyVec.size()
              << ", Kapazität: " << emptyVec.capacity() << std::endl;

    // Vektor mit Elementen
    std::vector<int> numbers = {1, 2, 3, 4, 5};
    std::cout << "5-Elemente-Vektor - Größe: " << numbers.size()
              << ", Kapazität: " << numbers.capacity() << std::endl;

    return 0;
}

Erwartetes Ergebnis:

空 vector - size: 0, capacity: 0
5 元素 vector - size: 5, capacity: 5

Codeanalyse:

  1. eines leeren Vektorscapacity()ist 0.
  2. Ein Vektor mit 5 Elementencapacity()Ist mindestens 5 (kann größer sein, abhängig von der Implementierung).

Beispiel 2: Die Beziehung zwischen Größe und Kapazität

VerständnissizeundcapacityDer Unterschied ist die Grundlage für die Optimierung der Vektornutzung.

Beispiel

#include <iostream>
#include <vector>

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

    // Elemente schrittweise hinzufügen und Kapazitätsänderungen beobachten
    std::cout << "Änderungen von Größe und Kapazität beim Hinzufügen von Elementen:" << std::endl;

    for(int i = 0; i < 15; ++i) {
        v.push_back(i);
        std::cout << "Nach dem Hinzufügen von " << (i + 1) << " Elementen - Größe: "
                  << v.size() << ", Kapazität: " << v.capacity() << std::endl;
    }

    return 0;
}

Erwartetes Ergebnis (typische Ausgabe):

添加元素过程中 size 和 capacity 的变化:
添加 1 个元素后 - size: 1, capacity: 1
添加 2 个元素后 - size: 2, capacity: 2
添加 3 个元素后 - size: 3, capacity: 4
添加 4 个元素后 - size: 4, capacity: 4
添加 5 个元素后 - size: 5, capacity: 8
添加 6 个元素后 - size: 6, capacity: 8
添加 7 个元素后 - size: 7, capacity: 8
添加 8 个元素后 - size: 8, capacity: 8
添加 9 个元素后 - size: 9, capacity: 16
添加 10 个元素后 - size: 10, capacity: 16
添加 11 个元素后 - size: 11, capacity: 16
添加 12 个元素后 - size: 12, capacity: 16
添加 13 个元素后 - size: 13, capacity: 16
添加 14 个元素后 - size: 14, capacity: 16
添加 15 个元素后 - size: 15, capacity: 16

Codeanalyse:

  • Die Kapazität eines Vektors wächst exponentiell (normalerweise um den Faktor 2).
  • Wenn die Kapazität nicht ausreicht, reserviert der Vektor einen größeren Speicherbereich (normalerweise das Doppelte der aktuellen Kapazität).
  • Diese Strategie dient dazu, die Anzahl der Speicher-Neuallokationen zu verringern und die Leistung zu verbessern.

Beispiel 3: Verwenden von reserve zum Vorab-Reservieren von Kapazität

NutzungreserveSie können ausreichend Kapazität vorab reservieren, um häufige Speicher-Neuallokationen zu vermeiden.

Beispiel

#include <iostream>
#include <vector>

int main() {
    // Kapazität für 1000 Elemente vorab reservieren
    std::vector<int> v;
    v.reserve(1000);

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

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

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

    return 0;
}

Erwartetes Ergebnis:

reserve(1000) 后 - size: 0, capacity: 1000
添加 100 个元素后 - size: 100, capacity: 1000

Codeanalyse:

  • reserve(1000)Vorab reservierter Speicherplatz, der 1000 Elemente aufnehmen kann.
  • Nach dem Hinzufügen von 100 Elementen,capacityEs ist immer noch 1000, und es fand keine Speicher-Neuallokation statt.
  • Dies kann die Leistung erheblich verbessern, insbesondere wenn eine große Anzahl von Elementen hinzugefügt werden muss.

Beispiel 4: shrink_to_fit gibt überschüssige Kapazität frei

In C++11 eingeführtshrink_to_fitMethode, die die Kapazität so anpassen kann, dass sie mit size übereinstimmt.

Beispiel

#include <iostream>
#include <vector>

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

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

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

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

    // Auf passende Größe verkleinern
    v.shrink_to_fit();
    std::cout << "Nach shrink_to_fit() - Größe: " << v.size()
              << ", Kapazität: " << v.capacity() << std::endl;

    return 0;
}

Erwartetes Ergebnis:

初始状态 - size: 5, capacity: 5
reserve(100) 后 - size: 5, capacity: 100
shrink_to_fit() 后 - size: 5, capacity: 5

Codeanalyse:

  • shrink_to_fit()Fordert den Container auf, die Kapazität auf die Größe zu reduzieren.
  • Dies kann Speicher freigeben, der nicht mehr benötigt wird.
  • Hinweis: Dies ist nicht zwingend erforderlich; die tatsächliche Kapazität hängt von der Implementierung ab.

Beispiel 5: Praktische Anwendung der Kapazität

LernencapacityEs kann helfen, die Speichernutzung zu optimieren.

Beispiel

#include <iostream>
#include <vector>

void printStatus(const std::string& operation,
                 const std::vector<int>& v) {
    std::cout << operation << " - Größe: " << v.size()
              << ", Kapazität: " << v.capacity() << std::endl;
}

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

    printStatus("Anfangszustand", data);

    // Wenn wir wissen, dass wir 1000 Elemente speichern müssen, können wir vorab reservieren
    const size_t estimatedSize = 1000;
    data.reserve(estimatedSize);

    printStatus("Nach reserve(1000)", data);

    // Datenladen simulieren
    for(size_t i = 0; i < 1000; ++i) {
        data.push_back(static_cast<int>(i));
    }

    printStatus("Nach dem Hinzufügen von 1000 Elementen", data);

    // Prüfen, ob eine Kapazitätserweiterung erforderlich ist
    if(data.capacity() < estimatedSize) {
        std::cout << "Warnung: Unzureichende Kapazität!" << std::endl;
    } else {
        std::cout << "Ausreichende Kapazität, minimierte Anzahl an Speicherzuweisungen" << std::endl;
    }

    return 0;
}

Erwartetes Ergebnis:

初始状态 - size: 0, capacity: 0
reserve(1000) 后 - size: 0, capacity: 1000
添加 1000 个元素后 - size: 1000, capacity: 1000
容量充足，内存分配次数最少化

Codeanalyse:

  • Schätzen Sie die erforderliche Kapazität im Voraus und verwenden Siereservekann mehrfache Speicherzuweisungen vermeiden.
  • Dies ist besonders nützlich für Szenarien mit großen Datenmengen.

C++-Containerklasse <vector>

Weitere Erweiterungen