Aralık bağdaştırıcıları

Aralık bağdaştırıcıları bir aralıktan bir görünüm (ad alanında Görünüm sınıflarındanstd::views) oluşturur. Görünüm türlerini doğrudan oluşturmak yerine görünüm oluşturmak için bir bağdaştırıcı kullanmanızı öneririz. Bağdaştırıcılar, görünümlere erişmenin amaçlanan yoludur. Bunlar, doğrudan görünüm türlerinin örneklerini oluşturmaktan daha kolay ve bazı durumlarda daha verimlidir.

Görünüm, bir aralıktaki öğelere başvuran basit bir nesnedir. Bir görünüm:

Bir aralıktan yalnızca belirli öğelerden oluşur.
Bir aralıktaki öğelerin dönüşümlerini temsil eden.
Bir aralığın tersi veya yalnızca ilk n öğeleri olabilir.
Önceki öğelerin bir bileşimi olun.

Görünüm, O(1)kaç öğe olursa olsun kopyalamak, atamak ve yok etmek için ucuzdur. Aşağıdaki örneği inceleyin:

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

int main()
{
    std::vector<int> input =  {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    auto divisible_by_three = [](const int n) {return n % 3 == 0;};
    auto square = [](const int n) {return n * n;};

    auto x = input | std::views::filter(divisible_by_three)
                   | std::views::transform(square);

    for (int i : x)
    {
        std::cout << i << ' ';
    }
}

0 9 36 81

İlk aralık bağdaştırıcısı olan filter, öğesinden input üçe bölünebilen öğeleri içeren bir görünüm sağlar. Diğer aralık bağdaştırıcısı olan transform, üçe bölünebilen öğeleri içeren görünümü alır ve bu öğelerin karesinin bir görünümünü sağlar.

Bir aralık bağdaştırıcısı bir görünüm oluşturduğunda, bu görünümü oluşturmak için aralıktaki her öğeyi dönüştürme maliyetine neden olmaz. Görünümdeki bir öğeyi işleme maliyeti yalnızca söz konusu öğeye eriştiğinizde ödenir.

Görünüm oluşturmak, gelecekte iş yapmaya hazırlanmaktır. Önceki örnekte, görünümü oluşturmak üç veya bu öğelerin karesini alarak tüm öğelerin bulunmasına neden olmaz. Çalışma yalnızca görünümdeki bir öğeye eriştiğinizde gerçekleşir.

Görünümün öğeleri genellikle görünümü oluşturmak için kullanılan aralığın gerçek öğeleridir. Görünüm genellikle öğelerin sahibi değildir; yalnızca bunlara başvurur, dışında owning_view. Öğenin değiştirilmesi, görünümün oluşturulduğu aralıktaki öğeyi değiştirir. Aşağıdaki örnekte bu davranış gösterilmektedir:

#include <algorithm>
#include <iostream>
#include <ranges>

int main()
{
    int input[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    auto even = [](const int n) { return n % 2 == 0; };
    auto x = input | std::views::filter(even); // create a view of the even elements from input

    for (int &i : x)
    {
        std::cout << i << ' '; // 0 2 4 6 8 10
    }
    std::cout << '\n'; 

    std::ranges::fill(x, 42); // changes the evens from input[] to 42
    for (int &i : input) // demonstrates that the even elements in the range are modified
    {
        std::cout << i << ' '; // // 42 1 42 3 42 5 42 7 42 9 42
    }
}

Aralık bağdaştırıcıları birçok biçimde gelir. Örneğin, aşağıdakilere göre bir görünüm oluşturmanıza olanak sağlayan aralık bağdaştırıcıları vardır:

Bir koşula (filter) göre başka bir aralığı filtreleme.
Bir aralıktakitransform () öğeleri dönüştürme.
Aralığı bölme (split).

Aralık bağdaştırıcıları birbirine zincirlenebilir (birleştirilebilir). Aralıkların gücü ve esnekliği en belirgin olduğu yerdir. Aralık bağdaştırıcıları oluşturma, önceki Standart Şablon Kitaplığı (STL) algoritmalarıyla ilgili temel bir sorunun üstesinden gelmenize olanak tanır. Bu, bunların birlikte zincirlemesinin kolay olmadığından kaynaklanır.

Aşağıdaki aralık bağdaştırıcıları ad alanında std::views kullanılabilir. Ad std::views alanı için std::ranges::viewsbir kolaylık diğer adıdır.

Aralık bağdaştırıcısı	Açıklama
`all` ^C++20	Bir aralığa ve öğelerine başvuran bir görünüm oluşturun.
`common` ^C++20	Olmayan bir aralıktan aynı yineleyici ve sentinel türlerine sahip bir görünüm oluşturun.
`counted` ^C++20	Belirtilen konumdan başlayarak bir aralığın ilk n öğesinin görünümünü oluşturun.
`drop` ^C++20	Belirtilen sayıda öğeyi önden atlayarak başka bir görünümden görünüm oluşturun.
`drop_while` ^C++20	Belirtilen koşulla eşleşen önde gelen öğeler bırakıldıktan sonra kalan bir aralığın öğelerini içeren bir görünüm oluşturun.
`elements` ^C++20	Bir aralıktaki her tanımlama grubu benzeri değerde seçili dizinin görünümünü oluşturun.
`empty` ^C++20	Öğesi olmayan bir görünüm oluşturun.
`filter` ^C++20	Belirtilen koşulla eşleşen bir aralığın öğelerini içeren bir görünüm oluşturun.
`iota` ^C++20	Artan değerler dizisi içeren bir görünüm oluşturun.
`istream` ^C++20	Akışın öğeleri üzerinde bir görünüm oluşturun.
`join` ^C++20	Birden çok aralığın tüm öğelerini tek bir görünümde birleştiren bir görünüm oluşturun.
`keys` ^C++20	Bir koleksiyondaki her tanımlama grubu benzeri değerde ilk dizinin görünümünü oluşturun.
`lazy_split` ^C++20	Bir görünümü sınırlayıcıya göre alt bölümlere ayırın.
`reverse` ^C++20	Bir aralığın öğelerinin ters sırada bir görünümünü oluşturun.
`single` ^C++20	Bir öğe içeren bir görünüm oluşturun.
`split` ^C++20	Bir görünümü sınırlayıcıya göre alt bölümlere ayırın.
`take` ^C++20	Başka bir görünümden ilk n öğe görünümünü oluşturun.
`take_while` ^C++20	Belirtilen koşulla eşleşen bir aralığın önde gelen öğelerini içeren bir görünüm oluşturun.
`transform` ^C++20	Dönüştürülen öğelerin görünümünü başka bir görünümden oluşturun.
`values` ^C++20	Bir koleksiyondaki her tanımlama grubu benzeri değerde ikinci dizinin görünümünü oluşturun.

Önceki tabloda, bir aralık bağdaştırıcısı genellikle aralık alma ve görünüm oluşturma olarak tanımlanır. Kesin olarak, aralık bağdaştırıcılarının aşağıdakilerden birini kabul eden bir aralık bağımsız değişkeni vardır:

türü cv-unqualified modelleri viewve bağımsız değişkeni bir rvalue veya kopyalanabilir.
Bağımsız değişkeni bir lvalue olarak geçirdiğinizde, görünüm boyunca modellenmeli range ve yaşamalıdır.
bağımsız değişkenini çağırırken owning_viewolduğu gibi bir rvalue olarak geçirdiğinizde ve rangemodellenmelidirmovable.

Aralık bağdaştırıcı işlevleri genellikle işlev çağrıları gibi görünen ve geçirilebilen türlerde kısıtlamaları zorlayan işlev nesneleridir.

İşlev nesnelerini bekleyen koda aralık bağdaştırıcılarını ve boru işlemlerinin (|) sonucunu geçirebilirsiniz. Aşağıdaki örnekte, aralık bağdaştırıcısının split oluşturduğu görünüm, aralık bağdaştırıcısı bir işlev nesnesi olduğundan bir işlev çağrısı tarafından aralık bağdaştırıcısına transform geçirilirtransform.

std::map<int, string> x = {{0, "Hello, world"}, {42, "Goodbye, world"}};
auto y = x | views::values | views::transform(views::split(' '));
// y is a range whose elements are ranges of whitespace-delimited strings from each value in x:
// {{"Hello", "world"}, {"Goodbye", "world"}}

`all`

Bir aralıktaki tüm öğelerin görünümünü oluşturun.

template <ranges::viewable_range R>
constexpr ranges::view auto all(R&& rg) const noexcept;

Parametreler

R
Temel alınan aralığın türü.

rg
Görünümün oluşturulacağı aralık.

Dönüş değeri

Zaten bir görünümse rg , bir kopyasıdır rg.
Görüntüleme olmayan bir lvalue iserg, öğesine başvuran ref_viewbir rg değeridir. (Görünümün rgömrü,.)
rg Geçici bir nesne gibi görüntülemeyen bir rvalue ise veya aralığı öğesine std::movegeçirmenin sonucu ise, bir owning_view.

Döndürülen görünümün türünü almak için kullanın std::views::all_t<decltype((rg))> .

Açıklamalar

Bu aralık bağdaştırıcısı, aralığı görünüme dönüştürmenin en iyi yoludur. Aralıktan görünüm oluşturmanın bir nedeni, aralığı değere göre geçirmenin pahalı olması durumunda bunu düşük maliyetle değere geçirmektir.

Görünümler oluşturma, kopyalama ve yok etme açısından uygun maliyetli olduğundan, bir aralığın görünümünü almak, ağır ağırlık aralığını değere göre geçirmenin kullanışlı bir alternatifidir. Olası bir özel durum, owning_viewtemel alınan aralığın sahibi olan bir görünümdür.

Genel olarak, bir görünümü yok etmek için en kötü senaryo, aralıktaki öğe sayısı için karmaşıklığa sahiptir O(N) . Görünüm kopyalarını öğelerle K yok N etseniz bile, toplam karmaşıklık yine de O(N) temel aralığın yalnızca bir kez yok edilmesidir.

Örnek: `all`

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

int main()
{
    std::vector<int> v = {1,2,3,4,5,6,7,8,9,10};
    auto myRefView = std::views::all(v); // create a ref_view of the vector
    std::cout << myRefView.size() << '\n'; // 10

    auto myOwningView = std::views::all(std::move(v)); // create an owning_view from a moved vector
    std::cout << myRefView.size() << '\n'; // outputs 0 because myOwningView now owns the elements
    std::cout << v.size() << '\n'; // outputs 0 because myOwningView now owns the elements
    std::cout << myOwningView.size(); // 10 
}

`common`

Aynı başlangıç yineleyicisi ve sentinel türü olmayan bir aralıktan bir görünüm oluşturun.

template <ranges::viewable_range R>
constexpr ranges::view auto common(R&& rg) const noexcept;

Parametreler

R
Temel alınan aralığın türü.

rg
Görünümün oluşturulacağı aralık.

Dönüş değeri

views::all(rg) aynı yineleyici ve sentinel türüne sahip bir aralıksa rg .
common_view(views::all(rg)) farklı yineleyici ve sentinel türleri varsa rg .

Açıklamalar

BIR API, başlangıç yineleyicisinin ve bitiş sentinelinin aynı türe sahip olmasını gerektirdiğinde ve kullandığınız görünüm bu gereksinimi karşılamadığında (veya karşılayıp karşılamadığını bilmiyorsanız), oluşturmak common_viewiçin bu aralık bağdaştırıcısını kullanın. Başlangıç yineleyicisinin türünün ve son sentinel türünün aynı olduğunu garanti eder.

Örnek: `common`

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

int main()
{
    std::list<int> lst{1, 2, 3, 4, 5, 6, 7, 8, 9};

    auto firstFive = std::views::take(lst, 5); 
    // firstFive.begin(), firstFive.end() have different types: counted_iterator versus default_sentinel
    // auto r = std::accumulate(firstFive.begin(), firstFive.end(), 0); // Error: accumulate() requires firstFive.begin() and firstFive.end() types to be the same.
    
    auto common = std::views::common(firstFive); // create a common_view that has the same begin/end iterator types
    std::cout << std::accumulate(common.begin(), common.end(), 0); // Now you can call the API because the iterator types are the same. Outputs 15 (1+2+3+4+5) 
}

`counted`

Belirtilen konumdan başlayarak bir aralığın ilk count öğelerinin görünümünü oluşturun.

template<class Iterator>
constexpr auto counted(Iterator&& it, iter_difference_t<Iterator> count);

Parametreler

DifferenceType
Sayının türü.

Iterator
Yineleyicinin türü.

count
Görünüme eklenecek öğe sayısı. Negatif olmamalıdır.

ise count == 0, boş span bir döndürülür.
Aralıktaki öğe sayısından büyükse count , davranış tanımlanmamıştır.

it
Başlangıç olarak aralıktaki öğeye yönelik bir yineleyici. Yineleyicinin işaret olduğu öğe, oluşturulan görünüme eklenir.

Dönüş değeri

A span , öğelerini bitişik olarak depolayan diziler, vektörler ve diğer kapsayıcılar için ise itcontiguous_iterator döndürülür. Aksi takdirde, bir subrange döndürülür.

Açıklamalar

Eklenen öğeler şunlardır: [it, count).

Görünüm oluşturulduktan sonra, görünümde oluşturulan aralık değişse bile görünümdeki öğelerin sayısı aynı kalır. Ancak, temel alınan aralık değişirse, görünümden öğelere erişmek tanımsız davranışa neden olabilir.

Örnek: `counted`

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

int main()
{
    std::vector<int> v{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    auto pos5 = std::ranges::find(v, 5);
    auto countedView = std::views::counted(pos5, 5);
    for (auto e : countedView) // outputs 5 6 7 8 9
    {
        std::cout << e << ' ';
    }
    std::cout << '\n';

    // You can pass the range directly if it supports input_or_output_iterator, in which case
    // the count starts from the first element
    const char chars[] = { 'H','i',' ','t','h','e','r','e' };
    for (char c : std::views::counted(chars, 2))
    {
        std::cout << c; // outputs Hi
    }
}

5 6 7 8 9
Hi

`drop`

Bir aralığın ilk n öğesini dışlayan bir görünüm oluşturun.

1) template<ranges::viewable_range R>
constexpr ranges::view auto drop(R&& rg, ranges::range_difference_t<R> count);

2) template<class DifferenceType>
constexpr /* range closure object */ drop(DifferenceType&& count);

Parametreler

DifferenceType
Atlana öğe sayısını açıklayan tür.

count
önünden rgbırakıla öğe sayısı. Negatif olmamalıdır.

ise count == 0içindeki tüm öğeler rg döndürülür.
içindeki öğe countsayısından büyükse rg boş bir görünüm döndürülür.

R
Aralığın türü.

rg
Görünümü oluşturmak için kullanılan aralık.

Dönüş değeri

Belirtilen sayıda öğe önden bırakılan temel aralığın görünümü.

Temel alınan aralıkta var olandan daha fazla öğe belirtirseniz, bir empty_view döndürülür.

Döndürülen görünüm genellikle, ancak her zaman değil, bir uzmanlığıdır drop_view. Bunun anlamı:

, veya Vuzmanlık alanı ise , empty_view, spanveya basic_string_view her ikisi iota_view de ve subrangeise, sonuç bir uzmanlığıdırrandom_access_range.sized_rangeV
Aksi takdirde, sonuç bir drop_viewşeklindedir.

Açıklamalar

Oluşturulduktan sonra, görünümdeki öğelerin sayısı değişiklikten oluşturulan görünümde bile aynı kalır. Ancak, temel alınan görünüm değişirse, döndürülen görünümdeki öğelere erişmek tanımsız davranışa neden olabilir.

drop , öğesinin tersidir take.

Daha önce "2)" olarak gösterilen kod, kanal söz dizimi ile kullanılabilir: collection | drop(5). Ya da işlev çağrısı söz dizimi ile kullanılabilir: drop(collection, 5) veya drop(5)(collection).

Örnek: `drop`

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

int main()
{
    std::vector<int> v{1, 2, 3, 4, 5};
    auto newView = std::views::drop(v, 3);
    for (auto e : newView) // 4 5
    {
        std::cout << e << ' ';
    }
    std::cout << '\n';

    auto numbers = std::views::iota(0) | std::views::take(10); // build a view of 10 integers
    auto latterHalf = numbers | std::views::drop(5);
    for (auto i : latterHalf)
    {
        std::cout << i << ' '; // 5 6 7 8 9
    }
}

4 5
5 6 7 8 9

`drop_while`

Belirtilen koşulla eşleşen önde gelen öğeler bırakıldıktan sonra kalan bir aralığın öğelerini içeren bir görünüm oluşturun.

1) template<ranges::viewable_range R, class P>
constexpr ranges::view auto drop_while(R&& rg, P&& predicate);

