Freigeben über

<ranges> -Funktionen

  • Artikel

Der <ranges>C++20-Header enthält die folgenden Nicht-Member-Hilfsfunktionen.

Nicht-Member-Funktionen Beschreibung
beginC++20 Rufen Sie einen Iterator zum ersten Element im Bereich ab.
cbeginC++20 Rufen Sie einen const Iterator zum ersten Element im Bereich ab.
cendC++20 Rufen Sie den Sentinel am Ende des constqualifizierten Bereichs ab.
cdataC++20 Rufen Sie einen const Zeiger auf das erste Element im zusammenhängenden Bereich ab.
crbeginC++20 Rufen Sie einen umgekehrten const Iterator zum Anfang des Bereichs ab.
crendC++20 Rufen Sie den Sentinel am Ende der crbegin() Rückgabe ab.
dataC++20 Rufen Sie einen Zeiger auf das erste Element im zusammenhängenden Bereich ab.
emptyC++20 Testen Sie, ob der Bereich leer ist.
endC++20 Rufen Sie den Sentinel am Ende des Bereichs ab.
rbeginC++20 Rufen Sie einen umgekehrten Iterator zum Anfang des Bereichs ab.
rendC++20 Rufen Sie einen umgekehrten Iterator am Ende des Bereichs zum Sentinel ab.
sizeC++20 Ruft die Größe des Bereichs als nicht signierten Wert ab.
ssizeC++20 Ruft die Größe des Bereichs als signierten Wert ab.

Viele dieser Funktionen werden als Anpassungspunktobjekte implementiert. Ein Anpassungspunktobjekt ist ein Funktionsobjekt , das in benutzerdefinierten Typen überladen werden kann, und gleichzeitig Einschränkungen erzwingt, welche Typen an das Funktionsobjekt übergeben werden können. Der Nettoeffekt ist, dass der Compiler herausfindet, ob eine gültige angepasste Funktion zum Aufrufen des übergebenen Typs vorhanden ist oder wenn die Standardimplementierung verwendet werden soll oder wenn der Aufruf unformiert ist.

Viele dieser Funktionen verfügen über entsprechende Funktionen im std Namespace. Verwenden Sie beim Arbeiten mit Bereichen stattdessen diese Hilfsfunktionen. Diese Funktionen verwenden C++20-Konzepte, die bessere Kompilierungszeitfehler bieten. Da sie als Anpassungspunkte implementiert werden, werden Probleme im Zusammenhang mit der argumentabhängigen Suche (ADL) und der Korrektheit vermieden.

begin

Rufen Sie einen Iterator zum ersten Element im Bereich ab.

template<class T>
constexpr std::input_or_output_iterator auto begin(T&& rg);

Parameter

T
Der Typ des Bereichs.

rg
Ein Bereich.

Rückgabewert

Ein Iterator für das erste Element im Bereich:

Abbildung eines Vektors mit den Elementen 10, 20 und 30. Das erste Element enthält 10 und heißt

Wenn der Bereich ein Array ist, wird das Äquivalent von rg + 0. Wenn auto(rg.begin()) ein Iterator zurückgegeben wird, wird das Äquivalent von auto(rg.begin()). Wenn dieser Ausdruck unformiert ist, wird verwendet, auto(begin(rg)) wenn dieser Ausdruck einen Iterator zurückgibt.

Hinweise

ranges::begin() funktioniert auf allen Bereichen, aber std::begin() nicht.

Beispiel: begin

// requires /std:c++20 or later
#include <vector>
#include <ranges>
#include <iostream>

int main()
{
    std::vector<int> v = {10, 20, 30};
    auto vi = std::ranges::begin(v);
    std::cout << *vi << ' ' << *++vi; // outputs 10 20
}

cbegin

Rufen Sie einen const Iterator zum ersten Element in einem Bereich ab. Der Iterator kann auf die Elemente im Bereich zugreifen, aber nicht ändern.

template<class T>
constexpr std::input_or_output_iterator auto cbegin(T&& rg);

Parameter

T
Der Typ des Bereichs.

rg
Ein Bereich.

Rückgabewert

Ein const Iterator für das erste Element im Bereich:

Abbildung eines Vektors mit den Elementen 10, 20 und 30. Das erste Element enthält 10 und ist mit

