<iterator> functies

advance

Hiermee wordt een iterator verhoogd met een opgegeven aantal posities.

template <class InputIterator, class Distance>
void advance(InputIterator& InIt, Distance Off);

Parameters

InIt
De iterator die moet worden verhoogd en die moet voldoen aan de vereisten voor een invoer-iterator.

Off
Een integraal type dat converteert naar het verschiltype van de iterator en dat het aantal stappen aangeeft dat de positie van de iterator moet worden geavanceerd.

Remarks

Het bereik moet niet-insingular zijn, waarbij de iterators deducteerbaar of voorbij het einde moeten zijn.

Als het InputIterator voldoet aan de vereisten voor een bidirectioneel iteratortype, kan dit Off negatief zijn. Als InputIterator dit een invoer- of doorstuurservertype is, Off moet dit niet-negatief zijn.

De geavanceerde functie heeft een constante complexiteit wanneer InputIterator deze voldoet aan de vereisten voor een iterator voor willekeurige toegang; anders heeft deze lineaire complexiteit en is dit mogelijk duur.

Voorbeeld

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

Hiermee maakt u een iterator die elementen aan de achterkant van een opgegeven container kan invoegen.

template <class Container>
back_insert_iterator<Container> back_inserter(Container& Cont);

Parameters

Cont
De container waarin de back-invoeging moet worden uitgevoerd.

Retourwaarde

Een back_insert_iterator gekoppeld aan het containerobject Cont.

Remarks

In de C++-standaardbibliotheek moet het argument verwijzen naar een van de drie reekscontainers met de lidfunctie push_back: deque Klasse, list Klasse of vector Klasse.

Voorbeeld

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

Hiermee wordt een iterator opgehaald naar het eerste element in een opgegeven container.

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]);

Parameters

cont
Een container.

array
Een matrix van objecten van het type Ty.

Retourwaarde

De eerste twee sjabloonfuncties retourneren cont.begin(). De eerste functie is niet-constant; de tweede is constant.

De derde sjabloonfunctie retourneert array.

Voorbeeld

U wordt aangeraden deze sjabloonfunctie te gebruiken in plaats van containerlid begin() wanneer er meer algemeen gedrag is vereist.

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

De functie reverse_sort ondersteunt containers van elk soort, naast reguliere matrices, omdat deze de niet-lidversie van begin(). Coderen reverse_sort om het containerlid begin()te gebruiken:

template <typename C>
void reverse_sort(C& c) {
    using std::begin;
    using std::end;

    std::sort(c.begin(), c.end(), std::greater<>());

}

Vervolgens wordt er een matrix naar verzonden, waardoor deze compilerfout wordt veroorzaakt:

error C2228: left of '.begin' must have class/struct/union

cbegin

Haalt een const (alleen-lezen) iterator op naar het eerste element in een opgegeven container.

template <class Container>
auto cbegin(const Container& cont)
   -> decltype(cont.begin());

Parameters

cont
Een container of initializer_list.

Retourwaarde

Een constante cont.begin().

Remarks

Deze functie werkt met alle C++-standaardbibliotheekcontainers en met initializer_list.

U kunt deze lidfunctie gebruiken in plaats van de begin() sjabloonfunctie om te garanderen dat de retourwaarde is const_iterator. Normaal gesproken wordt deze gebruikt met het auto trefwoord type aftrek, zoals wordt weergegeven in het volgende voorbeeld. In het voorbeeld kunt u overwegen Container om een wijzigbare (niet- const) container te zijn of initializer_list van elk type dat ondersteuning biedt begin() voor en cbegin().

auto i1 = Container.begin();
// i1 is Container<T>::iterator
auto i2 = Container.cbegin();

// i2 is Container<T>::const_iterator

cend

Haalt een const-iterator (alleen-lezen) op naar het element dat volgt op het laatste element in de opgegeven container.

template <class Container>
auto cend(const Container& cont)
   -> decltype(cont.end());

Parameters

cont
Een container of initializer_list.

Retourwaarde

Een constante cont.end().

Remarks

Deze functie werkt met alle C++-standaardbibliotheekcontainers en met initializer_list.

U kunt deze lidfunctie gebruiken in plaats van de end() sjabloonfunctie om te garanderen dat de retourwaarde is const_iterator. Normaal gesproken wordt deze gebruikt met het auto trefwoord type aftrek, zoals wordt weergegeven in het volgende voorbeeld. In het voorbeeld kunt u overwegen Container om een wijzigbare (niet- const) container te zijn of initializer_list van elk type dat ondersteuning biedt end() voor en cend().

auto i1 = Container.end();
// i1 is Container<T>::iterator
auto i2 = Container.cend();

// i2 is Container<T>::const_iterator

crbegin

