vector -> Verwendung der Elementfunktionen begin() und end() vs. the operator []

Question

Während wir den Vektor verwenden, verwenden wir manchmal den Operator [] wie Hausaufgaben [Mitte], aber verwenden Sie auch mal homework.begin(). Auch, homework.end() nicht Hausaufgaben [Ende], aber das ist wie beginnen. Geht es nur darum, auf die Elemente anders zuzugreifen? Es ist auf diese Weise verwirrender, stimmst du nicht zu?

Answer 1

vector :: operator [] ruft das N-te Element des Vektors ab. Ein solcher Operator ist nur für ausgewählte STL-Containerklassen definiert.

vector.end() ist eine Methode, die einen Iterator zurückgibt. Iteratoren sind spezielle Einheiten zum Arbeiten mit STL-Containern, inklusive Vektor. vector :: end() zeigt auf das Element, das unmittelbar auf das letzte Element des Vektors folgt - es wird oft als Wert behandelt, um den Iterator gegenzuhalten, um zu bestimmen, ob der gesamte Container durchlaufen wurde.

Answer 2

begin() und end() sind Elementfunktionen des Vektors, die einen Iterator zurückgeben. Dieser Iterator kann dereferenziert werden, um den Wert zu erhalten. Ähnlich haben Sie den Operator [], der einen Index übernimmt und den an dieser Position gespeicherten Wert direkt zurückgibt.

Answer 3

Es ist die gleiche Analogie wie bei C-Arrays ...

int a [length_a]

"Beginn/Ende" Version:

int* begin = a; 
int* end = a+length_a; 
while (p<e) { 
    printf("%d", *p); 
    ++p; 
} 

Hinweis wie "Ende" ein Element verweist jenseits des Arrays! Es ist genau dasselbe wie vector :: end (denke darüber nach wie eine Stoppbedingung).

"[]" Version:

for (int i=0; i<length_a; ++i) { 
    printf("%d", a[i]); 
} 

'[]' Zusammenfassung:

• + kompatibel mit C-Arrays, effiziente Syntax

• -nicht für nicht-zufällige Zugriff auf Container (zum Beispiel: Wechsel zu "Liste" wird schwierig sein)

mein POV Rat:

• Verwendung [] für den Direktzugriff oder als 'leicht' Array c Upgrade

• Verwendung Beginn/Ende, wenn ganze Inhalt sequentiell durchqueren

Answer 4

Sie machen verschiedene Dinge. operator[n] liefert eine Referenz eine Referenz auf das n te Element. begin() und end() gibt Iteratoren zurück, die auf den Anfang und das Ende des Containers zeigen. Wenn Sie über den Container iterieren müssen, ist die Verwendung von Iteratoren kaum "verwirrender". Es ist viel einfacher.

Angenommen, Sie haben einen Vektor v haben:

std::vector<int> v; 
v.push_back(1); 
v.push_back(7); 
v.push_back(42); 
v.push_back(3); 

, wenn Sie wollen einfach nur ein Element verweisen, haben Sie folgende Optionen:

v[2]; 
*v.begin()+2; 

Also hier, operator[] ist einfacher. Aber wenn man über den Behälter zu durchlaufen wollen, vielleicht um den Inhalt zu drucken, haben Sie diese Optionen:

for (int i = 0; i < v.size(); ++i){ 
    std::cout << v[i]; 
} 

std::copy(v.begin(), v.end(), std::ostream_iterator<std::string>(std::cout)); 

Plötzlich rettete die Iteratoren uns eine Menge Arbeit. Wir müssen keine Schleife mehr machen.

Oder lassen Sie uns sagen Sie das größte Element finden wollte:

int max = 0; 
for (int i = 0; i < v.size(); ++i){ 
    if (v[i] > max) { max = v[i]; } 
} 

std::max_element(v.begin(), v.end()); 

oder vielleicht wollen Sie den Vektor sortieren. Ich werde nicht einmal die Mühe, meine eigenen Sortieralgorithmus auszuschreiben mit operator[], aber hier ist der Iterator Version:

std::sort(v.begin(), v.end()); 

Aus diesem Grund beginnen(), Ende() sind nützlich.