C++-Container-Klassen<array>
Der C++11-Standard führte ein<array>Die Header-Datei bietet einen Array-Container mit fester Größe, der im Vergleich zu Arrays in C bessere Eigenschaften in Bezug auf Typsicherheit und Speicherverwaltung aufweist.
std::arrayEs ist eine Template-Klasse in der C++-Standardbibliothek, definiert in<array>In der Header-Datei.std::arrayDie Template-Klasse stellt ein Array mit fester Größe bereit, dessen Größe zur Kompilierzeit festgelegt wird und nicht dynamisch geändert werden kann.
Syntax
std::arrayDie grundlegende Syntax lautet wie folgt:
#include <array> std::array<T, N> array_name;
Tist der Typ der Elemente im Array.NEs ist die Größe des Arrays und muss eine nichtnegative Ganzzahl sein.
Deklaration und Initialisierung
<array>Die Größe muss zur Compile-Zeit bestimmt werden und kann nicht dynamisch geändert werden. Verwendungsbeispiel:
#include <iostream>
#include <array>
int main() {
std::array<int, 5> arr = {1, 2, 3, 4, 5}; // 声明一个定长为5的int数组
return 0;
}
Funktionen
- Typsicherheit：
std::arrayErzwingt Typprüfung und vermeidet die Typsicherheitsprobleme von Arrays der Sprache C. - Feste Größe: Die Größe des Arrays wird zur Compile-Zeit bestimmt und kann zur Laufzeit nicht geändert werden.
- Zusammenhängender Speicher：
std::arrayDie Elemente werden zusammenhängend im Speicher abgelegt, was einen effizienten Elementzugriff ermöglicht. - Standard-Container：
std::arraybietetstd::vectorÄhnliche Schnittstellen, wie z. B.size(),at(),front(),back()usw.
Beispiel
Nachfolgend ein Beispiel unter Verwendung vonstd::arrayEin einfaches Beispiel, einschließlich der Ausgabeergebnisse.
Beispiel
#include <array>
int main() {
// Erstelle ein std::array mit 5 Ganzzahlen
std::array<int, 5> myArray = {1, 2, 3, 4, 5};
// Verwende eine bereichsbasierte for-Schleife, um das Array zu durchlaufen
for (const auto& value : myArray) {
std::cout << value << " ";
}
std::cout << std::endl;
// Zugriff auf Array-Elemente über den Index
std::cout << "Element an Index 2: " << myArray.at(2) << std::endl;
// Ermittle die Größe des Arrays
std::cout << "Arraygröße: " << myArray.size() << std::endl;
// Array-Elemente ändern
myArray[3] = 10;
// Erneut durch das Array iterieren, um die geänderten Elemente anzuzeigen
for (const auto& value : myArray) {
std::cout << value << " ";
}
std::cout << std::endl;
return 0;
}
Ausgabe:
1 2 3 4 5 Element at index 2: 3 Array size: 5 1 2 3 10 5
Häufig verwendete Memberfunktionen
Die folgenden sind<array>Einige häufig verwendete Memberfunktionen in:
| Funktion | Beschreibung |
|---|---|
at(size_t pos) |
Gibt das Element an der angegebenen Position mit Bereichsprüfung zurück |
operator[] |
Gibt das Element an der angegebenen Position ohne Bereichsprüfung zurück |
front() |
Gibt das erste Element des Arrays zurück |
back() |
Gibt das letzte Element des Arrays zurück |
data() |
Gibt einen Zeiger auf die Array-Daten zurück |
size() |
Gibt die Array-Größe zurück (fest und unverändert) |
fill(const T& value) |
Setzt alle Elemente des Arrays auf den angegebenen Wert |
swap(array& other) |
Vertauscht die Inhalte zweier Arrays |
begin() / end() |
Gibt die begin-/end-Iteratoren des Arrays zurück |
Beispiel
1. Grundlegende Operationen
Beispiel
#include <array>
int main() {
std::array<int, 5> arr = {10, 20, 30, 40, 50};
std::cout << "Array-Elemente: ";
for (int i = 0; i < arr.size(); ++i) {
std::cout << arr[i] << " ";
}
std::cout << std::endl;
// Erstes und letztes Element abrufen
std::cout << "Erstes Element: " << arr.front() << std::endl;
std::cout << "Letztes Element: " << arr.back() << std::endl;
return 0;
}
Verwendung von at und Bereichsprüfung
Beispiel
#include <array>
int main() {
std::array<int, 3> arr = {1, 2, 3};
try {
std::cout << arr.at(2) << std::endl; // Normale Ausgabe
std::cout << arr.at(5) << std::endl; // Außerhalb des Bereichs, löst eine Ausnahme aus
} catch (const std::out_of_range& e) {
std::cout << "Ausnahme: " << e.what() << std::endl;
}
return 0;
}
3. Elemente mit fill füllen
Beispiel
#include <array>
int main() {
std::array<int, 5> arr;
arr.fill(100); // Alle Elemente auf 100 setzen
std::cout << "Gefülltes Array: ";
for (const auto& elem : arr) {
std::cout << elem << " ";
}
std::cout << std::endl;
return 0;
}
4. Array-Austausch
Beispiel
#include <array>
int main() {
std::array<int, 3> arr1 = {1, 2, 3};
std::array<int, 3> arr2 = {4, 5, 6};
arr1.swap(arr2);
std::cout << "Array 1: ";
for (const auto& elem : arr1) {
std::cout << elem << " ";
}
std::cout << std::endl;
std::cout << "Array 2: ";
for (const auto& elem : arr2) {
std::cout << elem << " ";
}
std::cout << std::endl;
return 0;
}
Vergleich mit anderen Array-Typen
| Funktionen | std::array | C-Style-Arrays | std::vector |
|---|---|---|---|
| Size | Zur Kompilierzeit festgelegt | Zur Kompilierzeit festgelegt | Dynamisch änderbar |
| Bereichsprüfung | at()Bietet Bereichsprüfung | Keine | at()Bietet Bereichsprüfung |
| Gedächtnisverwaltung | Stack-Allokation | Stack-Allokation | Heap-Allokation |
| Leistung | Effizient | Effizient | Geringer (dynamisch allokiert) |
| interface | Unterstützt STL-Standardschnittstelle | Unterstützt keine STL-Standardschnittstelle | Unterstützt STL-Standardschnittstelle |
std::arrayEs ist ein sehr nützlicher Container in der C++-Standardbibliothek, der Arrays fester Größe mit den Vorteilen von Typsicherheit und Speicherverwaltung bereitstellt. Anhand der obigen Beispiele können wir sehen, wie man sie erstellt, auf sie zugreift und sie ändertstd::arraydie Elemente. Für Szenarien, die Arrays mit fester Größe erfordern,std::arrayist eine sehr gute Wahl.