标签: iterator

我在Ruby中有一个任意方法,它产生多个值,因此可以将它传递给一个块:

def arbitrary
  yield 1
  yield 2
  yield 3
  yield 4
end

arbitrary { |x| puts x }

我想修改这个方法,这样,如果没有块,它只是将值作为数组返回.所以这个结构也可以运行:

myarray = arbitrary
p a -----> [1, 2, 3, 4, 5]

这可能在Ruby中吗？

map<string,Shopable*>::iterator it = mymap.begin();

迭代器似乎是常量,但items.begin()不返回常量迭代器.或者,这就是我的想法,因为鼠标悬停错误是这样的:

"No conversion from 'std::Tree_const_iterator<...> to std::Tree_iterator<...> exists'".

为什么？

根据这个非常高度推崇的答案,迭代一组擦除一些元素的规范方法如下:

for (it = mySet.begin(); it != mySet.end(); ) {
    if (conditionToDelete(*it)) {
        mySet.erase(it++);
    }
    else {
        ++it;
    }
}

当然,这是C++ 03设置擦除不返回迭代器的结果.否则一个人就可以写了it = mySet.erase(it);很明显,一个人可以写

itToDelete = it++;
mySet.erase(itToDelete);

这个问题不是关于如何在迭代时删除元素.问题是为什么以下行显然不会导致未定义的行为.

mySet.erase(it++);

起初我确信这必须是UB,因为我在考虑后增量方面做错了.这是一种常见(但错误的)方式,将预增量视为在评估的其余部分之前发生,并且后增量发生在AFTER之后.当然,这是错误的.后增量和前增量都有增加变量的副作用.不同之处在于这些表达式的价值.

也就是说,据我所知,C++标准(至少是C++ 03标准)没有明确说明何时会发生后增量的副作用.因此,除非我们保证如果作为后增量表达式的函数参数在进入函数体之前会产生副作用,那么这不应该是UB吗？究竟是什么(标准方面),如果有的话,禁止在迭代器在函数体内失效后发生的++副作用？

标准的行情非常受欢迎.

为了一个参数,让我们假设set的迭代器是一个内置类型,这实际上是operator ++,而不是重载的operator-function

我尝试编写一个函数,它将对容器的元素求和.这个容器可以是Vector,List,Queue等......这就是我尝试模板的原因.

不幸的是我收到此错误:

'C'不是模板

资源:

#include <iostream>
#include <vector>

using namespace std;

template<class C, typename T>
T sum( C<T>::iterator begin, C<T>::iterator end ) {
    T s = null;

    for (C<T>::iterator it = begin; it != end; it++) {
        s += *it;
    }

    return s;
}

int main()
{
    vector<int> v = {5, 9, 0, 11};

    cout << sum(v.begin(), v.end()) << endl;

    return 0;
}

我错了什么？我该如何解决？

我有下面的代码,我希望它抛出一个ConcurrentModificationException,但它运行成功.为什么会这样？

public void fun(){
    List <Integer>lis = new ArrayList<Integer>();
    lis.add(1);
    lis.add(2);

    for(Integer st:lis){
        lis.remove(1);
        System.out.println(lis.size());
    }
}

public static void main(String[] args) {
    test t = new test();
    t.fun();
}

如果我想在稳定的Rust中使用自定义步骤进行迭代,我该怎么办？基本上就像C/C++

for (int i = 0; i < n; i += 2) {

}

我已经尝试过使用range_step_inclusive和解决方案如何使用自定义步骤迭代范围？:

use std::iter::range_step_inclusive;
for i in range_step_inclusive(0, n, 2) {
    println!("i: {}", i);
}

但似乎它在Rust 1.1中不可用:

error: unresolved import `std::iter::range_step_inclusive`. There is no `range_step_inclusive` in `std::iter`

什么是另类？可能是创建自定义范围的惯用方法.

我想以std::begin通用的方式获得返回类型.我目前的解决方案是:

using type = decltype(std::begin(std::declval<T>()));

它适用于T = std::vector<int>.但我不明白为什么以下不起作用:

using type = decltype(std::begin(std::declval<int[3]>()));

我收到错误:

example.cpp:83:60: error: no matching function for call to ‘begin(int [3])’
     using type = decltype(std::begin(std::declval<int[3]>()));

如何以std::begin通用方式获取返回类型？

我有一个问题,理解为什么以下行之一返回生成器和另一个元组.

如何在第二行中创建生成器的确切原因和原因,而在第三行中生成一个元组？

sample_list = [1, 2, 3, 4]
generator = (i for i in sample_list)
tuple_ = (1, 2, 3, 4)

print type(generator)
<type 'generator'>

print type(tuple_)
<type 'tuple'>    

是因为元组是不可变对象,当我尝试解压缩里面的列表时(),它不能创建元组,因为它必须更改元组元组.

我昨天看到这个用户发帖.我认为这是输出矢量的一种很酷的方式.所以我输入了一个例子并问自己这与for each循环相比如何？

template <typename T>
void printVectorO(std::vector<T> &v)
{
    std::cout << "Ostream_iterator contents: " << std::endl;
    auto start = std::chrono::high_resolution_clock::now();
    std::ostream_iterator<T> ost(std::cout, " ");
    std::copy(begin(v), end(v), ost);
    std::cout << std::endl;

    auto end = std::chrono::high_resolution_clock::now();
    auto time = end - start;
    auto nano = std::chrono::duration_cast<std::chrono::nanoseconds>(time);
    std::cout << "Ostream_iterator computation took: " << nano.count() << " nano seconds"<< std::endl;
    std::cout << std::endl;
}

template <typename T>
void printVectorC(std::vector<T> &v)
{
    std::cout << "For Each Loop contents: …

我觉得这个问题肯定已被多次询问和解决,因为在我看来这是一个非常通用的场景,但我找不到任何指向解决方案的方法.

我正在尝试实现一个通用的可迭代Generator对象,该对象产生一个数字序列,直到满足某个终止条件,表明已经达到这样的条件以便停止迭代.

基本思想本质上是与Python的生成器类似,其中一个对象产生值,直到它不再产生为止,然后StopIteration引发异常以通知外部循环序列已完成.

根据我的理解,问题分为创建序列生成对象,然后在其上获取迭代器.

对于序列生成对象,我想我会定义一个基Generator类,然后扩展它以提供特定的行为(例如,从一组范围中获取值,或从固定值列表中获取等).所有GeneraorS中的每个呼叫产生一个新的值operator()或者抛出一个ValuesFinishedException如果发电机跑到序列的末端.我这样实现了这个(我以单范围子类为例,但我需要能够建模更多类型的序列):

struct ValuesFinishedException : public std::exception { };

template <typename T>
class Generator
{
public:
    Generator() { };
    ~Generator() { };
    virtual T operator()() = 0; // return the new number or raise a ValuesFinishedException
};

template <typename T>
class RangeGenerator : public Generator<T>
{
private:
    T m_start;
    T m_stop;
    T m_step;

    T m_next_val;

public:
    RangeGenerator(T start, T stop, T step) :
        m_start(start),
        m_stop(stop), …