<ranges> diğer ad şablonları

Diğer ad şablonu, kodu daha okunabilir hale getirebilen başka bir tür için bir diğer addır. Örneğin, aşağıdaki diğer ad, conditional_tgeçirilen türüne range bağlı olarak veya dangling aralığı için borrowed_range bir diğer addır:

// requires /std:c++20, or later

#include <iostream>
#include <list>
#include <span>
#include <algorithm>
#include <ranges>
#include <type_traits>

using namespace std;

// Define an alias template called my_iterator_t
// If the provided range R is a borrowed_range, then the 
// returned type is iterator_t<R>; otherwise, ranges::dangling
template<ranges::range R>
using my_iterator_t = conditional_t<
    ranges::borrowed_range<R>,
    ranges::iterator_t<R>, ranges::dangling>;

int main()
{
    my_iterator_t<list<int>> aDanglingRange; // list<> isn't a borrowed_range
    constexpr bool same = same_as<
        decltype(aDanglingRange),
        ranges::dangling>; // true

    my_iterator_t<span<int, 5>> anIterator_t; // span<> is a borrowed_range
    constexpr bool same2 = same_as<
        decltype(anIterator_t),
        ranges::iterator_t<span<int, 5>>>; // true

    cout << boolalpha << same << "," << same2; // outputs true, true
}

Diğer ad şablonları hakkında daha fazla bilgi için bkz . Diğer adlar ve tür tanımları.

Üst bilgi, <algorithm> bir rangeiçin yineleyici ve sentinel türlerini belirleyen aşağıdaki diğer ad şablonlarını tanımlar:

Diğer ad şablonu	Açıklama
borrowed_iterator_tC++20	için range döndürülen yineleyicinin ömrü sona eren bir aralığa başvurup göndermediğini belirleyin.
borrowed_subrange_tC++20	için döndürülen değerinin subrange range , ömrü sona eren bir aralığa başvurup başvurmadığını belirleyin.
danglingC++20	Döndürülen yineleyicinin başvurduğu yaşam süresinden/subrange rangedaha uzun olduğunu gösterir.range/subrange
iterator_tC++20	Belirtilen aralık için yineleyici türünü döndürür.
range_difference_tC++20	Belirtilen aralığın yineleyicisi için fark türünü döndürür.
range_reference_tC++20	Belirtilen aralığın yineleyicisi için başvuru türünü döndürür.
range_rvalue_reference_tC++20	Belirtilen aralığın yineleyicisi için rvalue başvuru türünü döndürür. Başka bir deyişle, aralığın öğelerinin rvalue başvuru türü.
range_size_tC++20	Belirtilen aralığın sizeraporlamak için kullanılan türünü döndürür.
range_value_tC++20	Belirtilen aralığın yineleyicisinin değer türünü döndürür. Veya başka bir deyişle, aralıktaki öğelerin türü.
sentinel_tC++20	Belirtilen aralık için sentinel türünü döndürür.

borrowed_iterator_t

Yineleyici döndüren bir algoritma işlevi rvalue range bağımsız değişkeniyle çağrıldığında, aralığın ömrü çağrının ardından sona erebilir. Bu, döndürülen yineleyicinin yaşam süresi sona eren öğelere başvurabileceği anlamına gelir. Sallanan bir yineleyici kullanmak tanımsız davranışla sonuçlanır.

Bu şablon diğer adı, verilen aralık bağımsız değişkeni için durumun bu olduğunu belirtmek veya modellere borrowed_range başvurduğu aralık veya std::ranges::iterator_t<R> aralık bir lvalue olarak geçirildiğinden döndürülen yineleyiciyi kullanmanın güvenli olduğunu belirtmek için döndürürranges::dangling.

template<ranges::range R>
using borrowed_iterator_t = conditional_t<ranges::borrowed_range<R>,
    ranges::iterator_t<R>, ranges::dangling>;

Parametreler

R
Test için aralık.

Açıklamalar

Bir rvalue aralığının ömrü, aralık modellerine borrowed_range bakılmaksızın bir işlev çağrısının ardından sona erebilir. Bu bir borrowed_rangeise, aralığın ömrü sona erdiğinde bağımsız olarak iyi tanımlanmış davranışlarla yineleyicileri kullanmaya devam edebilirsiniz.

Bunun doğru olmadığı durumlar, örneğin veya list gibi vector kapsayıcılar için geçerlidir çünkü kapsayıcının ömrü sona erdiğinde yineleyiciler yok edilmiş öğelere başvurur.

