Question

嘿所有人。一位朋友为我编写了一些Java代码，我很容易将其转换为C ++，但我对C ++中的Java迭代器的等价物非常好奇。这是代码，我很可能希望将数据返回到向量中。任何帮助表示赞赏

public class RLEIterator
extends RegionIterator
{
    public int reg = 0;
    public int mode = 0;
    public int skip = 0;
        // mode is the number of IDs that are valid still (count down)
        // skip is used after we run out of mode IDs, and move forward
        //   The goal is, to always have a valid 'hasNext' state, after
        // an ID is read via 'next'. Thus, the initial search, and then
        // the reading forward if mode == 0, after the ID is found.
    public int i;

    public RLEIterator()
    {
        // Need to set up the skip of an initial part, so we can
        // correctly handle there not being anything, despite there
        // being data encoded.

        int comp;
        i = 0;

        while ((mode == 0) && (i<nearRLE.length))
        {
            // set up the next code
            comp = ((int)nearRLE[i]) & 0xff;

            if ((comp > 0) && (comp <= 0x3e))
            {
                // skip forward by comp;
                reg += comp;
                i++;
                mode = 0; // have to keep on reading
            }
            else if (comp == 0x3f)
            {
                // skip forward by the following 16 bit word;
                // second byte is hi-byte of the word
                reg += ((int)nearRLE[i+1]) & 0xff;
                reg += (((int)nearRLE[i+2]) & 0xff) << 8;

                i+=3;
            }
            else if (comp == 0xff)
            {
                // include the following WORD of regions
                mode = ((int)nearRLE[i+1]) & 0xff;
                mode += (((int)nearRLE[i+2]) & 0xff) << 8;
                i += 3;
            }
            else if ((comp >= 0xc0) && (comp <= 0xfe))
            {
                // comp - 0xc0 regions are nearby
                mode = comp - 0xc0;  // +1 perhaps?
                i++;
            }
            else if ((comp >= 0x40) && (comp <= 0x7f))
            {
                // skip bits 3-5 IDs and then include bits 0-2
                reg += (comp & 0x38) >> 3;
                mode = (comp & 0x7);
                i++;
            }
            else if ((comp >= 0x80) && (comp <= 0xbf))
            {
                // include IDs bits 3-5, then skip bits 0-2
                mode = (comp & 0x38) >> 3;
                skip = (comp & 0x7);
                i++;
            }
        }
    }

    public boolean hasNext()
    {
        // not at the end of the RLE, and not currently processing a
        // directive. (mode)
        return (mode > 0);
    }

    public int next()
    {
        int ret = -1;
        int comp;

        // sanity check first. Shouldn't truthfully get called if mode
        // isn't >0
        if (mode <= 0)
            return -1;

        ret = reg;
        reg++;
        mode--;

        if (mode == 0)
        {
            // skip forward
            reg += skip;
            skip = 0;

            while ((mode == 0) && (i<nearRLE.length))
            {
                // set up the next code
                comp = ((int)nearRLE[i]) & 0xff;

                if ((comp > 0) && (comp <= 0x3e))
                {
                    // skip forward by comp;
                    reg += comp;
                    i++;
                    mode = 0; // have to keep on reading
                }
                else if (comp == 0x3f)
                {
                    // skip forward by the following 16 bit word;
                    // second byte is hi-byte of the word
                    reg += ((int)nearRLE[i+1]) & 0xff;
                    reg += (((int)nearRLE[i+2]) & 0xff) << 8;

                    i+=3;
                }
                else if (comp == 0xff)
                {
                    // include the following WORD of regions
                    mode = ((int)nearRLE[i+1]) & 0xff;
                    mode += (((int)nearRLE[i+2]) & 0xff) << 8;
                    i += 3;
                }
                else if ((comp >= 0xc0) && (comp <= 0xfe))
                {
                    // comp - 0xc0 regions are nearby
                    mode = comp - 0xc0;  // +1 perhaps?
                    i++;
                }
                else if ((comp >= 0x40) && (comp <= 0x7f))
                {
                    // skip bits 3-5 IDs and then include bits 0-2
                    reg += (comp & 0x38) >> 3;
                    mode = (comp & 0x7);
                    i++;
                }
                else if ((comp >= 0x80) && (comp <= 0xbf))
                {
                    // include IDs bits 3-5, then skip bits 0-2
                    mode = (comp & 0x38) >> 3;
                    skip = (comp & 0x7);
                    i++;
                }
            }
        }

        return ret;
    }
}

同样，在C ++中如何适应单个函数（如果可能）的方案的任何帮助都会很棒。谢谢！

Answer 1

您对C ++迭代器的熟悉程度如何？它们的设计看起来非常像指针，所以给定一个迭代器it：

++it

将递增迭代器（跳到下一个元素）

*it

将取消引用迭代器（将引用返回到它指向的元素）

--it

将（如果它被定义）减少迭代器（返回前一个元素）

C ++迭代器通常对它们所操作的容器一无所知。特别是，检查序列中是否还有更多元素的方法不是在迭代器上调用HasNext，而是将它与您知道指向序列末尾的迭代器进行比较。（或者，严格地说，将它与指向序列末尾的元素进行比较。）

除此之外，迭代器需要定义一些typedef和其他辅助内容，以帮助编译器对迭代器的功能进行分类和理解。

定义迭代器的最简单方法是使用Boost.Iterator库的iterator_facade类，它实现了几乎所有的管道。该库具有出色的文档，包括描述如何定义自己的迭代器类型的教程。

如果使用Boost是一个选项，你一定要去做。否则，标准库有std::iterator也有一点帮助（但是，值得注意的是，强制 - 迭代器可以完全有效地定义而无需从此类派生）< / p>

对不起，我没有写完一个完整的例子，但我现在有点急。（而且，如果你能够使用Boost，那么从头开始定义一个示例迭代器就会浪费时间）。希望上述内容足以让您入门。

Java Iterator在C ++中的等价物？（带代码）

1 个答案:

Java Iterator在C ++中的等价物？ （带代码）

1 个答案:

Java Iterator在C ++中的等价物？（带代码）