Haal een omgekeerde alleen-lezen iterator op voor de elementen van de container, beginnend aan het einde van de container.

template <class C> constexpr auto crbegin(const C& c) -> decltype(std::rbegin(c));

Parameters

C
Het type container.

c
Een containerinstantie.

Retourwaarde

Deze iterator retourneert de elementen van de container in omgekeerde volgorde, beginnend aan het einde van de container.

Voorbeeld: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

Haal de sentinel aan het einde van een alleen-lezen omgekeerde reeks elementen op.

template <class C> constexpr auto crend(const C& c) -> decltype(std::rend(c));

Parameters

C
Het type container.

c
Een containerinstantie.

Retourwaarde

De sentinel volgt het laatste element in een omgekeerde weergave van de container.

crend voorbeeld

#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

Haal een aanwijzer op naar het eerste element in de container.

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;

Parameters

C
Het type container.

c
Een exemplaar van een container.

E
Het elementtype van de initialisatielijst.

il
Een initialisatielijst.

N
Het aantal elementen in de matrix.

T
Het type gegevens in de matrix.

Retourwaarde

1, 2) Een aanwijzer, op basis van het type container, naar het eerste element. Als de container bijvoorbeeld een vector van gehele getallen is, is het type van de retourwaarde een int *.

3) Een aanwijzer naar het eerste element als matrix.

4) Een aanwijzer naar het eerste element van de initialisatielijst.

Voorbeeld: 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

Bepaalt het aantal stappen tussen de posities die door twee iterators worden aangepakt.

template <class InputIterator>
typename iterator_traits<InputIterator>::difference_type distance(InputIterator first, InputIterator last);

Parameters

first
De eerste iterator waarvan de afstand van de tweede moet worden bepaald.

last
De tweede iterator waarvan de afstand van de eerste moet worden bepaald.

Retourwaarde

Het aantal keren dat first moet worden verhoogd totdat deze gelijk is lastaan .

Remarks

De afstandsfunctie heeft constante complexiteit wanneer InputIterator deze voldoet aan de vereisten voor een iterator voor willekeurige toegang; anders heeft deze lineaire complexiteit en is dit mogelijk duur.

Voorbeeld

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

Parameters

C
Het type container.

c
Een exemplaar van een container.

E
Het elementtype van de initialisatielijst.

il
Een initialisatielijst.

N
Het aantal elementen in de matrix.

T
Het type gegevens in de matrix.

Retourwaarde

Retourneert true als de container geen elementen heeft; anders false.

Voorbeeld

#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

Hiermee wordt een iterator opgehaald naar het element dat volgt op het laatste element in de opgegeven container.

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]);

Parameters

cont
Een container.

array
Een matrix van objecten van het type Ty.

Retourwaarde

De eerste twee sjabloonfuncties retourneren cont.end() (de eerste is niet-constant en de tweede is constant).

De derde sjabloonfunctie retourneert array + Size.

Remarks

Zie beginvoor een codevoorbeeld.

front_inserter

Hiermee maakt u een iterator die elementen aan de voorzijde van een opgegeven container kan invoegen.

template <class Container>
front_insert_iterator<Container> front_inserter(Container& Cont);

Parameters

Cont
Het containerobject waarvan de voorzijde een element heeft ingevoegd.

Retourwaarde

Een front_insert_iterator gekoppeld aan het containerobject Cont.

Remarks

De lidfunctie front_insert_iterator van de klasse front_insert_iterator kan ook worden gebruikt.

In de C++-standaardbibliotheek moet het argument verwijzen naar een van de twee reekscontainers met de lidfunctie push_back: deque Class of List Class.

Voorbeeld

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

Een helpersjabloonfunctie waarmee u inserter(Cont, Where) in plaats van insert_iterator<Container>(Cont, Where).

template <class Container>
insert_iterator<Container>
inserter(
    Container& Cont,
    typename Container::iterator Where);

Parameters

Cont
De container waaraan nieuwe elementen moeten worden toegevoegd.

Where
Een iterator die het invoegpunt vindt.

Remarks

De sjabloonfunctie retourneert insert_iterator<Container>(Cont, Where).

Voorbeeld

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

Hiermee maakt u een checked_array_iterator die kan worden gebruikt door andere algoritmen.

template <class Iter>
checked_array_iterator<Iter>
    make_checked_array_iterator(
Iter Ptr,
    size_t Size,
    size_t Index = 0);

Parameters

Ptr
Een aanwijzer naar de doelmatrix.

Size
De grootte van de doelmatrix.

Index
Optionele index in de matrix.

Retourwaarde

Een exemplaar van checked_array_iterator.

Remarks

De make_checked_array_iterator functie wordt gedefinieerd in de stdext naamruimte.

