C++ <vector> reserve-Funktion
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.
- Typ:
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 Containers
size()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 <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:
reserve(100)Speicherplatz, der 100 Elemente aufnehmen kann, wurde vorab zugewiesen.size()ist immer noch 0, da noch keine Elemente hinzugefügt wurden.- 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 <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 <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 Voraus
reservedie 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
<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 <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.
Weitere Erweiterungen