2) template<class P>
constexpr /*range adaptor closure*/ drop_while(P&& predicate);

Parametreler

R
Aralığın türü.

predicate
Aralıktan hangi önde gelen öğelerin bırakıldığını belirleyen koşullar.

rg
Görünümün oluşturulacağı temel aralık.

Dönüş değeri

drop_while_view Koşulla eşleşen önde gelen öğeler bırakıldığında kalan öğelerden oluşan bir.

Açıklamalar

Koşul döndürdüğü rganda öğesinden false öğeleri bırakır.

drop_while , öğesinin tersidir take_while.

Daha önce "2)" olarak gösterilen kod, kanal söz dizimi ile kullanılabilir: collection | drop_while(predicate). Ya da işlev çağrısı söz dizimi ile kullanılabilir: drop_while(collection, predicate) veya drop_while(predicate)(collection).

Örnek: `drop_while`

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

void print(auto&& v)
{
    for (auto&& x : v)
    {
        std::cout << x << ' ';
    }
    std::cout << '\n';
}

int main()
{
    std::vector<int> v{ 0, 1, 2, 3, -4, 5, 6 };
    auto myView = std::views::drop_while(
        v,
        [](int i) {return i >= 0; });
    print(myView); // -4 5 6

    auto myView2 = v | std::views::drop_while(
        [](int i) {return i < 5; });
    print(myView2); // 5 6
}

