<iterator> -Funktionen
advance
Damit kann ein Iterator um eine bestimmte Anzahl von Positionen vorwärts verschoben werden.
template <class InputIterator, class Distance>
void advance(InputIterator& InIt, Distance Off);
Parameter
InIt
Der Iterator, der vorwärts verschoben werden soll und die Anforderungen für einen Eingabeiterator erfüllen muss.
Off
Ein Ganzzahltyp, der in den Differenztyp des Iterators konvertierbar ist und die Anzahl von Schritten angibt, um die die Position des Iterators vorwärts verschoben werden soll.
Hinweise
Der Bereich muss nicht veränderlich sein, wobei die Iteratoren ableiten oder über das Ende hinausleiten müssen.
Wenn die InputIterator Anforderungen für einen bidirektionalen Iteratortyp erfüllt sind, kann dies Off negativ sein. Wenn InputIterator es sich um einen Eingabe- oder Weiterleitungs iteratortyp handelt, Off muss es sich nicht um einen nichtegativen Typ handelt.
Die Advance-Funktion weist eine konstante Komplexität auf, wenn InputIterator sie den Anforderungen für einen Iterator mit wahlfreiem Zugriff entspricht. Andernfalls weist sie lineare Komplexität auf und ist daher potenziell teuer.
Beispiel
// iterator_advance.cpp
// compile with: /EHsc
#include <iterator>
#include <list>
#include <iostream>
int main()
{
using namespace std;
list<int> L;
for (int i = 1; i < 9; ++i)
{
L.push_back(i);
}
list<int>::iterator LPOS = L.begin();
cout << "The list L is: ( ";
for (auto L_Iter = L.begin(); L_Iter != L.end(); L_Iter++)
{
cout << *L_Iter << " ";
}
cout << ")." << endl;
cout << "The iterator LPOS initially points to the first element: "
<< *LPOS << "." << endl;
advance(LPOS, 4);
cout << "LPOS is advanced 4 steps forward to point"
<< " to the fifth element: "
<< *LPOS << "." << endl;
advance(LPOS, -3);
cout << "LPOS is moved 3 steps back to point to the "
<< "2nd element: " << *LPOS << "." << endl;
}
The list L is: ( 1 2 3 4 5 6 7 8 ).
The iterator LPOS initially points to the first element: 1.
LPOS is advanced 4 steps forward to point to the fifth element: 5.
LPOS is moved 3 steps back to point to the 2nd element: 2.
back_inserter
Damit wird ein Iterator erstellt, mit dem Elemente an das Ende eines bestimmten Containers eingefügt werden können.
template <class Container>
back_insert_iterator<Container> back_inserter(Container& Cont);
Parameter
Cont
Der Container, in dem die Einfügung am Ende ausgeführt werden sollte.
Rückgabewert
Ein back_insert_iterator, das dem Containerobjekt Cont zugeordnet ist.
Hinweise
Innerhalb der C++-Standardbibliothek muss das Argument auf einen der drei Sequenzcontainer verweisen, die über die Memberfunktion push_backverfügen: deque Klasse, list Klasse oder vector Klasse.
Beispiel
// iterator_back_inserter.cpp
// compile with: /EHsc
#include <iterator>
#include <vector>
#include <iostream>
int main()
{
using namespace std;
vector<int> vec;
for (int i = 0; i < 3; ++i)
{
vec.push_back(i);
}
cout << "The initial vector vec is: ( ";
for (auto vIter = vec.begin(); vIter != vec.end(); vIter++)
{
cout << *vIter << " ";
}
cout << ")." << endl;
// Insertions can be done with template function
back_insert_iterator<vector<int> > backiter(vec);
*backiter = 30;
backiter++;
*backiter = 40;
// Alternatively, insertions can be done with the
// back_insert_iterator member function
back_inserter(vec) = 500;
back_inserter(vec) = 600;
cout << "After the insertions, the vector vec is: ( ";
for (auto vIter = vec.begin(); vIter != vec.end(); vIter++)
{
cout << *vIter << " ";
}
cout << ")." << endl;
}
The initial vector vec is: ( 0 1 2 ).
After the insertions, the vector vec is: ( 0 1 2 30 40 500 600 ).
begin
Ruft einen Iterator für das erste Element in einem angegebenen Container ab.
template <class Container>
auto begin(Container& cont) `
-> decltype(cont.begin());
template <class Container>
auto begin(const Container& cont) `
-> decltype(cont.begin());
template <class Ty, class Size>
Ty *begin(Ty (& array)[Size]);
Parameter
cont
Ein Container.
array
Ein Array von Objekten des Typs Ty.
Rückgabewert
Die ersten beiden Vorlagenfunktionen geben cont.begin() zurück. Die erste Funktion ist nicht konstant; die zweite ist konstant.
Die dritte Vorlagenfunktion gibt array zurück.
Beispiel
Es empfiehlt sich, diese Vorlagenfunktion anstelle des Containermembers begin() zu verwenden, wenn ein eher generisches Verhalten erforderlich ist.
// cl.exe /EHsc /nologo /W4 /MTd
#include <algorithm>
#include <functional>
#include <iostream>
#include <iterator>
#include <vector>
template <typename C> void reverse_sort(C& c)
{
std::sort(std::begin(c), std::end(c), std::greater<>());
}
template <typename C> void print(const C& c)
{
for (const auto& e : c)
{
std::cout << e << " ";
}
std::cout << "\n";
}
int main()
{
std::vector<int> v = { 11, 34, 17, 52, 26, 13, 40, 20, 10, 5, 16, 8, 4, 2, 1 };
print(v);
reverse_sort(v);
print(v);
std::cout << "--\n";
int arr[] = { 23, 70, 35, 106, 53, 160, 80, 40, 20, 10, 5, 16, 8, 4, 2, 1 };
print(arr);
reverse_sort(arr);
print(arr);
}
11 34 17 52 26 13 40 20 10 5 16 8 4 2 1
52 40 34 26 20 17 16 13 11 10 8 5 4 2 1
--
23 70 35 106 53 160 80 40 20 10 5 16 8 4 2 1
160 106 80 70 53 40 35 23 20 16 10 8 5 4 2 1
Die Funktion reverse_sort unterstützt Container jeder Art, neben den normalen Arrays, da sie die Nichtmemberversion von begin() aufruft. Codieren reverse_sort für die Verwendung des Containermitglieds begin():
template <typename C>
void reverse_sort(C& c) {
using std::begin;
using std::end;
std::sort(c.begin(), c.end(), std::greater<>());
}
Wenn Sie dann ein Array an das Array senden, tritt dieser Compilerfehler auf:
error C2228: left of '.begin' must have class/struct/union
cbegin
Ruft einen Const -Iterator (schreibgeschützt) zum ersten Element in einem angegebenen Container ab.
template <class Container>
auto cbegin(const Container& cont)
-> decltype(cont.begin());
Parameter
cont
Ein Container oder initializer_listein .
Rückgabewert
Eine cont.begin()-Konstante.
Hinweise
Diese Funktion funktioniert mit allen C++-Standardbibliothekscontainern und mit initializer_list.
Sie können diese Memberfunktion anstelle der begin()-Vorlagenfunktion verwenden, um sicherzustellen, dass der Rückgabewert const_iterator ist. In der Regel wird sie mit dem auto Stichwort "Typabzug" verwendet, wie im folgenden Beispiel gezeigt. Im folgenden Beispiel ist Container ein änderbarer (nicht const) Container oder initializer_list eines beliebigen Typs, der begin() und cbegin() unterstützt.
auto i1 = Container.begin();
// i1 is Container<T>::iterator
auto i2 = Container.cbegin();
// i2 is Container<T>::const_iterator
cend
Ruft einen Const -Iterator (schreibgeschützt) zum Element ab, das dem letzten Element im angegebenen Container folgt.
template <class Container>
auto cend(const Container& cont)
-> decltype(cont.end());
Parameter
cont
Ein Container oder initializer_listein .
Rückgabewert
Eine cont.end()-Konstante.
Hinweise
Diese Funktion funktioniert mit allen C++-Standardbibliothekscontainern und mit initializer_list.
Sie können diese Memberfunktion anstelle der end()-Vorlagenfunktion verwenden, um sicherzustellen, dass der Rückgabewert const_iterator ist. In der Regel wird sie mit dem auto Stichwort "Typabzug" verwendet, wie im folgenden Beispiel gezeigt. Im folgenden Beispiel ist Container ein änderbarer (nicht const) Container oder initializer_list eines beliebigen Typs, der end() und cend() unterstützt.
auto i1 = Container.end();
// i1 is Container<T>::iterator
auto i2 = Container.cend();
// i2 is Container<T>::const_iterator
crbegin
Rufen Sie einen umgekehrten schreibgeschützten Iterator für die Elemente des Containers ab, beginnend am Ende des Containers.
template <class C> constexpr auto crbegin(const C& c) -> decltype(std::rbegin(c));
Parameter
C
Der Typ des Containers.
c
Eine Containerinstanz.
Rückgabewert
Dieser Iterator gibt die Elemente des Containers in umgekehrter Reihenfolge zurück, beginnend am Ende des Containers.
Beispiel: crbegin
#include <vector>
#include <iostream>
int main()
{
std::vector<int> v{10, 20, 30};
for (auto i = std::crbegin(v); i != std::crend(v); ++i)
{
std::cout << *i << ' '; // outputs 30 20 10
}
// v[1] = 100; // error because the iterator is const
}
30 20 10
crend
Rufen Sie den Sentinel am Ende einer schreibgeschützten umgekehrten Sequenz von Elementen ab.
template <class C> constexpr auto crend(const C& c) -> decltype(std::rend(c));
Parameter
C
Der Typ des Containers.
c
Eine Containerinstanz.
Rückgabewert
Der Sentinel folgt dem letzten Element in einer umgekehrten Ansicht des Containers.
crend-Beispiel
#include <vector>
#include <iostream>
int main()
{
std::vector<int> v{10, 20, 30};
auto vi = std::crend(v);
--vi; // get off the sentinel and onto the last element in the reversed range
std::cout << *vi; // outputs 10
// vi[0] = 300; // error because the iterator is const
}
10
data
Rufen Sie einen Zeiger auf das erste Element im Container ab.
1) template <class C> constexpr auto data(C& c) -> decltype(c.data());
2) template <class C> constexpr auto data(const C& c) -> decltype(c.data());
3) template <class T, size_t N> constexpr T* data(T (&array)[N]) noexcept;
4) template <class E> constexpr const E* data(initializer_list<E> il) noexcept;
Parameter
C
Der Typ des Containers.
c
Eine Instanz eines Containers.
E
Der Elementtyp der Initialisierungsliste.
il
Eine Initialisierungsliste.
N
Die Anzahl der -Elemente im Array.
T
Der Typ der Daten im Array.
Rückgabewert
1, 2) Ein Zeiger basierend auf dem Typ des Containers auf das erste Element. Wenn der Container beispielsweise ein Vektor ganzzahliger Zahlen ist, ist der Typ des Rückgabewerts ein int *.
3) Ein Zeiger auf das erste Element als Array.
4) Ein Zeiger auf das erste Element der Initialisierungsliste.
Beispiel: data
#include <vector>
#include <iostream>
int main()
{
std::vector<int> v{ 10, 20, 30 };
std::string src{ "a string" };
const char *charPtr = std::data(src);
int* intPtr = std::data(v);
std::cout << charPtr << ", " << *intPtr << '\n'; // a string, 10
}
a string, 10
distance
Bestimmt die Anzahl von Inkrementen zwischen den durch zwei Iteratoren festgelegten Positionen.
template <class InputIterator>
typename iterator_traits<InputIterator>::difference_type distance(InputIterator first, InputIterator last);
Parameter
first
Der erste Iterator, dessen Abstand zum zweiten ermittelt werden soll.
last
Der zweite Iterator, dessen Abstand zum ersten ermittelt werden soll.
Rückgabewert
Die Anzahl der Male, die erhöht werden muss, first bis sie gleich ist last.
Hinweise
Die Entfernungsfunktion weist eine konstante Komplexität auf, wenn InputIterator sie den Anforderungen für einen Iterator mit wahlfreiem Zugriff entspricht. Andernfalls weist sie lineare Komplexität auf und ist daher potenziell teuer.
Beispiel
// iterator_distance.cpp
// compile with: /EHsc
#include <iterator>
#include <list>
#include <iostream>
int main()
{
using namespace std;
list<int> L;
for (int i = -1; i < 9; ++i)
{
L.push_back(2 * i);
}
list <int>::iterator L_Iter, LPOS = L.begin();
cout << "The list L is: ( ";
for (L_Iter = L.begin(); L_Iter != L.end(); L_Iter++)
{
cout << *L_Iter << " ";
}
cout << ")." << endl;
cout << "The iterator LPOS initially points to the first element: "
<< *LPOS << "." << endl;
advance(LPOS, 7);
cout << "LPOS is advanced 7 steps forward to point "
<< " to the eighth element: "
<< *LPOS << "." << endl;
list<int>::difference_type Ldiff;
Ldiff = distance(L.begin(), LPOS);
cout << "The distance from L.begin( ) to LPOS is: "
<< Ldiff << "." << endl;
}
The list L is: ( -2 0 2 4 6 8 10 12 14 16 ).
The iterator LPOS initially points to the first element: -2.
LPOS is advanced 7 steps forward to point to the eighth element: 12.
The distance from L.begin( ) to LPOS is: 7.
empty
template <class C> constexpr auto empty(const C& c) -> decltype(c.empty());
template <class T, size_t N> constexpr bool empty(const T (&array)[N]) noexcept;
template <class E> constexpr bool empty(initializer_list<E> il) noexcept;
Parameter
C
Der Typ des Containers.
c
Eine Instanz eines Containers.
E
Der Elementtyp der Initialisierungsliste.
il
Eine Initialisierungsliste.
N
Die Anzahl der -Elemente im Array.
T
Der Typ der Daten im Array.
Rückgabewert
Gibt zurück true , wenn der Container keine Elemente enthält; andernfalls false.
Beispiel
#include <vector>
#include <iostream>
int main()
{
std::vector<int> v{ 10,20,30 };
std::vector<int> v2;
std::cout << std::boolalpha << std::empty(v); // outputs false
std::cout << std::boolalpha << ", " << std::empty(v2); // outputs true
}
false, true
end
Ruft einen Iterator für das Element ab, das auf das letzte Element im angegebenen Container folgt.
template <class Container>
auto end(Container& cont)
-> decltype(cont.end());
template <class Container>
auto end(const Container& cont)
-> decltype(cont.end());
template <class Ty, class Size>
Ty *end(Ty (& array)[Size]);
Parameter
cont
Ein Container.
array
Ein Array von Objekten des Typs Ty.
Rückgabewert
Die ersten zwei Vorlagenfunktionen geben cont.end() zurück (die erste ist keine Konstante und die zweite ist eine Konstante.)
Die dritte Vorlagenfunktion gibt array + Size zurück.
Hinweise
Ein Codebeispiel finden Sie unter begin.
front_inserter
Damit wird ein Iterator erstellt, mit dem Elemente an den Anfang eines bestimmten Containers eingefügt werden können.
template <class Container>
front_insert_iterator<Container> front_inserter(Container& Cont);
Parameter
Cont
Das Containerobjekt, dessen Front ein eingefügtes Element hat.
Rückgabewert
Ein front_insert_iterator, das dem Containerobjekt Cont zugeordnet ist.
Hinweise
Die Memberfunktion front_insert_iterator von der front_insert_iterator-Klasse kann ebenfalls verwendet werden.
In der C++-Standardbibliothek muss das Argument auf einen der drei Sequenzcontainer verweisen, die die Memberfunktion push_back: deque-Klasse oder „list-Klasse“ haben.
Beispiel
// iterator_front_inserter.cpp
// compile with: /EHsc
#include <iterator>
#include <list>
#include <iostream>
int main()
{
using namespace std;
list<int> L;
for (int i = -1; i < 9; ++i)
{
L.push_back(i);
}
cout << "The list L is:\n ( ";
for (auto L_Iter = L.begin(); L_Iter != L.end(); L_Iter++)
{
cout << *L_Iter << " ";
}
cout << ")." << endl;
// Using the template function to insert an element
front_insert_iterator<list <int>> Iter(L);
*Iter = 100;
// Alternatively, you may use the front_insert member function
front_inserter(L) = 200;
cout << "After the front insertions, the list L is:\n ( ";
for (auto L_Iter = L.begin(); L_Iter != L.end(); L_Iter++)
{
cout << *L_Iter << " ";
}
cout << ")." << endl;
}
The list L is:
( -1 0 1 2 3 4 5 6 7 8 ).
After the front insertions, the list L is:
( 200 100 -1 0 1 2 3 4 5 6 7 8 ).
inserter
Eine Hilfsvorlagenfunktion, mit der Sie inserter(Cont, Where) anstelle von insert_iterator<Container>(Cont, Where).
template <class Container>
insert_iterator<Container>
inserter(
Container& Cont,
typename Container::iterator Where);
Parameter
Cont
Der Container, zu dem neue Elemente hinzugefügt werden sollen.
Where
Ein Iterator, der nach der Einfügemarke sucht.
Hinweise
Diese Vorlagenfunktion gibt insert_iterator<Container>(Cont, Where) zurück.
Beispiel
// iterator_inserter.cpp
// compile with: /EHsc
#include <iterator>
#include <list>
#include <iostream>
int main()
{
using namespace std;
list<int> L;
for (int i = 2; i < 5; ++i)
{
L.push_back(10 * i);
}
cout << "The list L is:\n ( ";
for (auto L_Iter = L.begin(); L_Iter != L.end(); L_Iter++)
{
cout << *L_Iter << " ";
}
cout << ")." << endl;
// Using the template version to insert an element
insert_iterator<list<int>> Iter(L, L.begin());
*Iter = 1;
// Alternatively, using the member function to insert an element
inserter(L, L.end()) = 500;
cout << "After the insertions, the list L is:\n ( ";
for (auto L_Iter = L.begin(); L_Iter != L.end(); L_Iter++)
{
cout << *L_Iter << " ";
}
cout << ")." << endl;
}
The list L is:
( 20 30 40 ).
After the insertions, the list L is:
( 1 20 30 40 500 ).
make_checked_array_iterator
Erstellt einen checked_array_iterator, der von anderen Algorithmen verwendet werden kann.
Hinweis
Bei dieser Funktion handelt es sich um eine Microsoft-Erweiterung der C++-Standardbibliothek. Der Code, der mit dieser Funktion implementiert wird, ist nicht auf C++-Standardbuildumgebungen übertragbar, die die Microsoft-Erweiterung nicht unterstützen.
template <class Iter>
checked_array_iterator<Iter>
make_checked_array_iterator(
Iter Ptr,
size_t Size,
size_t Index = 0);
Parameter
Ptr
Ein Zeiger auf das Zielarray.
Size
Die Größe des Zielarrays.
Index
Optionaler Index im Array.
Rückgabewert
Eine Instanz von checked_array_iterator.
Hinweise
Die make_checked_array_iterator-Funktion wird im stdext-Namespace definiert.
Diese Funktion akzeptiert einen Rohzeiger – was normalerweise im Hinblick auf eine Überschreitung der Begrenzungen problematisch wäre –, und umschließt ihn in einer checked_array_iterator-Klasse, die die Überprüfung ausführt. Da diese Klasse als überprüft markiert ist, gibt die C++-Standardbibliothek hierzu keine Warnung aus. Weitere Informationen finden Sie unter Überprüfte Iteratoren.
Beispiel
Im folgenden Beispiel wird ein Vektor erstellt und mit 10 Elementen gefüllt. Der Inhalt des Vektors wird mithilfe des Kopieralgorithmus in ein Array kopiert. Anschließend wird make_checked_array_iterator verwendet, um das Ziel anzugeben. Daraufhin erfolgt eine absichtliche Verletzung der Begrenzungen bei der Überprüfung, sodass eine Debugassertionsfehler ausgelöst wird.
// make_checked_array_iterator.cpp
// compile with: /EHsc /W4 /MTd
#include <algorithm>
#include <iterator> // stdext::make_checked_array_iterator
#include <memory> // std::make_unique
#include <iostream>
#include <vector>
#include <string>
using namespace std;
template <typename C> void print(const string& s, const C& c)
{
cout << s;
for (const auto& e : c)
{
cout << e << " ";
}
cout << endl;
}
int main()
{
const size_t dest_size = 10;
// Old-school but not exception safe, favor make_unique<int[]>
// int* dest = new int[dest_size];
unique_ptr<int[]> updest = make_unique<int[]>(dest_size);
int* dest = updest.get(); // get a raw pointer for the demo
vector<int> v;
for (int i = 0; i < dest_size; ++i)
{
v.push_back(i);
}
print("vector v: ", v);
copy(v.begin(), v.end(), stdext::make_checked_array_iterator(dest, dest_size));
cout << "int array dest: ";
for (int i = 0; i < dest_size; ++i)
{
cout << dest[i] << " ";
}
cout << endl;
// Add another element to the vector to force an overrun.
v.push_back(10);
// ! The next line causes a debug assertion when it executes.
copy(v.begin(), v.end(), stdext::make_checked_array_iterator(dest, dest_size));
}
make_move_iterator
Erstellt einen move iterator, der den bereitgestellten Iterator als stored-Iterator enthält.
template <class Iterator>
move_iterator<Iterator>
make_move_iterator(const Iterator& It);
Parameter
It
Der Iterator, der im neuen Move-Iterator gespeichert ist.
Hinweise
Die Vorlagenfunktion gibt zurück move_iterator <Iterator>(_It).
make_unchecked_array_iterator
Erstellt ein unchecked_array_iterator-Objekt, das von anderen Algorithmen verwendet werden kann.
Hinweis
Bei dieser Funktion handelt es sich um eine Microsoft-Erweiterung der C++-Standardbibliothek. Der Code, der mit dieser Funktion implementiert wird, ist nicht auf C++-Standardbuildumgebungen übertragbar, die die Microsoft-Erweiterung nicht unterstützen.
template <class Iter>
unchecked_array_iterator<Iter>
make_unchecked_array_iterator(Iter Ptr);
Parameter
Ptr
Ein Zeiger auf das Zielarray.
Rückgabewert
Eine Instanz von unchecked_array_iterator.
Hinweise
Die make_unchecked_array_iterator-Funktion wird im stdext-Namespace definiert.
Diese Funktion akzeptiert einen Rohzeiger und umschließt ihn in einer Klasse, die keine Überprüfung ausführt und daher nichts optimiert. Sie deaktiviert jedoch auch Compilerwarnungen wie C4996. Dies ist daher eine zielgerichtete Methode zur Bearbeitung von nicht aktivierten Zeigerwarnungen, ohne diese global zu deaktivieren oder den Aufwand der Überprüfung in Kauf zu nehmen. Weitere Informationen finden Sie unter Überprüfte Iteratoren.
Beispiel
Im folgenden Beispiel wird ein Vektor erstellt und mit 10 Elementen gefüllt. Der Inhalt des Vektors wird mithilfe des Kopieralgorithmus in ein Array kopiert. Anschließend wird make_unchecked_array_iterator verwendet, um das Ziel anzugeben.
// make_unchecked_array_iterator.cpp
// compile with: /EHsc /W4 /MTd
#include <algorithm>
#include <iterator> // stdext::make_unchecked_array_iterator
#include <iostream>
#include <vector>
#include <string>
using namespace std;
template <typename C> void print(const string& s, const C& c)
{
cout << s;
for (const auto& e : c)
{
cout << e << " ";
}
cout << endl;
}
int main()
{
const size_t dest_size = 10;
int* dest = new int[dest_size];
vector<int> v;
for (int i = 0; i < dest_size; ++i)
{
v.push_back(i);
}
print("vector v: ", v);
// COMPILER WARNING SILENCED: stdext::unchecked_array_iterator is marked as checked in debug mode
// (it performs no checking, so an overrun will trigger undefined behavior)
copy(v.begin(), v.end(), stdext::make_unchecked_array_iterator(dest));
cout << "int array dest: ";
for (int i = 0; i < dest_size; ++i)
{
cout << dest[i] << " ";
}
cout << endl;
delete[] dest;
}
vector v: 0 1 2 3 4 5 6 7 8 9
int array dest: 0 1 2 3 4 5 6 7 8 9
next
Führt eine bestimmte Anzahl von Iterationen aus und gibt die neue Position des Iterators zurück.
template <class InputIterator>
InputIterator next(
InputIterator first,
typename iterator_traits<InputIterator>::difference_type off = 1);
Parameter
first
Die aktuelle Position.
off
Die Anzahl der Iterationen.
Rückgabewert
Gibt die neue Position des Iterators nach dem Durchlaufen von off an.
Hinweise
Die Vorlagenfunktion gibt next inkrementiert off-Zeiten zurück.
prev
Führt eine bestimmte Anzahl von Iterationen rückwärts aus und gibt die neue Position des Iterators zurück.
template <class BidirectionalIterator>
BidirectionalIterator prev(
BidirectionalIterator first,
typename iterator_traits<BidirectionalIterator>::difference_type off = 1);
Parameter
first
Die aktuelle Position.
off
Die Anzahl der Iterationen.
Hinweise
Die Vorlagenfunktion gibt next dekrementiert off-Zeiten zurück.
rbegin
Rufen Sie einen Iterator ab, der die Elemente des Containers in umgekehrter Reihenfolge zurückgibt.
template <class C> constexpr auto rbegin(C& c) -> decltype(c.rbegin());
template <class C> constexpr auto rbegin(const C& c) -> decltype(c.rbegin());
Parameter
C
Der Typ des Containers.
c
Eine Containerinstanz.
Rückgabewert
Der zurückgegebene Iterator stellt die Elemente des Containers in umgekehrter Reihenfolge dar, beginnend am Ende des umgekehrten Bereichs.
Beispiel: rbegin
#include <vector>
#include <iostream>
int main()
{
std::vector<int> v{ 10, 20, 30 };
for (auto e = std::rbegin(v); e != std::rend(v); ++e)
{
std::cout << *e << ' '; // outputs 30 20 10
}
}
30 20 10
rend
Rufen Sie den Sentinel am Ende einer umgekehrten Abfolge von Elementen ab.
template <class C> constexpr auto rend(C& c)-> decltype(c.rend());
template <class C> constexpr auto rend(const C& c) -> decltype(c.rend());
Parameter
C
Der Typ des Containers.
c
Eine Containerinstanz.
Rückgabewert
Ein Umgekehrter Iterator zum Sentinel am Ende des Containers. Der Sentinel folgt dem letzten Element in der umgekehrten Ansicht des Containers:
rend-Beispiel
#include <vector>
#include <iostream>
int main()
{
std::vector<int> v{10, 20, 30};
auto vi = std::rend(v);
--vi; // get off the sentinel and onto the last element in the reversed range
std::cout << *vi; // outputs 10
}
10
size
template <class C> constexpr auto size(const C& c)
-> decltype(c.size());
template <class T, size_t N> constexpr size_t size(const T (&array)[N]) noexcept;
Parameter
C
Der Typ des Containers.
c
Eine Instanz eines Containers.
N
Die Anzahl der -Elemente im Array.
T
Der Typ der Daten im Array.
Rückgabewert
Die Anzahl der Elemente im Container als nicht signierter ganzzahliger Wert.
Beispiel: size
#include <vector>
#include <iostream>
int main()
{
std::vector<int> v{ 10, 20, 30 };
size_t s = std::size(v);
std::cout << s; // outputs 3
}
3