Deze functie gebruikt een onbewerkte aanwijzer, die normaal gesproken zorgen zou veroorzaken over de overloop van grenzen, en verpakt deze in een checked_array_iterator klasse die controleert. Omdat deze klasse is gemarkeerd als ingeschakeld, waarschuwt de C++-standaardbibliotheek er niet voor. Zie Gecontroleerde iterators voor meer informatie en codevoorbeelden.

Voorbeeld

In het volgende voorbeeld wordt een vector gemaakt en gevuld met 10 items. De inhoud van de vector wordt gekopieerd naar een matrix met behulp van het kopieeralgoritmen en wordt vervolgens make_checked_array_iterator gebruikt om de bestemming op te geven. Dit wordt gevolgd door een opzettelijke schending van de grenzencontrole, zodat er een fout in de foutopsporingsverklaring wordt geactiveerd.

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

Hiermee maakt u een move iterator die de opgegeven iterator als iterator stored bevat.

template <class Iterator>
move_iterator<Iterator>
make_move_iterator(const Iterator& It);

Parameters

It
De iterator die is opgeslagen in de nieuwe verplaatsings-iterator.

Remarks

De sjabloonfunctie retourneert move_iterator<Iterator>(_It).

make_unchecked_array_iterator

Hiermee maakt u een unchecked_array_iterator die kan worden gebruikt door andere algoritmen.

template <class Iter>
unchecked_array_iterator<Iter>
    make_unchecked_array_iterator(Iter Ptr);

Parameters

Ptr
Een aanwijzer naar de doelmatrix.

Retourwaarde

Een exemplaar van unchecked_array_iterator.

Remarks

De make_unchecked_array_iterator functie wordt gedefinieerd in de stdext naamruimte.

Deze functie gebruikt een onbewerkte aanwijzer en verpakt deze in een klasse die geen controle uitvoert en daarom wordt geoptimaliseerd voor niets, maar ook compilerwaarschuwingen zoals C4996 stillegt. Daarom is dit een gerichte manier om niet-aangevinkte aanwijzerwaarschuwingen af te handelen zonder ze globaal af te sluiten of de kosten voor controle te maken. Zie Gecontroleerde iterators voor meer informatie en codevoorbeelden.

Voorbeeld

In het volgende voorbeeld wordt een vector gemaakt en gevuld met 10 items. De inhoud van de vector wordt gekopieerd naar een matrix met behulp van het kopieeralgoritmen en wordt vervolgens make_unchecked_array_iterator gebruikt om de bestemming op te geven.

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

Herhaalt een opgegeven aantal keren en retourneert de nieuwe iteratorpositie.

template <class InputIterator>
InputIterator next(
    InputIterator first,
    typename iterator_traits<InputIterator>::difference_type off = 1);

Parameters

first
De huidige positie.

off
Het aantal keren dat het moet worden herhaald.

Retourwaarde

Retourneert de nieuwe iteratorpositie na herhalende off tijden.

Remarks

De sjabloonfunctie retourneert next incrementele off tijden

prev

Herhaalt een opgegeven aantal keren omkeren en retourneert de nieuwe iteratorpositie.

template <class BidirectionalIterator>
BidirectionalIterator prev(
    BidirectionalIterator first,
    typename iterator_traits<BidirectionalIterator>::difference_type off = 1);

Parameters

first
De huidige positie.

off
Het aantal keren dat het moet worden herhaald.

Remarks

De sjabloonfunctie retourneert next aflopende off tijden.

rbegin

Haal een iterator op, die de elementen van de container in omgekeerde volgorde retourneert.

template <class C> constexpr auto rbegin(C& c) -> decltype(c.rbegin());
template <class C> constexpr auto rbegin(const C& c) -> decltype(c.rbegin());

Parameters

C
Het type container.

c
Een containerinstantie.

Retourwaarde

De geretourneerde iterator geeft de elementen van de container in omgekeerde volgorde weer, beginnend aan het einde van het omgekeerde bereik.

Voorbeeld: 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

Haal de sentinel aan het einde van een omgekeerde reeks elementen op.

template <class C> constexpr auto rend(C& c)-> decltype(c.rend());
template <class C> constexpr auto rend(const C& c) -> decltype(c.rend());

Parameters

C
Het type container.

c
Een containerinstantie.

Retourwaarde

Een omgekeerde iterator naar de sentinel aan het einde van de container. De sentinel volgt het laatste element in de omgekeerde weergave van de container:

rend voorbeeld

#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;

Parameters

C
Het type container.

c
Een exemplaar van een container.

N
Het aantal elementen in de matrix.

T
Het type gegevens in de matrix.

Retourwaarde

Het aantal elementen in de container als een niet-ondertekende geheel getalachtige waarde.

Voorbeeld: 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