void foo(const auto& collection) { *collection.begin() = 104; } int main() { std::vector<int> ints {1, 2, 3, 4, 5}; foo(ints); // Error, as it should be foo(ints | std::views::all); // Compiles and modifies the vector. Why? return 0; } Why is constness of lvalue reference completely ignored if an argument of a function is of… Read More Is const broken with std::views?
Goal is to minimize a function over a range of input values. Performance matters. Unfortunately, the ranges::min() algorithm recomputes the output for the live optimum over and over again. It seems like the algorithm could cache the output value corresponding to the optimum, or am I missing something ? In this example, why does f(x=0)… Read More can ranges min recalculations be avoided
Is there any standard functionality to create a range/view over all pairs? The following code illustrates the view I am looking to create: std::unordered_map<std::string, std::vector<int>> m{{"Foo", {1,2}}, {"Hello", {4,5}}}; auto view = ???; std::vector<std::pair<std::string, int>> v{view.begin(), view.end()}; std::vector<std::pair<std::string, int>> out1{{"Foo", 1}, {"Foo", 2}, {"Hello", 4}, {"Hello", 5}}; std::vector<std::pair<std::string, int>> out2{{"Hello", 4}, {"Hello", 5}, {"Foo", 1},… Read More Is there any standard functionality for creating a flattened view of a map with a container as the mapped_type?
Is there any better way to drop last element in container using c++20 ranges than reverse it twice? #include <iostream> #include <vector> #include <ranges> int main() { std::vector<int> foo{1, 2, 3, 4, 5, 6}; for (const auto& d: foo | std::ranges::views::reverse | std::ranges::views::drop(1) | std::ranges::views::reverse) { std::cout << d << std::endl; } } >Solution :… Read More What is the best way to drop last element using c++20 ranges
Works fine on gcc trunk, but not on clang trunk, both with libstd++. Or am I missing something exceedingly obvious? Godbolt #include <algorithm> #include <iostream> #include <ostream> #include <vector> std::ostream& operator<<(std::ostream& os, const std::vector<int>& v) { for (auto&& e: v) os << e << " "; return os; } int main() { auto ints =… Read More std::ranges::remove still not suported / broken on clang trunk when using libstdc++?
#include <iostream> #include <cstdlib> #include <vector> #include <ranges> #include <algorithm> using namespace std; int main() { vector<int> ints = {1,2,3,4,5}; auto v = ints | views::take_while([](int i){return i<3;}) ; for (int i : v) std::cout << i << ‘ ‘; std::cout << ‘\n’; int size = v.size(); std::cout << size << std::endl; } v.size() does… Read More ranges views size does not compile
I am using algorithms from std::ranges (max and max_element) with a projection. Is it possible for the result to also be the projected value? Currently I have to call the projection function again on the returned value. Example: Here I want the size of the longest string, but the algorithms return only the string or… Read More Get projected value from std::ranges algorithms
To quickly create a for loop similar to python’s for i in range(100), I could do: for (auto const i : std::views::iota(0, 100)) { /* … */ } However, CLion is warning me to add a std::weakly_incrementable constraint to my auto: for (std::weakly_incrementable auto const i : std::views::iota(0, 100)) { /* … */ } I… Read More weakly_incrementable constraint while using iota_view
it’s my first time digging into the new <ranges> library and I tried a little experiment combining std::views::transform with a stateful lambda and ‘piping’ the resulting range to std::views::drop: #include <iostream> #include <ranges> #include <vector> using namespace std; int main() { auto aggregator = [sum = 0](int val) mutable { return sum += val; };… Read More Range transformations with stateful lambdas and std::views::drop
Consider the following code snippet: #include <vector> #include <ranges> #include <iostream> struct A { }; struct B { B(void *) {}; }; template<class T, class R> std::vector<T> foo(R &&range) { return std::vector<T> { std::ranges::begin(range), std::ranges::end(range) }; } int main() { std::cout << foo<A>(std::views::empty<A>).size() << "\n"; std::cout << foo<B>(std::views::empty<B>).size() << "\n"; } It correctly prints 0… Read More Inconsistent behavior with `empty` std ranges view depending on type