-4 5 6
5 6

`elements`

Bir elements_viewaralıktaki her tanımlama grubu benzeri değerde seçili dizinin bir görünümü olan bir oluşturun. Örneğin, bir değer aralığı std::tuple<string, int> göz önünde bulundurulduğunda, her bir tanımlama grubundaki elements_view tüm öğelerden bir string oluşturun.

template<ranges::viewable_range R, size_t N>
constexpr ranges::view auto elements<N>(R&& rg);

Parametreler

N
Görünüme eklenecek her tanımlama grubu benzeri değerden seçecek öğenin dizini.

R
Temel alınan aralığın türü.

rg
Görünümün oluşturulacağı demet benzeri değerler aralığı.

Dönüş değeri

Bir elements_view koleksiyondaki her tanımlama grubu benzeri değerde seçilen dizinden oluşan bir.

Örnek: `elements`

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

int main()
{
    std::map<std::string, int> cpp_standards
    {
        {"C++98", 1998},
        {"C++03", 2003},
        {"C++11", 2011},
        {"C++14", 2014},
        {"C++17", 2017},
        {"C++20", 2020}
    };

    // Create an elements_view of all the string elements from each tuple
    for (int const year : std::views::elements<1>(cpp_standards))
    {
        std::cout << year << ' '; // 2003 2011 2014 2017 1998 2020
    }
    std::cout << '\n';

    // Another way, using |: create an elements_view of all the int elements from each tuple
    for (auto&& name : cpp_standards | std::views::elements<0>)
    {
        std::cout << name << ' '; // C++03 C++11 C++14 C++17 C++98 c++20
    }
}