Wenn der Bereich ein Array ist, wird das Äquivalent von rg + 0. Wenn auto(rg.cbegin()) ein Iterator zurückgegeben wird, wird das Äquivalent von auto(rg.cbegin()). Wenn dieser Ausdruck unformiert ist, wird verwendet, auto(cbegin(rg)) wenn dieser Ausdruck einen Iterator zurückgibt.

Hinweise

ranges::cbegin() funktioniert auf allen Bereichen, aber std::cbegin() nicht.

Beispiel: cbegin

// requires /std:c++20 or later
#include <vector>
#include <ranges>
#include <iostream>

int main()
{
    std::vector<int> v = {10, 20, 30};
    auto vi = std::ranges::cbegin(v);
    std::cout << *vi; // outputs 10
    // *vi = 100; // error because the iterator is const
}

cdata

Rufen Sie einen const Zeiger auf das erste Element im zusammenhängenden Bereich ab.

template<class T>
constexpr std::add_pointer_t<ranges::range_reference_t<const T>> cdata(T&& rg);

Parameter

T
Der Typ des Bereichs.

rg
Ein Bereich.

Rückgabewert

Ein const Zeiger basierend auf dem Typ des Bereichs auf die ersten Elementdaten im zusammenhängenden Bereich. Wenn der Bereich z. B. ein Vektor ganzzahliger Zahlen ist, ist der Typ des Rückgabewerts ein const int *.

Beispiel: cdata

#include <ranges>
#include <iostream>

int main()
{
    std::vector v{10, 20, 30};
    std::string src{ "a string" };
   
    auto c_charPtr = std::ranges::cdata(src); // ptr is a const char *
    auto c_intPtr = std::ranges::cdata(v); // ptr2 is a const int *
    std::cout << c_charPtr << ", " << *c_intPtr << '\n'; // outputs a string, 10

    // *c_intPtr = 100; // error - cannot assign to a const pointer
    // *charPtr = 'A'; // error - cannot assign to a const pointer
}

cend

Rufen Sie den Sentinel am Ende des constqualifizierten Bereichs ab. Der Iterator kann auf die Elemente im Bereich zugreifen, aber nicht ändern.

template<class T>
constexpr std::sentinel_for<decltype(ranges::cbegin(std::declval<T>()))> auto cend(T&& rg);

Parameter

T
Der Typ des Bereichs.

rg
Ein Bereich.

Rückgabewert

Der Sentinel, der auf das letzte Element im const-qualifizierten Bereich folgt:

Abbildung eines Vektors mit den Elementen 10, 20 und 30. Das erste Element enthält 10 und ist mit cbegin() beschriftet. Das letzte Element enthält 30 und wird als

Hinweise

ranges::cend() funktioniert auf allen Bereichen, aber std::cend() nicht.

Beispiel: cend

// requires /std:c++20 or later
#include <vector>
#include <ranges>
#include <iostream>

int main()
{
    std::vector<int> v = {10, 20, 30};
    auto i = std::ranges::cend(v);
    --i; // get off the sentinel and onto the last element in the range
    std::cout << *i; // outputs 30
    // *i = 300 // error because the iterator is const
}

crbegin

Rufen Sie einen umgekehrten const Iterator zum ersten Element in einem umgekehrten Bereich ab. Ein Umgekehrter Iterator gibt die Elemente des Bereichs in umgekehrter Reihenfolge zurück. Der Bereich selbst wird nicht umgekehrt; Zugriff darauf ist.

template<class T>
constexpr std::input_or_output_iterator auto crbegin(T&& rg);

Parameter

T
Der Typ des Bereichs.

rg
Ein Bereich.

Rückgabewert

Ein Umgekehrter const Iterator zum ersten Element im Bereich. Dieser Iterator gibt die Elemente des Bereichs in umgekehrter Reihenfolge zurück, beginnend am Ende des 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. Es ist mit crend() beschriftet. Das erste Element im Vektor enthält die Zahl 10 und wird als

Wenn der Bereich ein Array ist, wird das Äquivalent zurückgegeben reverse_iterator{rg + n} , bei dem n es sich um die Anzahl der Elemente im Array handelt. Wenn auto(rg.crbegin()) ein Iterator zurückgegeben wird, wird das Äquivalent von auto(rg.crbegin()). Wenn dieser Ausdruck unformiert ist, wird verwendet, auto(crbegin(rg)) wenn dieser Ausdruck einen Iterator zurückgibt.

Hinweise

