C++ <vector> operator[]-Operator
Unter allen Möglichkeiten, auf Vektorelemente zuzugreifen,operator[]ist der gebräuchlichste und direkteste, genau wie der Zugriff auf Array-Elemente.
operator[]ist der Indexoperator von Containerklassen und wird verwendet, umdas Element an der angegebenen Position zurückzugeben, führt jedoch keine Grenzprüfung durch. Seine Verwendung ist genau die gleiche wie die eines regulären Arrays.
operator[]bietet eine array-artige Direktzugriffsfähigkeit, mit der du schnell auf Elemente an jeder Position zugreifen kannst.
Wortdefinitionen: operator[]ist der Indexoperator, und die eckigen Klammern sind das Symbol für den Array-Zugriff.
Grundlegende Syntax und Parameter
operator[]ist eine Memberfunktion der Containerklasse. Verwende sie einfach wie ein Array.
Syntaxformat
reference operator[](size_type pos); const_reference operator[](size_type pos) const;
Parameterbeschreibung
- Parameter:
pos- Typ:
size_type(ein vorzeichenloser Ganzzahltyp, normalerweisesize_t) - Beschreibung: Die Position (der Index) des Elements, auf das zugegriffen werden soll. Der Index beginnt bei 0, und der maximal gültige Index ist
size() - 1。
- Typ:
Funktionsbeschreibung
- Rückgabewert: gibt die ... des Elements an der angegebenen Position zurückReferenz. Wenn der Container ein konstanter Container ist, wird eine konstante Referenz zurückgegeben.
- Wirkung: gibt das Element an der angegebenen Position zurück. Es wird keine Grenzprüfung durchgeführt; ein Zugriff außerhalb der Grenzen führt zu undefiniertem Verhalten.
- Unterschied zu at():
operator[]Führt keine Grenzprüfung durch, ist daher etwas schneller;at()führt eine Bereichsprüfung durch und löst eine Ausnahme aus, wenn außerhalb der Grenzen zugegriffen wird.
Beispiel
Lass es uns anhand einer Reihe von Beispielen, die von einfach bis komplex reichen, gründlich meistern.operator[]Verwendung.
Beispiel 1: Grundlegende Verwendung - Zugriff auf Elemente
Beispiel
#include <vector>
int main() {
// 1. Erstelle einen Vektor und füge einige Elemente hinzu
std::vector<int> numbers = {10, 20, 30, 40, 50};
std::cout << "Die Größe des Vektors ist: " << numbers.size() << std::endl;
// 2. Verwenden Sie operator[], um auf Elemente zuzugreifen
std::cout << "Erstes Element [0]: " << numbers[0] << std::endl;
std::cout << "Zweites Element [1]: " << numbers[1] << std::endl;
std::cout << "Drittes Element [2]: " << numbers[2] << std::endl;
std::cout << "Letztes Element [4]: " << numbers[4] << std::endl;
// 3. Verwende eine Schleife, um auf alle Elemente zuzugreifen
std::cout << "Alle Elemente: ";
for(size_t i = 0; i < numbers.size(); ++i) {
std::cout << numbers[i] << " ";
}
std::cout << std::endl;
return 0;
}
Erwartete Ausgabe:
vector的大小是: 5 第一个元素 [0]: 10 第二个元素 [1]: 20 第三个元素 [2]: 30 最后一个元素 [4]: 50 所有元素: 10 20 30 40 50
Codeanalyse:
numbers[0]Das erste Element zurückgeben10(Indizes beginnen bei 0).numbers[4]gibt das letzte Element zurück50(weilsize()ist 5, und die gültigen Indizes sind 0-4).- mit Schleifen und
operator[]kann alle Elemente durchlaufen, und seine Verwendung ist genau die gleiche wie die eines Arrays.
Beispiel 2: Ändern von Elementwerten
operator[]gibt eine Referenz zurück, sodass sie verwendet werden kann, um den Wert eines Elements zu ändern.
Beispiel
#include <vector>
int main() {
std::vector<int> numbers = {10, 20, 30};
std::cout << "Vor der Änderung: ";
for(size_t i = 0; i < numbers.size(); ++i) {
std::cout << numbers[i] << " ";
}
std::cout << std::endl;
// Verwende operator[], um eine Referenz zu erhalten und Elemente zu ändern
numbers[0] = 100;
numbers[1] = 200;
numbers[2] = 300;
std::cout << "Nach der Änderung: ";
for(size_t i = 0; i < numbers.size(); ++i) {
std::cout << numbers[i] << " ";
}
std::cout << std::endl;
return 0;
}
Erwartete Ausgabe:
修改前: 10 20 30 修改后: 100 200 300
Codeanalyse:
numbers[0] = 100;Der Wert des ersten Elements wurde durch die Referenz geändert.- Dies zeigt
operator[]gibt eine modifizierbare lvalue-Referenz zurück.
Beispiel 3: Verwenden von auto zum automatischen Ableiten des Typs
KombinationautoSchlüsselwort, für bequemere Verwendungoperator[]。
Beispiel
#include <vector>
#include <string>
int main() {
std::vector<std::string> names = {"Alice", "Bob", "Charlie"};
// auto zur automatischen Typableitung verwenden
for(size_t i = 0; i < names.size(); ++i) {
auto& name = names[i]; // Abgeleitet als std::string&
std::cout << "Runde " << (i + 1) << " Personen: " << name << std::endl;
}
return 0;
}
Erwartete Ausgabe:
第 1 个人: Alice 第 2 个人: Bob 第 3 个人: Charlie
Codeanalyse:
auto& name = names[i];Automatisch abgeleitet alsstd::string&, was die direkte Änderung des Elements ermöglicht.Beispiel 4: Unterschied zwischen operator[] und at()
Comparisonoperator[]undat()Verhaltensunterschiede.
Beispiel
#include <vector>
#include <stdexcept>
int main() {
std::vector<int> numbers = {10, 20, 30};
// operator[] führt keine Bereichsprüfung durch; Zugriff außerhalb der Grenzen erfolgt auf eigenes Risiko
// Hier wird auf numbers[5] zugegriffen, aber size() ist 3, dies ist undefiniertes Verhalten
// Zur Demonstration greifen wir nur auf den gültigen Bereich zu
std::cout << "operator[]-Zugriff:" << std::endl;
for(size_t i = 0; i < 3; ++i) {
std::cout << "numbers[" << i << "] = " << numbers[i] << std::endl;
}
std::cout << "\nat()-Zugriff (mit Bereichsprüfung):" << std::endl;
for(size_t i = 0; i < 3; ++i) {
std::cout << "numbers.at(" << i << ") = " << numbers.at(i) << std::endl;
}
std::cout << "\nVorschlag: Verwenden Sie operator[], wenn Sie sicher sind, dass der Index nicht außerhalb der Grenzen liegt, << std::endl;
std::cout << " Verwenden Sie at(), wenn Sie unsicher sind, um Ausnahmeschutz zu erhalten." << std::endl;
return 0;
}
Codeanalyse:
operator[]Zugriff ist schneller, weil keine Bereichsprüfung durchgeführt wird.at()Sicherer, aber mit Overhead für die Ausnahmebehandlung.- Auswahlhinweis: Wenn der Index sicher ist (z. B. eine Schleifenvariable zwischen 0 und size()-1), verwenden Sie
operator[]; wenn der Index aus externer Eingabe stammt oder unsicher sein könnte, verwenden Sieat()。
Beispiel 5: Berechnung des Vektor-Skalarprodukts
Nutzungoperator[]Implementiere Vektoroperationen.
Beispiel
#include <vector>
// Berechne das Skalarprodukt zweier Vektoren
int dotProduct(const std::vector<int>& v1, const std::vector<int>& v2) {
int result = 0;
for(size_t i = 0; i < v1.size(); ++i) {
result += v1[i] * v2[i];
}
return result;
}
int main() {
std::vector<int> v1 = {1, 2, 3};
std::vector<int> v2 = {4, 5, 6};
int result = dotProduct(v1, v2);
std::cout << "Vektor v1: ";
for(size_t i = 0; i < v1.size(); ++i) {
std::cout << v1[i] << " ";
}
std::cout << std::endl;
std::cout << "Vektor v2: ";
for(size_t i = 0; i < v2.size(); ++i) {
std::cout << v2[i] << " ";
}
std::cout << std::endl;
std::cout << "Skalarprodukt: " << result << std::endl;
// 1*4 + 2*5 + 3*6 = 4 + 10 + 18 = 32
return 0;
}
Erwartete Ausgabe:
向量 v1: 1 2 3 向量 v2: 4 5 6 点积: 32
Codeanalyse:
- Nutzung
operator[]kann in Algorithmen schnell auf Vektorelemente zugreifen. - Das Skalarprodukt wird berechnet, indem die Elemente an den entsprechenden Positionen multipliziert und dann summiert werden.
Weitere Erweiterungen