2003 2011 2014 2017 1998 2020
C++03 C++11 C++14 C++17 C++98 c++20

`empty`

Öğesi olmayan bir görünüm olan bir empty_viewoluşturun.

template<class T>
inline constexpr empty_view<T> empty{};

Parametreler

T
Görünümdeki öğelerin türü. Hiçbir öğe olmasa bile görünümün bir öğe türüne ihtiyacı vardır.

Dönüş değeri

Bir empty_view.

Açıklamalar

bir empty_view görünümü gerektiren ancak öğelerini işlemesi gerekmeyen kodu çağırırken yararlı olabilir.

Örnek: `empty`

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

int main()
{
    auto anEmptyView = std::views::empty<int>;
    bool isNotEmpty = (bool)anEmptyView;
    std::cout << boolalpha << isNotEmpty << "\n"; // false
}

false

`filter`

Belirtilen koşulla eşleşen bir aralığın öğelerini içeren bir görünüm oluşturun.

1) template<ranges::viewable_range R, class P>
    requires {filter_view(forward<R>(rg), forward<P>(predicate));}
constexpr ranges::view auto filter(R&& rg, P&& predicate);

2) template<class P>
constexpr /*range adaptor closure*/ filter(P&& predicate);

Parametreler

P
Koşulun türü.

predicate
Aralıkta tutulacak öğeleri belirleyen koşullar.

R
Temel alınan aralığın türü.

rg
Görünümün oluşturulacağı aralık.

Dönüş değeri

Koşulla filter_view eşleşen bir aralığın öğelerini içeren.

Açıklamalar

Verimlilik adına, ve bir boru filterile birlikte kullandığınızda transform|, yalnızca saklamak istediğiniz öğeleri sağlamak için ilkini filter yapıntransform.

Daha önce "2)" olarak gösterilen kod, kanal söz dizimi ile kullanılabilir: collection | filter(predicate). Ya da işlev çağrısı söz dizimi ile kullanılabilir: filter(collection, predicate) veya filter(predicate)(collection).

Örnek: `filter`

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

void print(auto&& v)
{
    for (auto&& x : v)
    {
        std::cout << x << ' ';
    }
    std::cout << '\n';
}

int main()
{
    std::vector<int> v{0, 1, 2, 3, -4, 5, 6};
    auto myView = std::views::filter(v, [](int i) {return i < 5; });
    print(myView); // 0 1 2 3 -4

    auto myView2 = v | std::views::filter([](int i) {return i < 5; }); // pipe syntax
    print(myView2); // 0 1 2 3 -4
}

0 1 2 3 -4
0 1 2 3 -4

`iota`

Artan değerler dizisi içeren bir görünüm oluşturun. Sıra sınırlanabilir veya sınırlanamaz.

template<class V>
constexpr ranges::view auto iota(V&& startValue); // create an unbounded sequence of incrementing values

template<class V, class E>
constexpr ranges::view auto iota(V&& startValue, E&& endValue); // create a bounded sequence of incrementing values

Parametreler

E
Bitiş değerinin türü.

S
Başlangıç değerinin türü.