ranges::crbegin() funktioniert auf allen bidirektionalen Bereichen, aber std::crbegin() nicht.

Beispiel: crbegin

// requires /std:c++20 or later
#include <vector>
#include <ranges>
#include <iostream>

int main()
{
    std::vector v{10, 20, 30};
    auto vi = std::ranges::crbegin(v);
    std::cout << *vi << ' ' << *++vi << ' ' << *++vi; // outputs 30 20 10
    // vi[1] = 100; // error because the iterator is const
}

crend

Rufen Sie den Sentinel am Ende der crbegin() Rückgabe ab. Ein Umgekehrter Iterator gibt die Elemente des Bereichs in umgekehrter Reihenfolge zurück. Der Bereich selbst wird nicht umgekehrt; Zugriff darauf ist.

template<class T>
std::sentinel_for<decltype(ranges::crbegin(declval<T>()))> auto crend(T&& rg);

Parameter

T
Der Typ des Bereichs.

rg
Ein Bereich.

Rückgabewert

Der Sentinel am Ende der cbegin() Rückgabe. Der Sentinel folgt dem letzten Element in einer umgekehrten Ansicht des 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. Es ist mit crend() beschriftet. Das erste Element im Vektor enthält die Zahl 10 und wird als

Hinweise

ranges::crend() funktioniert auf allen bidirektionalen Bereichen, aber std::crend() nicht.

crend-Beispiel

// requires /std:c++20 or later
#include <vector>
#include <ranges>
#include <iostream>

int main()
{
    std::vector v{10, 20, 30};
    auto vi = std::ranges::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    
    std::cout << *vi << ' ' << *--vi << ' ' << *--vi; // outputs 10, 20, 30
}

data

Rufen Sie einen Zeiger auf das erste Element in einem zusammenhängenden Bereich ab.

template<class T>
constexpr std::add_pointer_t<ranges::range_reference_t<T>> data(T&& rg);

Parameter

T
Der Typ des Bereichs.

rg
Ein Bereich.

Rückgabewert

Ein Zeiger basierend auf dem Typ des Bereichs auf das erste Element im zusammenhängenden Bereich. Wenn der Bereich beispielsweise ein Vektor ganzzahliger Zahlen ist, ist der Typ des Rückgabewerts ein int *.

Beispiel

// requires /std:c++20 or later
#include <vector>
#include <ranges>
#include <iostream>

int main()
{
    std::vector v{10, 20, 30};
    std::string src{ "a string" };
   
    auto charPtr = std::ranges::data(src); // charPtr is a char *
    auto intPtr = std::ranges::data(v); // intPtr is an int *
    std::cout << charPtr << ", " << *intPtr << '\n'; // outputs a string, 10
    *intPtr = 100;
    *charPtr = 'A';
    std::cout << charPtr << ", " << *intPtr; // outputs A string, 100
}

empty

Testen Sie, ob der Bereich leer ist.

template<class T>
constexpr bool empty(T&& rg);

Parameter

T
Der Typ des Bereichs.

rg
Ein Bereich.

Rückgabewert

Gibt zurück true , wenn der Bereich keine Elemente enthält; andernfalls false.

Beispiel

// requires /std:c++20 or later
#include <vector>
#include <ranges>
#include <iostream>

int main()
{
        std::vector v{10,20,30};
    std::vector<int> v2;

    std::cout << std::boolalpha << std::ranges::empty(v); // outputs false
    std::cout << std::boolalpha << ", " << std::ranges::empty(v2); // outputs true
}

end

Rufen Sie den Sentinel am Ende des Bereichs ab.

template<class T>
std::sentinel_for<ranges::iterator_t<T>> auto end(T&& rg);

Parameter

T
Der Typ des Bereichs.

rg
Ein Bereich.

Rückgabewert

Der Sentinel, der auf das letzte Element im Bereich folgt:

Abbildung eines Vektors mit den Elementen 10, 20 und 30. Das erste Element enthält 10 und ist mit

Hinweise

ranges::end() funktioniert auf allen Bereichen, aber std::end() nicht.

Beispiel

// requires /std:c++20 or later
#include <vector>
#include <ranges>
#include <iostream>

int main()
{
    std::vector<int> v = {10, 20, 30};
    auto i = std::ranges::end(v);
    --i; // get off the sentinel and onto the last element in the range
    std::cout << *i; // outputs 30
}

