`<iterator>` -Funktionen

Artikel
10/12/2023

`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.

Abbildung eines Vektors mit den Elementen 10, 20 und 30. Es gibt ein imaginäres Feld vor dem äußerst linken Element (das ganz links stehende Element enthält die Zahl 10), das den Sentinel darstellt. Es ist mit crend() beschriftet. Das erste Element im Vektor enthält die Zahl 10 und wird als

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
}

`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

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

// 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.

Abbildung eines Vektors mit den Elementen 10, 20 und 30. Es gibt ein imaginäres Feld vor dem äußerst linken Element (das ganz links stehende Element enthält die Zahl 10), das den Sentinel darstellt. Die Bezeichnung ist rend(). Das erste Element im Vektor enthält die Zahl 10 und wird als

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:

Abbildung eines Vektors mit den Elementen 10, 20 und 30. Es gibt ein imaginäres Feld vor dem äußerst linken Element (das ganz links stehende Element enthält die Zahl 10), das den Sentinel darstellt. Die Bezeichnung ist rend(). Das erste Element im Vektor enthält die Zahl 10 und wird als

`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
}

`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
}

Freigeben über

<iterator> -Funktionen

advance

Parameter

Hinweise

Beispiel

back_inserter

Parameter

Rückgabewert

Hinweise

Beispiel

begin

Parameter

Rückgabewert

Beispiel

cbegin

Parameter

Rückgabewert

Hinweise

cend

Parameter

Rückgabewert

Hinweise

crbegin

Parameter

Rückgabewert

Beispiel: crbegin

crend

Parameter

Rückgabewert

crend-Beispiel

data

Parameter

Rückgabewert

Beispiel: data

distance

Parameter

Rückgabewert

Hinweise

Beispiel

empty

Parameter

Rückgabewert

Beispiel

end

Parameter

Rückgabewert

Hinweise

front_inserter

Parameter

Rückgabewert

Hinweise

Beispiel

inserter

Parameter

Hinweise

Beispiel

make_checked_array_iterator

Parameter

Rückgabewert

Hinweise

Beispiel

make_move_iterator

Parameter

Hinweise

make_unchecked_array_iterator

Parameter

Rückgabewert

Hinweise

Beispiel

next

Parameter

Rückgabewert

Hinweise

prev

Parameter

Hinweise

rbegin

Parameter

Rückgabewert

`<iterator>` -Funktionen

`advance`

`back_inserter`

`begin`

`cbegin`

`cend`

`crbegin`

Beispiel: `crbegin`

`crend`

`crend`-Beispiel

`data`

Beispiel: `data`

`distance`

`empty`

`end`

`front_inserter`

`inserter`

`make_checked_array_iterator`

`make_move_iterator`

`make_unchecked_array_iterator`

`next`

`prev`

`rbegin`

Beispiel: `rbegin`

`rend`

`rend`-Beispiel

`size`

Beispiel: `size`