startValue
Dizideki ilk değer.

endValue
Bu değer, dizideki son değeri geçmiştir. Örneğin, std::views::iota(0, 5) değerlerine 0,1,2,3,4sahip bir görünüm oluşturur.

Dönüş değeri

Artan iota_view değer dizilerinden biri.

Açıklamalar

İlişkisiz bir dizi için, veri türünün maksimum değerine ulaşıldıktan sonra davranış tanımlanmamış olur.

Örnek: `iota`

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

void print(auto&& v)
{
    for (auto&& x : v)
    {
        std::cout << x << ' ';
    }
    std::cout << '\n';
}

int main()
{
    // create an iota view with its range adaptor (preferred)
    print(std::views::iota(0, 5)); // outputs 0 1 2 3 4
    
    // create an iota_view class directly
    std::ranges::iota_view letters{'a', 'f'};
    print(letters); // a b c d e
}

0 1 2 3 4
a b c d e

`istream`

Akışın öğeleri üzerinde bir görünüm oluşturun.

template <class Val>
views::istream<Val>(str);

Parametreler

str
Akış nesnesi. Türü, bir uzmanlığından std::basic_istreamtüretilir.

Val
Akıştan ayıklanan öğelerin türü.

Dönüş değeri

Bir basic_istream_view.

Bu aralık bağdaştırıcısı, türü ranges::basic_istream_view<Val, typename U::char_type, typename U::traits_type>(str)olan U ile eşdeğerdirstr.

Örnek: `istream`

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

int main()
{
    std::istringstream doubles{"1.1 2.2 3.3 4.4 5.5"};
    for (const auto& elem : std::views::istream<double>(doubles))
    {
        std::cout << elem << ' '; // 1.1 2.2 3.3 4.4 5.5
    }
}

1.1 2.2 3.3 4.4 5.5

`join`

Birden çok aralığın tüm öğelerini tek bir görünümde birleştiren bir görünüm oluşturun.

1) template <ranges::viewable_range R>
[[nodiscard]] constexpr ranges::view auto join(R&& rg) const noexcept;

2) inline constexpr /*range adaptor closure*/ join();

Parametreler

R
Temel alınan aralığın türü.

rg
Görünümün oluşturulacağı aralık.

Dönüş değeri

join_view Temel alınan aralıktaki tüm aralıkların öğelerini içeren bir.

Örnek: `join`

#include <iostream>
#include <vector>
#include <ranges>
#include <string>

int main()
{
    // a range of two ranges
    std::vector<std::string> rangeOfRanges[2]{{"C++20", "contains:"}, {"ranges", "modules", "concepts & more."}};

    for (const auto& elem : std::views::join(rangeOfRanges))
    {
        std::cout << elem << ' ';
    }
}

C++20 contains: ranges modules concepts & more.

Açıklamalar

Daha önce "2)" olarak gösterilen kod, kanal söz dizimi ile kullanılabilir: collection | join. Veya işlev çağrısı söz dizimi ile kullanılabilir: join(collection).

`keys`

keys_view Bir koleksiyondaki her tanımlama grubu benzeri değerde ilk dizinden bir oluşturun. Bu, ilişkilendirici kapsayıcılardan anahtar ayıklamak için kullanışlıdır. Örneğin, bir aralığı std::tuple<string, int>göz önünde bulundurulduğunda, her bir tanımlama grubundaki string tüm öğelerden oluşan bir görünüm oluşturun.

template <ranges::viewable_range R>
constexpr auto keys(R&& rg);

Parametreler

R
Temel alınan aralığın türü.

Dönüş değeri

keys_view Aralıktaki her tanımlama grubu benzeri değerdeki ilk dizinden oluşan bir.

Örnek: `keys`

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

int main()
{
    // ========== extract keys from a map

    std::map<std::string, int> cpp_standards
    {
        {"C++98", 1998},
        {"C++03", 2003},
        {"C++11", 2011},
        {"C++14", 2014},
        {"C++17", 2017},
        {"C++20", 2020}
    };

    // Extract all of the keys from the map
    for (std::string standards : std::views::keys(cpp_standards))
    {
        std::cout << standards << ' '; // C++03 C++11 C++14 C++17 C++98 C++20
    }
    std::cout << '\n';

    // ========== Extract keys from a pair

    std::vector<std::pair<std::string, int>> windows
    {
        {"Windows 1.0", 1985},
        {"Windows 2.0", 1987},
        {"Windows 3.0", 1990},
        {"Windows 3.1", 1992},
        {"Windows NT 3.1", 1993},
        {"Windows 95", 1995},
        {"Windows NT 4.0", 1996},
        {"Windows 95", 1995},
        {"Windows 98", 1998},
        {"Windows 1.0", 1985},
        {"Windows 2000", 2000}
    };
    
    // Another way to call the range adaptor is by using '|'
    for (std::string version : windows | std::views::keys)
    {
        std::cout << version << ' '; // Windows 1.0 Windows 2.0 Windows 3.0 ...
    }
}

C++03 C++11 C++14 C++17 C++98 C++20
Windows 1.0 Windows 2.0 Windows 3.0 Windows 3.1 Windows NT 3.1 Windows 95 Windows NT 4.0 Windows 95 Windows 98 Windows 1.0 Windows 2000

`lazy_split`

Bir aralığı sınırlayıcıya göre alt aralıklara bölün. Sınırlayıcı tek bir öğe veya öğelerin görünümü olabilir.

1) template<viewable_range R, class Pattern>
constexpr view auto lazy_split(R&& rg, Pattern&& delimiter);

2) template<class Pattern>
constexpr /*range adaptor closure*/ lazy_split(Pattern&& delimiter);

Parametreler

delimiter
Tek bir değer veya aralığın nereye bölüneceğini belirten bir değer dizisi.

Pattern
Sınırlayıcının türü.