Yineleyicileri, örneğin yineleyicileri isteğe bağlı olarak oluşturulduğu için borrowed_rangeyok edilmeye tabi olmayan değerler kümesi üzerinde olan değerler view iota_view<int>{0, 42} gibi bir için kullanmaya devam edebilirsiniz.

Bir algoritma işlevine yineleyicileri yaşam süresine bağlı olan bir aralık geçirilirse, ranges::dangling yineleyici veya alt düzenleme yerine döndürülür, bu nedenle derleme zamanında olası kötüye kullanım algılanır.

Örnek: borrowed_iterator_t

Aşağıdaki örnekte, sarkan bir yineleyicinin nasıl borrowed_iterator_t algılanıyor olduğu gösterilmektedir. İşlev ranges::max_element() , dönüş türünü belirlemek için bu şablon diğer adını kullanır:

// requires /std:c++20, or later

#include <vector>
#include <span>
#include <ranges>
#include <iostream>
#include <algorithm>

using namespace std;

int main()
{
    // Not dangling ------------------

    int a[] = {0,1,2,3};

    // not dangling even though an rvalue because span models ranges::borrowed
    auto result1 = ranges::max_element(span{a});
    cout << boolalpha << ranges::borrowed_range<decltype(span{a})> << endl; // outputs true because the temporary models ranges::borrowed
    cout << same_as<decltype(result1), ranges::dangling> << endl; // outputs false because the result isn't dangling

    vector<int> v{0,1,2,3}; // doesn't model ranges::borrowed
    auto result2 = ranges::max_element(v); // Yet not dangling because passed as an lvalue
    cout << same_as<decltype(result2), ranges::dangling> << endl; // outputs false because the result isn't dangling
    
    // Dangling ------------------

    auto result3 = ranges::max_element(vector{0,1,2,3}); // dangling because vector doesn't model ranges::borrowed and is passed as an rvalue
    cout << same_as<decltype(result3), ranges::dangling>; // outputs true because the result is dangling
}

true
false
false
true

borrowed_subrange_t

döndüren subrange bir algoritma işlevi rvalue range bağımsız değişkeniyle çağrıldığında, aralığın ömrü çağrının ardından sona erebilir. Bu, döndürülenin subrange yaşam süresi sona eren öğelere başvurabileceği anlamına gelir. Sallanan bir kullanım subrange tanımsız davranışla sonuçlanır.

Bu şablon diğer adı, bunun verilen aralık bağımsız değişkeninin durumu olabileceğini belirtmek veya öğeleri modellere borrowed_range başvuran aralık veya subrange<ranges::iterator_t<R>> aralık bir lvalue olarak geçirildiği için döndürülen alt alanı kullanmanın güvenli olduğunu belirtmek için döndürürranges::dangling.

template<ranges::range R>
using borrowed_subrange_t = conditional_t<ranges::borrowed_range<R>,
    ranges::subrange<ranges::iterator_t<R>>, ranges::dangling>;

Parametreler

R
Test için aralık.

Açıklamalar

Bir rvalue aralığının ömrü, aralık modellerine borrowed_range bakılmaksızın bir işlev çağrısının ardından sona erebilir. Bu bir borrowed_rangeise, aralığın ömrü sona erdiğinde bağımsız olarak iyi tanımlanmış davranışlarla yineleyicileri kullanmaya devam edebilirsiniz.

Bunun doğru olmadığı durumlar, örneğin veya list gibi vector kapsayıcılar için geçerlidir çünkü kapsayıcının ömrü sona erdiğinde yineleyiciler yok edilmiş öğelere başvurur.

Yineleyicileri, örneğin yineleyicileri isteğe bağlı olarak oluşturulduğu için borrowed_rangeyok edilmeye tabi olmayan değerler kümesi üzerinde olan değerler view iota_view<int>{0, 42} gibi bir için kullanmaya devam edebilirsiniz.

Bir algoritma işlevine yineleyicileri yaşam süresine bağlı olan bir aralık geçirilirse, ranges::dangling derleme zamanında olası kötüye kullanım algılanabilmesi için bir alt ayar yerine döndürülür.

Örnek: borrowed_subrange_t

Aşağıdaki örnekte, dönüş türünü belirlemek için bu şablon diğer adı kullanıldığı için equal_range() max_element sarkan bir yineleyicinin nasıl borrowed_subrange_t algıladığı gösterilmektedir:

// requires /std:c++20, or later

#include <vector>
#include <iostream>
#include <algorithm>
#include <span>
#include <ranges>

