标签: std-ranges

对于以下代码：

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

int main() 
{
    std::string s = " text ";
    auto sv = std::ranges::views::split(s, ' ');                    
    std::cout << std::ranges::distance(sv.begin(), sv.end());
}

输出为 2。输出范围中不存在最后一个分隔符之后的空子范围。

这似乎不一致，因为N+1如果N输入范围中出现分隔符，我希望输出范围中有子范围。为什么不是这样？

请注意 range-v3 做的完全一样，所以我确定这是故意的，但我想知道为什么。

我想<<为任何人写一个泛型，range最后我得到了这个：

std::ostream& operator << (std::ostream& out, std::ranges::range auto&& range) {
    using namespace std::ranges;

    if (empty(range)) {
        return out << "[]";
    }

    auto current = begin(range);
    out << '[' << *current;

    while(++current != end(range)) {
        out << ',' << *current;
    }

    return out << ']';
}

像这样测试：

int main() {
    std::vector<int> ints = {1, 2, 3, 4};
    std::cout << ints << '\n';
}

它完美运行并输出：

[1,2,3,4]

Run Code Online (Sandbox Code Playgroud)

但是，当测试时：

int main() {
    std::vector<int> empty = {};
    std::cout << empty …

我开始尝试std::ranges并想了解视图是如何真正起作用的。所以我尝试编写自己的容器和迭代器类型，并希望在视图中使用它。

但是似乎缺少一些东西，但编译器只告诉我begin()视图中没有方法，但没有告诉我为什么。

例子：

#include <iostream>
#include <array>
#include <ranges>

class MyFixedContainer;
class MyIterator
{
    MyFixedContainer* ptr;
    unsigned int offset;
public:
    MyIterator( MyFixedContainer* ptr_, unsigned int offset_ ): ptr{ ptr_},offset{offset_}{}

    bool operator==( MyIterator& other ) const
    {   
        return ( ptr == other.ptr )&& ( offset == other.offset );
    }   

    bool operator!=( MyIterator& other ) const
    {   
        return !(*this == other);
    }   

    MyIterator operator++()
    {   
        offset++;
        return *this;
    }   

    MyIterator operator++(int)
    {   
        MyIterator tmp = *this;
        offset++;
        return …

使用范围允许我减少样板文件，所以这很好，但我找不到按升序或降序排序的方法。以下代码段编译得很好（g++ 10.2.0）并且投影确实简化了代码，不需要 lambda。

  struct Player {
    double score_;
    string name_;
  };

  vector<Player> players{
    {10.0, "Thorin"}, {20.0, "Bombur"}, {15.0, "Bofur"}, {5.0, "Bifur"},
    { 2.0, "Balin"},  {25.0, "Kili"  }, {23.0, "Fili"},  {4.0, "Dwalin"}
  };

  std::ranges::sort(players, std::ranges::less{}, &Player::score_ );

  for(auto const &player : players) {
    cout <<  "Name = " << std::left << setw(10) << player.name_ 
         << " Score = " << player.score_ << endl;
  }

现在我需要一个布尔控制升序或降序排序。

我想写一个这样的简单语句：

 std::ranges::sort(players, sort_ascending ? std::ranges::less() : std::ranges::greater() , &Player::score_);

但是std::ranges::less和std::ranges::greater没有相同的类型，所以三元运算符将不起作用。

error: operands …

In [range.sized#1]:

The sized_­range concept refines range with the requirement that the number of elements in the range can be determined in amortized constant time using ranges?::?size.

template<class T>   
  concept sized_­range =
  range<T> &&
    requires(T& t) { ranges::size(t); };

Run Code Online (Sandbox Code Playgroud)

The standard states that obtaining the size of ranges::sized_range is guaranteed to be in constant time. Consider the following:

auto r1 = std::views::iota(0)
    | std::views::filter([](int x){ return x % 2 == 0; })
    | std::views::take(1'000'000);

r1 is obviously …

我正在使用带有 GCC 实现（v10.2 和 v11）的 C++20 范围。

为了测试行为的std::views::join，我试图生成使用嵌套视图single，然后我平坦它使用join。

#include <ranges>
#include <iostream>

int main() {
  auto data = std::views::single(1);
  auto v =
      data
      | std::views::transform([](const auto &s) { return std::views::single(s); })
      | std::views::join
      ;

  for (auto &&x : v) { // Infinite loop + segfault
    std::cout << x << '\n';
  }
}

[在编译器资源管理器中]

我希望找到for 的一个迭代器具有初始值 (1)循环。但是不......它进入了一个无限循环，因为我使用了这个值，所以出现了段错误。