标签: boost-range

我试着编译这段代码:

#include <boost/range/adaptors.hpp>
#include <boost/range/algorithm.hpp>
#include <vector>

int main() {
    std::vector<int> v{
        1,5,4,2,8,5,3,7,9
    };
    std::cout << *boost::min_element(v | boost::adaptors::transformed(
            [](int i) { return -i; })) << std::endl;
    return 0;
}

编译失败,出现以下错误消息(在长模板实例化小说之后):

/usr/local/include/boost/iterator/transform_iterator.hpp:84:26: error: use of deleted function ‘main()::<lambda(int)>::<lambda>()’
../main.cpp:12:5: error: a lambda closure type has a deleted default constructor

我搜索了问题,并在Boost Users邮件列表存档中找到了这个问题.它建议使用#define BOOST_RESULT_OF_USE_DECLTYPE可以解决问题.我把它放在我的代码的最开头,但它仍然没有编译.错误消息的长度似乎要短得多,但最后的错误消息是相同的.我目前正在使用Boost 1.50.

这可能是什么问题？有没有办法让这项工作？

我试图通过向适配器提供c ++ 0x lambda来使用boost :: adapters :: transformed.

以下代码无法编译.我正在使用g ++ 4.6.2和boost 1.48.

#include <iostream>
#include <vector>

#include <boost/range/adaptors.hpp>
#include <boost/range/algorithm.hpp>

using namespace std;
namespace br    = boost::range;
namespace badpt = boost::adaptors;


int main()
{  
  vector<int> a = {0,3,1,};
  vector<int> b = {100,200,300,400};

  auto my_ftor = [&b](int r)->int{return b[r];};

  cout<<*br::max_element(a|badpt::transformed(my_ftor))<<endl;
}

关于我在这里做错了什么的想法？

考虑到:

#include <cassert>
#include <boost/range/irange.hpp>
#include <boost/range/algorithm.hpp>

int main() {
    auto range = boost::irange(1, 4);
    assert(boost::find(range, 4) == end(range));
}

Live Clang demo Live GCC demo

这给了:

main.cpp:8:37:错误:使用未声明的标识符'end'

考虑到如果你写using boost::end;它工作得很好,这意味着它boost::end是可见的:

为什么ADL不工作并且boost::end在表达中找到end(range)？如果它是故意的,它背后的理由是什么？

需要说明的是,预期结果与本例中使用std::find_if和不合格的结果类似end(vec).

我开始玩Boost :: Range,以便在C++中使用延迟转换管道.我现在的问题是如何在较小的部分拆分管道.假设我有:

int main(){
  auto map = boost::adaptors::transformed; // shorten the name
  auto sink = generate(1) | map([](int x){ return 2*x; })
                          | map([](int x){ return x+1; })
                          | map([](int x){ return 3*x; });
  for(auto i : sink)
    std::cout << i << "\n";
}

我想用a替换前两个地图magic_transform,即:

int main(){
  auto map = boost::adaptors::transformed; // shorten the name
  auto sink = generate(1) | magic_transform()
                          | map([](int x){ return 3*x; });
  for(auto i : sink)
    std::cout << i << …

我一直在浏览boost::range图书馆并注意到boost :: range_iterator和boost::iterator_range.我在这里对这些术语感到困惑.请问有谁可以解释两者之间有什么区别以及什么时候使用什么？此外,如果您能指出示例示例,除了文档之外,还可以使用增强范围库来了解更多相关信息.谢谢

我试图将一个boost::adaptors::transformed(让我们称之为map)链接到boost::adaptors::filtered(让我们称之为filter) - 这个想法是在一个范围内映射一个fun返回"Maybe"(在我的情况下,a std::pair<bool, T>)并仅输出部分结果.我的第一个实施:

define BOOST_RESULT_OF_USE_DECLTYPE // enable lambda arguments for Boost.Range
#include <boost/range/adaptor/filtered.hpp>
#include <boost/range/adaptor/transformed.hpp>

struct OnlyEven
{
    typedef int argument_type;
    typedef std::pair<bool, int> result_type;
    result_type operator()(argument_type x) const
    {
        std::cout << "fun: " << x << std::endl;
        return std::make_pair(x % 2 == 0, x);
    }
} only_even;

int main(int argc, char* argv[])
{
    auto map = boost::adaptors::transformed;
    auto filter = boost::adaptors::filtered;
    int v[] = {1, 2, …

在C++ 11的算法std::is_sorted和std::is_sorted_until都需要ForwardIterator秒.但是,Boost.Range版本boost::is_sorted只需要SinglePassRange与s对应的InputIterators.特别是,它委托给一个基于迭代器的实现,如下所示:

template<class Iterator, class Comp>
inline Iterator is_sorted_until (Iterator first, Iterator last, Comp c) {
  if (first == last)
    return last;

  Iterator it = first; ++it;

  for (; it != last; first = it, ++it)
    if (c(*it, *first))
      return it;

  return it;
}

这里我们看到在*first迭代++it器增量之后发生的迭代器解除引用.这意味着Iterator应该具有ForwardIterator所需的类别.为什么？因为标准这样说

24.2.3输入迭代器[input.iterators]/p2(见表107,关于这一行++r)

post:r不再要求任何前一个值的副本可以解除引用或属于==.

注意:这不是"单个示例的证明",但似乎任何基于比较的算法(例如adjacent_find)都必然需要前向迭代器才能在两个迭代器之间进行比较.

问题:为什么Boost.Range版本 …

使用有什么好处boost::any_range？这是一个例子:

typedef boost::any_range<
    int
  , boost::forward_traversal_tag
  , int
  , std::ptrdiff_t
> integer_range;

void display_integers(const integer_range& rng)
{
    boost::copy(rng,
                std::ostream_iterator<int>(std::cout, ","));

    std::cout << std::endl;
}

int main(){
    std::vector<int> input{ ... };
    std::list<int> input2{ ... };
    display_integers(input);
    display_integers(input2);
}

但是使用模板参数可以实现具有更高效率的相同功能,该参数满足ForwardRange概念:

template <class ForwardRange>
void display_integers(const ForwardRange& rng)
{
    boost::copy(rng,
                std::ostream_iterator<int>(std::cout, ","));

    std::cout << std::endl;
}

所以我在寻找使用any_range值得的场景.也许我错过了什么.

我想使用boost :: range来实现类似于NumPy和Matlab中可用的"花式索引".具体来说,我想使用另一个容器的元素作为索引来选择一个可索引容器的某些元素.例如,可以在Python中执行以下操作:

>>> squares = numpy.arange(10)**2  # Step 1 - setup squares
>>> indices = numpy.array([1,3,4]) # Step 2 - setup indices
>>> squares[indices]               # Step 3 - fancy indexing
array([ 1, 9, 16])

在C++中,使用boost :: range,我认为上面的代码看起来像这样:

#include "sampled.hpp"
#include <boost/assign/std/vector.hpp>
#include <boost/lambda/lambda.hpp>
#include <boost/range/adaptors.hpp>
#include <boost/range/algorithm.hpp>
#include <boost/range/counting_range.hpp>
#include <iostream>
#include <vector>

using namespace boost;
using namespace boost::adaptors;
using namespace boost::assign;
using namespace boost::lambda;
using namespace std;

int main(int argc, char** argv)
{
    // Step 1 - setup …

Python itertools具有teen-plicating iterables:

def tee(iterable, n=2):
    it = iter(iterable)
    deques = [collections.deque() for i in range(n)]
    def gen(mydeque):
        while True:
            if not mydeque:             # when the local deque is empty
                newval = next(it)       # fetch a new value and
                for d in deques:        # load it to all the deques
                    d.append(newval)
            yield mydeque.popleft()
    return tuple(gen(d) for d in deques)

我找不到相应的东西Boost::Range.我错过了什么或者我应该自己滚动吗？