int main()
{
    using namespace std;

    // Not dangling ------------------

    vector vec{0, 1, 1, 2};

    auto result1 = ranges::equal_range(span{vec}, 1); // not dangling even though passing as an rvalue because span models borrowed_range
    cout << boolalpha << ranges::borrowed_range<decltype(span{vec})> << endl;  // true because the temporary is a borrowed range
    cout << boolalpha << same_as<decltype(result1), ranges::dangling> << endl; // false because the result isn't dangling

    // result2 isn't dangling even though vec doesn't model ranges::borrowed because it's an lvalue
    auto result2 = ranges::max_element(vec);
    cout << boolalpha << ranges::borrowed_range<decltype(vec)> << endl;  // false because vector isn't a borrowed_range
    cout << boolalpha << same_as<decltype(result2), ranges::dangling> << endl; // false because the result isn't dangling

    // Dangling -----------------------

    // result3 is dangling because the temporary is an rvalue that doesn't model borrowed_range
    auto result3 = ranges::max_element(vector{0,1,1,2});
    cout << boolalpha << same_as<decltype(result3), ranges::dangling> << endl; // true because the result is dangling
}

true
false
false
false
true

dangling

Yineleyici veya subrange bir döndüren bir algoritma işlevi rvalue range bağımsız değişkeniyle çağrılırsa, aralık bağımsız değişkeninin ömrü çağrının ardından sona erebilir. Bu, döndürülen yineleyicinin veya subrange yaşam süresi sona eren öğelere başvurabileceği anlamına gelir. Sallanan bir yineleyici kullanmak veya subrange tanımsız davranışla sonuçlanır.

Algoritma işlevine yineleyicileri yaşam süresine bağlı olan bir aralık geçirilirse, ranges::dangling derleme zamanında olası kötüye kullanım algılanabilmesi için yineleyici veya alt düzenleme yerine döndürülür.

1) constexpr dangling() noexcept = default;
2) template<class... Args>
constexpr dangling(Args&&...) noexcept {}

Parametreler

Args
Tür olmayanvoid değişken sayısı. Hiçbir etkisi yok. Bağımsız değişkenler kolaylık sağlar, böylece yineleyici türünü ve türünü dangling oluşturmak için farklı kod yollarına ihtiyacınız yoktur. Geçirilen değer yineleyici yerine döndürülmesi gerektiğini gösterdiğinde dangling bu yararlı olur.

Örnek: dangling

Aşağıdaki örnekte, sarkan bir yineleyicinin nasıl max_element algılanıyor olduğu gösterilmektedir.

// requires /std:c++20, or later

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

using namespace std;

int main()
{
    auto result1 = ranges::max_element(vector{1,2,3}); // dangling because vector doesn't model ranges::borrowed and is passed as an rvalue
    cout << boolalpha << same_as<decltype(result1), ranges::dangling> << endl; // outputs true because the result is dangling

    vector<int> v{3,4,5};
    auto result2 = ranges::max_element(v); // Not dangling because passed as an lvalue
    cout << same_as<decltype(result2), ranges::dangling>; // outputs false because the result isn't dangling
}

true
false

iterator_t

Bu şablon diğer adı, sağlanan aralık türü üzerinde yinelemek için kullanılan yineleyici türünü döndürür.

template<class T>
using iterator_t = decltype(ranges::begin(declval<T&>()));

Parametreler

T
Yineleyici türünü almak için aralık türü.

Örnek: iterator_t

Aşağıdaki örnek, bir vektör için yineleyici bildirmek için nasıl iterator_t kullanılabileceğini gösterir:

// requires /std:c++20, or later

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

int main()
{
    using namespace std;

    vector<int> v{1,2,3};

    ranges::iterator_t<decltype(v)> it = v.begin();
    cout << *it << "\n"; // outputs 1
    cout << typeid(it).name(); // outputs class _Vector_iterator<class _Vector_val<struct _Simple_types<int>>>
}

1
class std::_Vector_iterator<class std::_Vector_val<struct std::_Simple_types<int> > >

range_difference_t

Belirtilen aralığın yineleyicisi için fark türünü döndürür.

template<range R>
using range_difference_t = iter_difference_t<iterator_t<R>>;

Parametreler

R
Yineleyicisi fark türünü sağlayacak aralık.

Örnek: range_difference_t

Aşağıdaki örnek, bir aralıktaki öğeler arasındaki uzaklığı tutmak için nasıl range_difference_t kullanıldığını gösterir:

// requires /std:c++20, or later

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

int main()
{
    using namespace std;

    vector<int> v{1,2,3};

    auto findIt = ranges::find(v, 2);
    // type of distance is ptrdiff_t
    ranges::range_difference_t<decltype(v)> distance = ranges::distance(v.begin(), findIt);
    cout << distance << endl; // outputs 1
}

