<ranges> – funkce

Hlavička <ranges>^C++20 obsahuje následující pomocné funkce, které nejsou členy.

Nečlenové funkce	Popis
beginC++20	Získejte iterátor k prvnímu prvku v oblasti.
cbeginC++20	const Získejte iterátor k prvnímu prvku v oblasti.
cendC++20	Získejte sentinel na konci kvalifikovaného rozsahu const.
cdataC++20	const Získejte ukazatel na první prvek v souvislé oblasti.
crbeginC++20	Na začátek rozsahu získáte reverzní const iterátor.
crendC++20	Získejte sentinel na konci toho, co crbegin() se vrátí.
dataC++20	Získejte ukazatel na první prvek v souvislé oblasti.
emptyC++20	Otestujte, jestli je oblast prázdná.
endC++20	Získejte sentinel na konci rozsahu.
rbeginC++20	Na začátek rozsahu získáte reverzní iterátor.
rendC++20	Získejte reverzní iterátor do sentinelu na konci rozsahu.
sizeC++20	Získá velikost rozsahu jako nepodepsanou hodnotu.
ssizeC++20	Získá velikost rozsahu jako podepsanou hodnotu.

Mnohé z těchto "funkcí" jsou implementovány jako objekty bodu přizpůsobení. Objekt bodu přizpůsobení je objekt funkce, který lze přetížit u uživatelem definovaných typů, a zároveň vynucuje omezení, u kterých typů lze předat objektu funkce. Čistý efekt spočívá v tom, že kompilátor zjistí, jestli existuje platná přizpůsobená funkce pro volání předaného typu, nebo jestli se má použít výchozí implementace, nebo pokud je volání špatně vytvořené.

Mnoho z těchto funkcí má odpovídající funkce v std oboru názvů. Při práci s oblastmi ale místo toho používejte tyto pomocné funkce. Tyto funkce používají koncepty C++20, které poskytují lepší chyby v době kompilace. Vzhledem k tomu, že jsou implementované jako body přizpůsobení, jsou problémy související se vyhledáváním závislými na argumentech (ADL) a správnosti constů zabráněno.

begin

Získejte iterátor k prvnímu prvku v oblasti.

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

Parametry

T
Typ rozsahu.

rg
Rozsah.

Vrácená hodnota

Iterátor na první prvek v rozsahu:

Pokud je oblast matice, vrátí ekvivalent .rg + 0 Pokud auto(rg.begin()) vrátí iterátor, vrátí ekvivalent .auto(rg.begin()) Pokud je tento výraz špatně vytvořený, použije se, auto(begin(rg)) pokud tento výraz získá iterátor.

Poznámky

ranges::begin() funguje na všech rozsazích, zatímco std::begin() nemusí.

Příklad: 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

const Získejte iterátor k prvnímu prvku v oblasti. Iterátor má přístup k prvkům v oblasti, ale nemůže je upravovat.

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

Parametry

T
Typ rozsahu.

rg
Rozsah.

Vrácená hodnota

const Iterátor na první prvek v rozsahu:

Pokud je oblast matice, vrátí ekvivalent .rg + 0 Pokud auto(rg.cbegin()) vrátí iterátor, vrátí ekvivalent .auto(rg.cbegin()) Pokud je tento výraz špatně vytvořený, použije se, auto(cbegin(rg)) pokud tento výraz získá iterátor.

Poznámky

ranges::cbegin() funguje na všech rozsazích, zatímco std::cbegin() nemusí.

Příklad: 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

const Získejte ukazatel na první prvek v souvislé oblasti.

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

Parametry

T
Typ rozsahu.

rg
Rozsah.

Vrácená hodnota

const Ukazatel na základě typu oblasti na první prvek dat v souvislé oblasti. Pokud je například oblast vektorem celých čísel, typ návratové hodnoty je .const int *

Příklad: 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

Získejte sentinel na konci kvalifikovaného rozsahu const. Iterátor má přístup k prvkům v oblasti, ale nemůže je upravovat.

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

Parametry

T
Typ rozsahu.

rg
Rozsah.

Vrácená hodnota

Sentinel, který následuje za posledním prvkem v -kvalifikovaném rozsahu const:

Poznámky

ranges::cend() funguje na všech rozsazích, zatímco std::cend() nemusí.

Příklad: 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

Získejte reverzní const iterátor na první prvek v obráceném rozsahu. Reverzní iterátor vrátí prvky oblasti v obráceném pořadí. Samotný rozsah není obrácený; přístup k němu je.

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

