New Type Functions/Utilities for Dealing with Ranges in C++20

ChebyshevTST發表於2023-12-02

Generic Types of Ranges

  型別萃取從字面意思上來說其實就是幫助我們挑選某個物件的型別,篩選特定的物件來做特定的事。可以先來回顧一下以前的寫法。

#include <vector>
#include <iterator>

int main() {
    std::vector v{1, 2, 3};
    using iterator_type = std::vector<int>::iterator;

    using difference_type = std::iterator_traits<iterator_type>::difference_type;
    using iterator_catogory = std::iterator_traits<iterator_type>::iterator_category;
    using pointer = std::iterator_traits<iterator_type>::pointer;
    using reference = std::iterator_traits<iterator_type>::reference;
    using value_type = std::iterator_traits<iterator_type>::value_type;
}

  到了C++20,我們有了ranges,我們有了更多強大的工具,可以說它們是處理ranges的強大工具,我們來看看具體的內容。

  透過上圖,很多內容都直觀明瞭,為了避免晦澀難懂的抽象話術,我們透過程式碼來看看具體用法。

#include <vector>
#include <ranges>
#include <algorithm>
#include <iterator>
#include <type_traits>


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

    static_assert(std::is_same_v<std::ranges::iterator_t<decltype(v)>::difference_type,
                  std::iterator_traits<decltype(v)::iterator>::difference_type>); // OK
    static_assert(std::is_same_v<std::ranges::iterator_t<decltype(v)>::pointer,
                  std::iterator_traits<decltype(v)::iterator>::pointer>); // OK
    static_assert(std::is_same_v<std::ranges::iterator_t<decltype(v)>::reference,
                  std::iterator_traits<decltype(v)::iterator>::reference>); // OK
    static_assert(std::is_same_v<std::ranges::iterator_t<decltype(v)>::value_type,
                  std::iterator_traits<decltype(v)::iterator>::value_type>); // OK
    static_assert(std::is_same_v<std::ranges::iterator_t<decltype(v)>::iterator_category,
                  std::iterator_traits<decltype(v)::iterator>::iterator_category>); // OK
    // 可以明顯看到,比起傳統的迭代器萃取,C++20的處理方式更加簡潔,只用傳入ranges型別,而不用傳入迭代器型別,或許這就是ranges的魅力所在。
    
    static_assert(std::is_same_v<std::ranges::sentinel_t<decltype(v)>, 
                  decltype(end(v))>); // OK
    // 獲取哨兵型別。

    static_assert(std::is_same_v<std::ranges::range_reference_t<decltype(v)>,
                  decltype(v[0])>); // OK, both are int&
    static_assert(std::is_same_v<std::ranges::range_reference_t<decltype(v)>,
                  std::remove_reference_t<decltype(v[0])>>); // Error, int& and int

    static_assert(std::is_same_v<std::ranges::range_value_t<decltype(v)>,
                  std::remove_reference_t<decltype(v[0])>>); // OK, both are int
    static_assert(std::is_same_v<std::ranges::range_value_t<decltype(v)>,
                  decltype(v[0])>); // Error, int and int&

    static_assert(std::is_same_v<std::ranges::range_size_t<decltype(v)>,
                  std::size_t>); // OK

    static_assert(std::is_same_v<std::ranges::range_difference_t<decltype(v)>,
                  std::ptrdiff_t>); // OK

    static_assert(std::is_same_v<std::ranges::range_rvalue_reference_t<decltype(v)>,
                  decltype(std::move(v[0]))>); // OK

    static_assert(std::is_same_v<std::ranges::borrowed_iterator_t<decltype(v)>,
                  std::ranges::dangling>); // OK
    static_assert(std::is_same_v<std::ranges::borrowed_subrange_t<decltype(v)>,
                  std::ranges::dangling>); // OK
}

 

Generic Types of Iterators

  回到迭代器這一話題,為了更好的支援新的迭代器型別特徵,你應該用如下的方式來代替傳統的型別萃取。

#include <vector>
#include <ranges>
#include <type_traits>
#include <iterator>

int main() {
    std::vector v{1, 2, 3};
    using iterator_type = std::vector<int>::iterator;

    static_assert(std::is_same_v<std::iter_value_t<std::ranges::iterator_t<decltype(v)>>, int>);
    static_assert(std::is_same_v<std::iter_reference_t<std::ranges::iterator_t<decltype(v)>>, int&>);
    static_assert(std::is_same_v<std::iter_rvalue_reference_t<std::ranges::iterator_t<decltype(v)>>, int&&>);
    static_assert(std::is_same_v<std::iter_difference_t<std::ranges::iterator_t<decltype(v)>>, std::ptrdiff_t>);

    using type1 = std::common_reference_t<int, int>; // int
    using type2 = std::common_reference_t<int&, int>; // int
    using type3 = std::common_reference_t<int&, int&>; // int&
    using type4 = std::common_reference_t<int&, int&&>; // const int&
    using type5 = std::common_reference_t<int&&, int&&>; // int&&
}

  common_reference_t過於複雜,暫且先跳過。可以看到,這也是萃取型別的一種方式,只不過寫法不同罷了。話說回來,std::ranges::range_value_t<Rg>其實就是std::iter_value_t<std::ranges::iterator_t<Rg>>的簡化。

 

New Functional Types

  std::identity是一個函式物件,返回物件本身,可以搭配ranges的演算法一起使用。

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

int main() {
    std::vector v{1, 2, 3};
    auto pos = std::ranges::find(v, 9, [](auto x) { return x * x; });
    if (pos != end(v))
        std::cout << "Exist\n";

    auto pos2 = std::ranges::find(v, 3, std::identity{});
    if (pos2 != end(v))  
        std::cout << "Exist\n";
    
    auto pos3 = std::ranges::find(v, 3);
    if (pos3 != end(v))
        std::cout << "Exist\n";
}

  pos處傳入一個lambda表示式,對容器當中的每一個元素進行平方,然後返回對應的迭代器。pos2處傳入的正是std::identity,即物件自身,相當於不對原容器進行任何的具體操作,它跟pos3本質上是相同的。

  std::compare_three_way也是一個函式物件,它與<=>這個運算子有關聯。這個運算子有個有意思的名字,叫宇宙飛船運算子,因為它的形狀長得像宇宙飛船。這是C++20比較有意思的一個特性。

#include <iostream>
#include <type_traits>
#include <functional>


int main() {
    int a{3}, b{4};
    auto result = (a <=> b);

    if (result < 0)
        std::cout << "a < b\n";
    else if (result == 0)
        std::cout << "a == b\n";
    else 
        std::cout << "a > b\n";
}

Other New Types for Dealing with Iterators

  C++20,還有更多的值得探索......