R
Bölünecek aralığın türü.

rg
Bölünecek aralık.

Dönüş değeri

Bir lazy_split_view veya daha fazla alt düzenleme içeren ve özgün aralığın üzerinde delimiterbölünmesinin sonucu olan.

Açıklamalar

Sınırlayıcı sonucun bir parçası değildir. Örneğin, değerinin aralığını 1,2,32bölerseniz iki alt alanınız olur: 1 ve 3.

İlgili bir bağdaştırıcıdır split. ile split_view arasındaki lazy_split_view birincil farklar şunlardır:

Görünüm	Aralığı `const` bölebilir	Aralık yineleyicisi
`split_view`	hayır	Destekler `forward_range` veya üzeri
`lazy_split_view`	evet	`input_range` veya üzeri

Daha verimli olduğundan, olan bir aralığı split_viewbölmeniz gerekmediği sürece tercih edebilirsinizconst.

Daha önce "2)" olarak gösterilen kod, kanal söz dizimi ile kullanılabilir: collection | lazy_split(delimiter). Ya da işlev çağrısı söz dizimi ile kullanılabilir: lazy_split(collection, delimiter) veya lazy_split(delimiter)(collection).

Örnek: `lazy_split`

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

int main()
{
    std::vector<int> rg{1, 2, 3, 1, 2, 3, 4, 5, 6};

    // split on a single element
    for (const auto& sub : rg | std::views::split(3))
    {
        // outputs:
        // 1 2
        // 1 2
        // 4 5 6
        for (const auto& elem : sub)
        {
            std::cout << elem << ' ';
        }
        std::cout << '\n';
    }

    // split on a sequence of elements
    int delimiters[] = {2, 3};
    for (const auto& subrange : std::views::split(rg, delimiters))
    {
        // outputs 1 1 4 5 6
        for (auto& i : subrange)
        {
            std::cout << i << " ";
        }
    }
}

`reverse`

Bir aralığın öğelerinin ters sırada bir görünümünü oluşturun.

1) template<viewable_range R>
constexpr ranges::view auto reverse(R&& rg);

2) inline constexpr /*range adaptor closure*/ reverse();

Parametreler

R
Ters çevrilecek temel aralığın türü.

rg
Geri çevrilecek aralık.

Dönüş değeri

Temel alınan aralığın öğelerini ters sırada sunan bir görünüm. Döndürülen görünüm genellikle, ancak her zaman değil, bir uzmanlığıdır reverse_view. Bunun anlamı:

bir uzmanlığı Visereverse_view, sonuç bağımsız değişkenin temel görünümüdür. Çift ters işlem yapılmaz (işlem yoktur).
biçimine Vsahipsesubrange<reverse_iterator<I>, reverse_iterator<I>>, sonuç, çizilmemiş yineleyicilerin bir subrange sonucudur. Çift ters, operasyon yapılmaz.
Aksi takdirde, sonuç bir reverse_viewşeklindedir.

Açıklamalar

Daha önce "2)" olarak gösterilen kod, kanal söz dizimi ile kullanılabilir: collection | reverse. Veya işlev çağrısı söz dizimi ile kullanılabilir: reverse(collection).

Örnek: `reverse`

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

int main()
{
    std::vector<int> v{ 0, 1, 2, 3, -4, 5, 6 };
    auto rv = v | std::views::reverse; // using the pipe syntax  

    for (auto &&e : rv) // outputs 6 5 -4 3 2 1 0
    {
        std::cout << e << ' ';
    }
    std::cout << '\n';

    // using the range adaptor without using the pipe syntax
    auto rv2 = std::views::reverse(v);
    for (auto &&e : rv2) // outputs 6 5 -4 3 2 1 0
    {
        std::cout << e << ' ';
    }
}

6 5 -4 3 2 1 0
6 5 -4 3 2 1 0

`single`

Bir single_viewöğe içeren bir görünüm olan bir oluşturun.

template<class T>
constexpr ranges::view auto single(T&& t);

Parametreler

T
Görünümdeki öğenin türü.

t
Görünümde depoacak öğenin değeri.

Dönüş değeri

single_view öğesini içeren tbir .

Açıklamalar

Bu görünüm, içinde en az bir öğe bulunan bir görünümle sağlanması gereken kodu çağırmak için test amacıyla kullanışlıdır.

Örnek: `single`

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

int main()
{
    auto sv = std::views::single(7);
    std::cout << sv.front() << " " << *sv.data() << "\n"; // 7 7
    
    auto sv2 = std::views::single(<std::tuple<double, std::string>{6502, "8-bit"});
    std::cout << std::get<0>(sv2[0]) << " " << std::get<1>(sv2[0]) << "\n"; // 6502 8-bit
}

7 7
6502 8-bit

`split`

Bir görünümü sınırlayıcıya göre alt bölümlere ayırın. Sınırlayıcı tek bir öğe veya öğe dizisi olabilir.

1) template<viewable_range R, class Pattern>
constexpr view auto split(R&& rg, Pattern&& delimiter);

2) template<class Pattern>
constexpr /*range adaptor closure*/ split(Pattern&& delimiter);

Parametreler

delimiter
Tek bir değer veya aralığın nereye bölüneceğini belirten bir değer dizisi.

Pattern
Sınırlayıcının türü.

R
Bölünecek temel aralığın türü.

rg
Bölünecek aralık.

Dönüş değeri

Bir split_view veya daha fazla alt düzenleme içeren bir.

Açıklamalar

Sınırlayıcı sonucun bir parçası değildir. Örneğin, değerinin aralığını 1,2,32bölerseniz iki alt alanınız olur: 1 ve 3.

İlgili bir bağdaştırıcıdır lazy_split. ile split_view arasındaki lazy_split_view birincil farklar şunlardır:

Görünüm	Aralığı `const` bölebilir	Aralık türü
`split_view`	hayır	Destekler `forward_range` veya üzeri
`lazy_split_view`	evet	Destekler `input_range` veya üzeri

Daha verimli olduğundan, olan bir aralığı split_viewbölmeniz gerekmediği sürece tercih edebilirsinizconst.

Daha önce "2)" olarak gösterilen kod, kanal söz dizimi ile kullanılabilir: collection | split(delimiter). Ya da işlev çağrısı söz dizimi ile kullanılabilir: split(collection, 5) veya split(5)(collection).

Örnek: `split`

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

int main()
{
    std::vector<int> rg{ 1, 2, 3, 1, 2, 3, 4, 5, 6 };

    // split on a single element, 3
    for (const auto& sub : rg | std::views::split(3))
    {
        // This prints out:
        // 1,2
        // 4,5,6
        for (const auto& elem : sub)
        {
            std::cout << elem << ' ';
        }
        std::cout << '\n';
    }

    // split on a sequence of elements, 2,3
    int delimiters[] = {2, 3};
    for (const auto& subrange : std::views::split(rg, delimiters))
    {
        // outputs 1 1 4 5 6
        for (auto& i : subrange)
        {
            std::cout << i << " ";
        }
    }
}

`take`

Bir aralığın önünden alınan belirtilen sayıda öğeyi içeren bir görünüm oluşturun.

1) template<ranges::viewable_range R>
constexpr ranges::view auto take(R&& rg, ranges::range_difference_type<R> count);

2) template<class DifferenceType>
constexpr /*range adaptor closure*/ take(DifferenceType&& count);

Parametreler

R
Temel alınan aralığın türü.

rg
Görünümün oluşturulacağı aralık.

count
önünden rgalınması gereken öğe sayısı.

Dönüş değeri

Döndürülen görünüm genellikle, ancak her zaman değil, bir uzmanlığıdır take_view. Özellikle:

, veya Vuzmanlık alanı ise , empty_view, spanveya basic_string_view her ikisi iota_view de ve subrangeise, sonuç bir uzmanlığıdırrandom_access_range.sized_rangeV
Aksi takdirde, sonuç bir take_viewşeklindedir.

Açıklamalar

Alınacak öğe sayısı içinde rgvar olandan daha fazla öğe belirtirseniz, tüm öğeler alınır.

take , öğesinin tersidir drop.

Daha önce "2)" olarak gösterilen kod, kanal söz dizimi ile kullanılabilir: collection | take(5). Ya da işlev çağrısı söz dizimi ile kullanılabilir: take(5, collection) veya take(5)(collection).

Örnek: `take`

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

int main()
{
    std::string s{ "abcdefg" };
    auto myView = std::views::take(s, 3);
    for (auto c : myView)
    {
        std::cout << c << ' '; // a b c
    }

    std::cout << std::endl;

    for (auto c : s | std::views::take(3)) // pipe syntax
    {
        std::cout << c << ' '; // a b c
    }
}

a b c
a b c

`take_while`

Belirtilen koşulla eşleşen bir aralığın önde gelen öğelerini içeren bir görünüm oluşturun.

1) template<ranges::viewable_range R, class P>
constexpr ranges::view auto take_while(R&& rg, P&& predicate);

2) template<class P>
constexpr /*range adaptor closure*/ take_while(P&& predicate);

Parametreler

P
Koşulun türü.

predicate
Aralıktan hangi önde gelen öğelerin kopyalandığını belirleyen koşullar.

R
Temel alınan aralığın türü.

rg
Görünümün oluşturulacağı aralık.

Dönüş değeri

take_while_view Aralıkta belirtilen ölçütleri karşılayan ilk count öğelerden oluşan bir.

Açıklamalar

Koşul döndürdüğünde rg veya aralıkta öğe false tükendikten sonra öğesi almayı durdurur.

take_while , öğesinin tersidir drop_while.

Daha önce "2)" olarak gösterilen kod, kanal söz dizimi ile kullanılabilir: collection | take_while(pred). Ya da işlev çağrısı söz dizimi ile kullanılabilir: take_while(collection, pred) veya take_while(pred)(collection).

Örnek: `take_while`

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

void print(auto&& v)
{
    for (auto&& x : v)
    {
        std::cout << x << ' ';
    }
    std::cout << '\n';
}

int main()
{
    std::vector<int> v{ 0, 1, 2, 3, -4, 5, 6 };
    auto myView = std::views::take_while(
        v, [](int i) {return i >= 0; });
    print(myView); // 0 1 2 3

    print(v | std::views::take_while( // 0 1 2 3 -4
        [](int i) {return i < 5; })); // pipe syntax
}

0 1 2 3
0 1 2 3 -4

`transform`

Her biri belirtilen aralıktaki bir öğenin dönüşümü olan öğelerin görünümünü oluşturun.

1) template<viewable_range R, class F>
constexpr ranges::view auto transform(R&& rg, F&& fun);

2) template<class F>
constexpr /*range adaptor closure*/ transform(F&& fun);

Parametreler

F
Öğeleri dönüştürmek için işlev nesnesinin türü.

R
Temel alınan aralığın türü.

fun
Öğeleri dönüştüren işlev.

rg
Görünümün oluşturulacağı aralık.

Dönüş değeri

öğesinin transform_view dönüştürülmüş öğelerini rgiçeren bir.

Açıklamalar

Verimlilik adına, ve oluştururken filter ilkini transform yapın; böylece filter yalnızca saklamak istediğiniz öğelere sahip olursunuz.transform

Daha önce "2)" olarak gösterilen kod, kanal söz dizimi ile kullanılabilir: collection | transform(fun). Ya da işlev çağrısı söz dizimi ile kullanılabilir: transform(collection, fun) veya transform(fun)(collection).

Örnek: `transform`

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