1

range_reference_t

Belirtilen aralığın yineleyicisi için başvuru türünü döndürür. Başka bir deyişle, aralığın öğelerinin başvuru türü.

template <range R>
using range_reference_t = iter_reference_t<ranges::iterator_t<R>>;

Parametreler

R
Yineleyici türünün başvuru türünün döndürüldiği aralık.

Örnek: range_reference_t

Aşağıdaki örnek, range_reference_t bir aralıktaki öğelerin türüne başvuruda bulunur:

// requires /std:c++20, or later

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

int main()
{
    using namespace std;

    vector<int> v{1,2,3};

    ranges::range_reference_t<decltype(v)> ref = v[0];

    cout << ref << endl; // outputs 1
    cout << typeid(ref).name() << endl; // outputs int
}

1
int

range_rvalue_reference_t

Belirtilen aralığın yineleyicisi için rvalue başvuru türünü döndürür. Başka bir deyişle, aralığın öğelerinin rvalue başvuru türü.

template <range R>
using range_rvalue_reference_t = iter_reference_t<ranges::iterator_t<R>>;

Parametreler

R
Rvalue başvuru türünü yineleyici türüne alacak aralık.

Örnek: range_rvalue_reference_t

Aşağıdaki örnekte, bir aralıktaki öğelerin rvalue türüne başvuru gösterilmektedir range_rvalue_reference_t :

// requires /std:c++20, or later

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

int main()
{
    using namespace std;

    vector<int> v{1,2,3};

    ranges::range_rvalue_reference_t<decltype(v)> elementRvalueType = v[0] * 10; // elementRvalueType is int&& 

    cout << elementRvalueType << endl; // outputs 10
    cout << typeid(elementRvalueType).name() << endl; // outputs int
}

10
int

range_size_t

Belirtilen sized_rangeiçin işlevin size türünü döndürür.

template <range R>
using range_size_t = iter_reference_t<ranges::iterator_t<R>>;

Parametreler

R
İşlevinin size türünü alacak aralık.

Örnek: range_size_t

Aşağıdaki örnekte, bir aralıktaki öğelerin sayısına başvurma gösterilmektedir range_size_t :

// requires /std:c++20, or later

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

int main()
{
    using namespace std;

    vector<int> v{1,2,3};

    ranges::range_size_t<decltype(v)> size = v.size();
    cout << size << endl; // outputs 3
    cout << typeid(size).name(); // outputs unsigned __int64
}

3
unsigned __int64

range_value_t

Belirtilen aralığın yineleyicisinin değer türünü döndürür. Veya başka bir deyişle, aralıktaki öğelerin türü.

template <ranges::range R>
using range_value_t = iter_value_t<ranges::iterator_t<R>>;

Parametreler

R
Yineleyicisinin değer türünü alacak aralık.

Örnek: range_value_t

Aşağıdaki örnekte, bir aralıktaki öğelerin türüne nasıl range_value_t başvurduğu gösterilmektedir:

// requires /std:c++20, or later

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

int main()
{
    using namespace std;

    vector<int> v{1,2,3};
    ranges::range_value_t<decltype(v)> elementType = v[2]; // elementType is an int 

    cout << elementType << endl; // outputs 3
    cout << typeid(elementType).name() << endl; // outputs int
}

3
unsigned int

sentinel_t

Belirtilen aralık için sentinel türünü döndürür.

template <range R>
using sentinel_t = decltype(ranges::end(declval<R&>()));

Parametreler

R
Sentinel türünü almak için aralık.

Örnek: sentinel_t

Aşağıdaki örnekte, yineleyici türü ile sentinel türünün aynı olup olmadığını belirlemek için kullanma sentinel_t gösterilmektedir:

// requires /std:c++20, or later

#include <iostream>
#include <list>
#include <ranges>

int main()
{
    using namespace std;

    list myList{1, 2, 3};
    ranges::subrange count = std::views::counted(myList.begin(), myList.size());

    ranges::iterator_t<decltype(count)> first;
    ranges::sentinel_t<decltype(count)> last;

    // The iterator type and the sentinel type of a subrange
    // obtained from views::counted are not the same
    cout << boolalpha << is_same<decltype(first), decltype(last)>::value << endl; // outputs false
    cout << "iter: " << typeid(first).name() << "\n\n end: " << typeid(last).name() << endl;
}

false
iter: class std::counted_iterator<class std::_List_iterator<class std::_List_val<struct std::_List_simple_types<int> > > >

 end: struct std::default_sentinel_t

Ayrıca bkz.

<ranges>
Aralık bağdaştırıcıları
Sınıfları görüntüleme