Parametry

T
Typ rozsahu.

rg
Rozsah.

Vrácená hodnota

Reverzní const iterátor na první prvek v oblasti. Tento iterátor vrátí prvky oblasti v obráceném pořadí počínaje koncem rozsahu:

Pokud je oblast matice, vrátí ekvivalent místa reverse_iterator{rg + n} , kde n je počet prvků v matici. Pokud auto(rg.crbegin()) vrátí iterátor, vrátí ekvivalent .auto(rg.crbegin()) Pokud je tento výraz špatně vytvořený, použije se, auto(crbegin(rg)) pokud tento výraz získá iterátor.

Poznámky

ranges::crbegin() funguje na všech obousměrných rozsazích, zatímco std::crbegin() nemusí.

Příklad: 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

Získejte sentinel na konci toho, co crbegin() se vrátí. Reverzní iterátor vrátí prvky oblasti v obráceném pořadí. Samotný rozsah není obrácený; přístup k němu je.

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

Parametry

T
Typ rozsahu.

rg
Rozsah.

Vrácená hodnota

Sentinel na konci toho, co cbegin() se vrátí. Sentinel následuje poslední prvek v obráceném zobrazení oblasti:

Poznámky

ranges::crend() funguje na všech obousměrných rozsazích, zatímco std::crend() nemusí.

crend příklad

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

Získá ukazatel na první prvek v souvislé oblasti.

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

Parametry

T
Typ rozsahu.

rg
Rozsah.

Vrácená hodnota

Ukazatel na základě typu rozsahu na první prvek v souvislé oblasti. Pokud je například oblast vektorem celých čísel, typ návratové hodnoty je .int *

Příklad

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

Otestujte, jestli je oblast prázdná.

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

Parametry

T
Typ rozsahu.

rg
Rozsah.

Vrácená hodnota

Vrátí, pokud oblast neobsahuje true žádné prvky; jinak false.

Příklad

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

Získejte sentinel na konci rozsahu.

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

Parametry

T
Typ rozsahu.

rg
Rozsah.

Vrácená hodnota

Sentinel, který následuje za posledním prvkem v rozsahu:

Poznámky

ranges::end() funguje na všech rozsazích, zatímco std::end() nemusí.

Příklad

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

Získejte reverzní iterátor na první prvek v obráceném rozsahu. Reverzní iterátor vrátí prvky oblasti v obráceném pořadí. Samotný rozsah není obrácený; přístup k němu je.

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

Parametry

T
Typ rozsahu.

rg
Rozsah.

Vrácená hodnota

Reverzní iterátor na první prvek v oblasti. Tento iterátor vrátí prvky oblasti v obráceném pořadí počínaje koncem obrácené oblasti:

Pokud je oblast matice, vrátí ekvivalent místa reverse_iterator{rg + n} , kde n je počet prvků v matici. Pokud auto(rg.rbegin()) vrátí iterátor, vrátí ekvivalent .auto(rg.rbegin()) Pokud je tento výraz špatně vytvořený, použije se, auto(rbegin(rg)) pokud tento výraz získá iterátor.

Poznámky

ranges::rbegin() funguje na všech obousměrných rozsazích, zatímco std::rbegin() nemusí.

Příklad

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

Získejte reverzní iterátor do sentinelu na konci obráceného zobrazení oblasti. Reverzní iterátor vrátí prvky oblasti v obráceném pořadí. Samotný rozsah není obrácený; přístup k němu je.

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

Parametry

T
Typ rozsahu.

rg
Rozsah.

Vrácená hodnota

Reverzní iterátor na sentinel na konci rozsahu. Sentinel následuje poslední prvek v obráceném zobrazení oblasti:

Poznámky

ranges::rend() funguje na všech obousměrných rozsazích, zatímco std::rend() nemusí.

Příklad

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

Získá počet prvků v oblasti jako nepodepsanou hodnotu.

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

Parametry

T
Typ rozsahu.

rg
Rozsah.

Vrácená hodnota

Počet prvků v oblasti jako celočíselná hodnota bez znaménka.

Poznámky

Tato funkce se provádí v konstantním čase.

Příklad

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

Získá velikost rozsahu jako podepsanou hodnotu.

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

Parametry

T
Typ rozsahu.

rg
Rozsah.

Vrácená hodnota

Počet prvků v oblasti jako celočíselná hodnota typu signed.

Poznámky

Tato funkce se provádí v konstantním čase.

Příklad

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

Viz také

<ranges>
Co jsou objekty přizpůsobení