rbegin

Rufen Sie einen umgekehrten Iterator zum ersten Element in einem umgekehrten Bereich ab. Ein Umgekehrter Iterator gibt die Elemente des Bereichs in umgekehrter Reihenfolge zurück. Der Bereich selbst wird nicht umgekehrt; Zugriff darauf ist.

template<class T>
constexpr std::input_or_output_iterator auto rbegin(T&& rg);

Parameter

T
Der Typ des Bereichs.

rg
Ein Bereich.

Rückgabewert

Ein Umgekehrter Iterator zum ersten Element im Bereich. Dieser Iterator gibt die Elemente des Bereichs in umgekehrter Reihenfolge zurück, 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

Wenn der Bereich ein Array ist, wird das Äquivalent zurückgegeben reverse_iterator{rg + n} , bei dem n es sich um die Anzahl der Elemente im Array handelt. Wenn auto(rg.rbegin()) ein Iterator zurückgegeben wird, wird das Äquivalent von auto(rg.rbegin()). Wenn dieser Ausdruck unformiert ist, wird verwendet, auto(rbegin(rg)) wenn dieser Ausdruck einen Iterator zurückgibt.

Hinweise

ranges::rbegin() funktioniert auf allen bidirektionalen Bereichen, aber std::rbegin() nicht.

Beispiel

// requires /std:c++20 or later
#include <vector>
#include <ranges>
#include <iostream>

int main()
{
    std::vector v{10, 20, 30};
    auto vi = std::ranges::rbegin(v);
    std::cout << *vi << ' ' << *++vi << ' ' << *++vi; // outputs 30 20 10
}

rend

Rufen Sie am Ende einer umgekehrten Ansicht des Bereichs einen umgekehrten Iterator zum Sentinel ab. Ein Umgekehrter Iterator gibt die Elemente des Bereichs in umgekehrter Reihenfolge zurück. Der Bereich selbst wird nicht umgekehrt; Zugriff darauf ist.

template<class T>
constexpr 
std::sentinel_for<decltype(ranges::rbegin(std::declval<T>()))> auto rend(T&& rg);

Parameter

T
Der Typ des Bereichs.

rg
Ein Bereich.

Rückgabewert

Ein umgekehrter Iterator zum Sentinel am Ende des Bereichs. Der Sentinel folgt dem letzten Element in einer umgekehrten Ansicht des 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

Hinweise

ranges::rend() funktioniert auf allen bidirektionalen Bereichen, aber std::rend() nicht.

Beispiel

// requires /std:c++20 or later
#include <vector>
#include <ranges>
#include <iostream>

int main()
{
    std::vector v{10, 20, 30};
    auto vi = std::ranges::rend(v);
    --vi; // get off the sentinel and onto the last element in the reversed range
    std::cout << *vi; // outputs 10
    std::cout << *vi << ' ' << *--vi << ' ' << *--vi; // outputs 10, 20, 30
}

size

Ruft die Anzahl der Elemente im Bereich als nicht signierten Wert ab.

template<class T>
constexpr /*unsigned integer-like type */ size(T&& rg);

Parameter

T
Der Typ des Bereichs.

rg
Ein Bereich.

Rückgabewert

Die Anzahl der Elemente im Bereich als nicht signierter ganzzahliger Wert.

Hinweise

Diese Funktion wird in konstanter Zeit ausgeführt.

Beispiel

// requires /std:c++20 or later
#include <vector>
#include <ranges>
#include <iostream>

int main()
{
    std::vector v{10, 20, 30};
    auto s = std::ranges::size(v); // s is a size_t
    std::cout << s; // outputs 3
}

ssize

Ruft die Größe des Bereichs als signierten Wert ab.

template<class T>
constexpr /* signed-integer-like type */ ssize(T&& rg);

Parameter

T
Der Typ des Bereichs.

rg
Ein Bereich.

Rückgabewert

Die Anzahl der Elemente im Bereich als signierter ganzzahliger Wert.

Hinweise

Diese Funktion wird in konstanter Zeit ausgeführt.

Beispiel

// requires /std:c++20 or later
#include <vector>
#include <ranges>
#include <iostream>

int main()
{
    std::vector v{10, 20, 30};
    auto s = std::ranges::ssize(v);
    std::cout << s; // outputs 3
}

Siehe auch

<ranges>
Was sind Anpassungsobjekte?