void print(auto&& v)
{
    for (auto&& x : v)
    {
        std::cout << x << ' ';
    }
    std::cout << '\n';
}

int main()
{
    std::vector<int> v{0, 1, 2, 3, -4, 5, 6};
    auto myView = std::views::transform(v, [](int i) {return i * 2; });
    print(myView); // 0 2 4 6 -8 10 12

    print(v | std::views::transform( // 0 2 4 6 -8 10 12
        [](int i) {return i * 2; })); // pipe syntax
}

0 2 4 6 -8 10 12
0 2 4 6 -8 10 12

`values`

values_view Bir koleksiyondaki her tanımlama grubu benzeri değerde ikinci dizinden oluşan bir oluşturun. Bu, ilişkilendirici bir kapsayıcıdaki değerlerin görünümünü oluşturmak için kullanışlıdır. Örneğin, bir değer aralığı std::tuple<string, int> göz önünde bulundurulduğunda, her bir tanımlama grubundaki int tüm öğelerden oluşan bir görünüm oluşturun.

template <ranges::viewable_range R>
constexpr ranges::view auto values(R&& rg);

Parametreler

R
Temel alınan aralığın türü.

rg
Tanımlama grubu benzeri değerlerin temel aralığı.

Dönüş değeri

values_view İkinci dizinden aralıktaki her tanımlama grubu benzeri değere yerleşik bir değer.

Örnek: `values`

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

int main()
{
    // ========== working with a map

    std::map<std::string, int> cpp_standards
    {
        {"C++98", 1998},
        {"C++03", 2003},
        {"C++11", 2011},
        {"C++14", 2014},
        {"C++17", 2017},
        {"C++20", 2020}
    };

    // Extract all of the years from the map
    for (int years : std::views::values(cpp_standards))
    {
        std::cout << years << ' '; // 2003 2011 2014 2017 1998 2020
    }
    std::cout << '\n';

    // ========== working with pairs

    std::vector<std::pair<std::string, int>> windows
    {
        {"Windows 1.0", 1985},
        {"Windows 2.0", 1987},
        {"Windows 3.0", 1990},
        {"Windows 3.1", 1992},
        {"Windows NT 3.1", 1993},
        {"Windows 95", 1995},
        {"Windows NT 4.0", 1996},
        {"Windows 95", 1995},
        {"Windows 98", 1998},
        {"Windows 1.0", 1985},
        {"Windows 2000", 2000}
    };

    // Another way to call the range adaptor by using '|'
    // Create a values_view that contains the year from each pair
    for (int years : windows | std::views::values)
    {
        std::cout << years << ' '; // 1985 1987 1990 1992 ...
    }
}

2003 2011 2014 2017 1998 2020
1985 1987 1990 1992 1993 1995 1996 1995 1998 1985 2000

Aralık bağdaştırıcı türü diğer adları

`all_t`

Döndüren görünümün all türünü sağlar.

template <ranges::viewable_range R>
using all_t = decltype(views::all(std::declval<R>()));

Parametreler

R
Temel alınan aralığın türü.

Dönüş değeri

Döndüren görünümün all türü: decltype(views::all(std::declval<R>())).

Örnek: `all_t`

#include <ranges>
#include <iostream>
#include <vector>

int main()
{
    std::vector<int> v = {1,2,3,4,5,6,7,8,9,10};
    auto myView = std::views::all(v);
    std::views::all_t<decltype((v))> &viewType = myView;
}

Ayrıca bkz.

<ranges>
<ranges> Kavram
Sınıfları görüntüleme

Geri Bildirim

Bu sayfayı yararlı buldunuz mu?

Last updated on 2025-11-07

Aracılığıyla paylaş

Aralık bağdaştırıcıları

all

Parametreler

Dönüş değeri

Açıklamalar

Örnek: all

common

Parametreler

Dönüş değeri

Açıklamalar

Örnek: common

counted

Parametreler

Dönüş değeri

Açıklamalar

Örnek: counted

drop

Parametreler

Dönüş değeri

Açıklamalar

Örnek: drop

drop_while

Parametreler

Dönüş değeri

Açıklamalar

Örnek: drop_while

elements

Parametreler

Dönüş değeri

Örnek: elements

empty

Parametreler

Dönüş değeri

Açıklamalar

Örnek: empty

filter

Parametreler

Dönüş değeri

Açıklamalar

Örnek: filter

iota

Parametreler

Dönüş değeri

Açıklamalar

Örnek: iota

istream

Parametreler

Dönüş değeri

Örnek: istream

join

Parametreler

Dönüş değeri

Örnek: join

Açıklamalar

keys

Parametreler

Dönüş değeri

Örnek: keys

lazy_split

Parametreler

Dönüş değeri

Açıklamalar

Örnek: lazy_split

reverse

Parametreler

Dönüş değeri

Açıklamalar

Örnek: reverse

single

Parametreler

Dönüş değeri

Açıklamalar

Örnek: single

split

Parametreler

Dönüş değeri

Açıklamalar

Örnek: split

take

`all`

Örnek: `all`

`common`

Örnek: `common`

`counted`

Örnek: `counted`

`drop`

Örnek: `drop`

`drop_while`

Örnek: `drop_while`

`elements`

Örnek: `elements`

`empty`

Örnek: `empty`

`filter`

Örnek: `filter`

`iota`

Örnek: `iota`

`istream`

Örnek: `istream`

`join`

Örnek: `join`

`keys`

Örnek: `keys`

`lazy_split`

Örnek: `lazy_split`

`reverse`

Örnek: `reverse`

`single`

Örnek: `single`

`split`

Örnek: `split`

`take`

Örnek: `take`

`take_while`

Örnek: `take_while`

`transform`

Örnek: `transform`

`values`

Örnek: `values`

`all_t`

Örnek: `all_t`