标签: iterator

使用Java Iterator,我使用该hasNext方法来确定迭代是否具有更多元素(不消耗元素) - 因此,hasNext就像一个" Peek"方法.

我的问题:C#的通用s 有什么类似于" hasNext"或" Peek"的方法IEnumerator吗？

我写了一个OutputIterator来回答另一个问题.这里是:

#include <queue>

using namespace std;

template< typename T, typename U >
class queue_inserter {
    queue<T, U> &qu;  
public:
    queue_inserter(queue<T,U> &q) : qu(q) { }
    queue_inserter<T,U> operator ++ (int) { return *this; }
    queue_inserter<T,U> operator * () { return *this; }
    void operator = (const T &val) { qu.push(val); }
};

template< typename T, typename U >
queue_inserter<T,U> make_queue_inserter(queue<T,U> &q) {
    return queue_inserter<T,U>(q);
}    

这适用于这个小复制功能:

template<typename II, typename OI>
void mycopy(II b, II e, OI oi) {
    while …

给定n个不同项目的列表,我如何逐步交换每次交换一对值的项目的每个排列？(我认为这是可能的,它确实应该是这样.)

我正在寻找的是一个迭代器,它产生下一对要交换的项的索引,这样如果迭代n!-1次,它将逐步通过n!列表的排列按某种顺序排列.如果再次迭代它会将列表恢复到它的起始顺序,这将是一个奖励,但它不是一个要求.如果所有对都涉及第一个(相应的是最后一个)元素作为其中一个,那么该函数只需返回一个值,这也是一个奖励.

示例: - 对于3个元素,您可以交替地将最后一个元素与第一个和第二个元素交换以循环排列,即:(abc)swap 0-2 =>(cba)1-2(cab)0-2( bac)1-2(bca)0-2(acb).

我将在C中实现,但可能会在大多数语言中解决问题.

我认为这Iterator.copy()将是一个非常方便的功能.您可以以更好的方式实现迭代器过滤器.

例如,Googles Java Collection中filter(和类似的)函数使用的唯一原因UnmodifiableIterator(只是Iterator没有remove)是因为你不能实现这样的过滤器,Iterator否则无法在某些时候复制它.(真的,使用当前界面是不可能的;试试吧.)

另一个优点是你可以在for-each-loop中使用迭代器:因为可复制的迭代器也可以自动迭代.另见这个问题.目前,主要的设计理由不允许这样做是因为Iterator它实现Iterable并Iterator<T> iterator() { return this; }会使无效迭代器.通过使用一个copy函数,它就像它一样简单Iterator<T> iterator() { return copy(); }并且它不会使原始迭代器无效.因此,没有理由不允许这样做.

有什么缘故吗？只是为了减少实现它的复杂性？

因为我找不到我要找的东西,所以我打算自己写一些东西,但我想在潜入之前先问问群众.

• 是否有一个boost或stl随机访问容器类型允许传入预填充缓冲区？

虚构的(？)容器类型将运行如下:

  const int blobSize = unpackBlobSize( msg );
  int *     blob     = unpackBlobData( msg );

  SpecialVector<int> mySpecialIntVector( blob, blobSize );

基本上我将旧库与c风格的原始指针连接到缓冲区,但是想要使用C++样式容器语义而不需要复制步骤.我希望有的是std :: vector plus preallocated&prefilled buffer constructor,减去resize.

Libeigen在他们的Eigen :: Map中具有这种功能,它允许以下内容:

  int array[9];
  for(int i = 0; i < 9; ++i) 
      array[i] = i;
  stl::cout << Eigen::Map<Eigen::Matrix3i>(array) << stl::endl;

有人知道一个涵盖这些约束的boost或stl模板吗？

我想enumerate在迭代器上使用类似函数来生成该对(previous_element, current_element).也就是说,由于iter是

i0, i1, i1, ...

我想offset(iter)屈服

(None, i0), (i0, i1), (i1, i2) ...

for k,v in targets.iteritems():
    price= str(v['stockprice'])

    Bids = str(u''.join(v['OtherBids']))
    Bids = Bids.split(',')

    # create a list of unique bids by ranking
    for a, b in zip(float(price), Bids):
        try:
            del b[next(i for i, e in enumerate(b) if format(e, '.4f')  == a)]
        except StopIteration:
            pass

我从我的字典中提取数据,但似乎所有这些都是unicode.我怎么能摆脱unicode废话？

我尝试编写一个函数,它将对容器的元素求和.这个容器可以是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;
}

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

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

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

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'>    

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

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

我正在尝试实现一个通用的可迭代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), …