c++ - 关于使用 boost::zip 迭代器的一些代码的问题

Question

最近我看到了一些关于如何使用 boost::zip_iterator 的示例代码。但是，我不知道它是如何工作的。这是代码:

class to_hex2
{
private:
    vector<unsigned char> &v;
    char trans(const char c) const
    {
        if(c >= 'a')
            return c - 'a' + 10;
        else if(c >= 'A')
            return c - 'A' + 10;
        else
            return c - '0';
    }
public:
    to_hex2(vector<unsigned char> &_v): 
        v(_v){}

    typedef boost::tuples::tuple<const char&,const char&> Tuple;
    void operator()(Tuple const &t) const   
    {
        static char tmp;    
        tmp = trans(t.get<0>()) * 0x10;
        tmp += trans(t.get<1>());
        v.push_back(tmp);
    }
};

int main()
{
    char s[] = "1234aBcD";
    vector<unsigned char> v;
    typedef step_iterator<const char*> si_t;    
    for_each(
                boost::make_zip_iterator(
                    boost::tuples::make_tuple(si_t(s),si_t(s+1))),  
                boost::make_zip_iterator(
                    boost::tuples::make_tuple(si_t(s+8),si_t(s+9))),    
                to_hex2(v));
    std::copy(
                v.begin(),v.end(),std::ostream_iterator<unsigned char>(cout," "));
    std::cout<<std::endl<<"v.size="<<v.size();
    return 0;
}

step_iterator 是迭代两个步骤而不是一个步骤的迭代器。

我的第一个问题是:因为数组 s 的索引最多为 8(包括 '\0':-) )，所以可以写 s+9 吗？不过，代码似乎可以正常运行。

我的第二个问题是:由于 zip_iterator 可以同时迭代一个 vector ，这是否意味着结果是随机的？我看到的结果是不变的，如下图:

最后但并非最不重要的一点，有人能告诉我结果是如何生成的(它是什么意思)，因为 ASCII 码中没有上下箭头(我用谷歌搜索并看到它 here )。

Answer 1

只要您不取消引用指针，就可以指向数组末尾的一个。这非常有用，因为 C++ 使用半开范围，其中排除了最后一个元素。

在您发布的代码中，s+9指向 s 的末尾后一个，但永远不会取消引用，因此行为是明确定义的。

关于你的第二个问题:不，这段代码的结果不是随机的。元素将按顺序从头到尾迭代。当文档说明 zip_iterator允许对序列进行并行迭代，这并不意味着迭代将由多个线程或其他任何东西同时执行，它仅意味着每次迭代将推进多个迭代器而不是一个迭代器。这是 for_each 的可能实现:

template <typename InputIterator, typename Func>
void for_each(InputIterator first, InputIterator last, Func f)
{
    while (first != last)
    {
        f(*first);
        ++first;
    }
}

如您所见，for_each适用于单个迭代器。如果你需要一次迭代两个序列，那么你可以使用 zip_iterator ，它封装了几个迭代器。它的operator*返回多个值(一个元组)，及其 operator++ s 递增所有迭代器，同时推进它们。

为了更好地理解您的代码中发生了什么，这里是一个精简版本，没有 zip_iterator和 for_each :

class to_hex2
{
private:
    vector<unsigned char> &v;
    char trans(const char c) const
    {
        if(c >= 'a')
            return c - 'a' + 10;
        else if(c >= 'A')
            return c - 'A' + 10;
        else
            return c - '0';
    }
public:
    to_hex2(vector<unsigned char> &_v): 
        v(_v){}

    void operator()(const char &first, const char &second) const   
    {
        static char tmp;    
        tmp = trans(first) * 0x10;
        tmp += trans(second);
        v.push_back(tmp);
    }
};

int main()
{
    char s[] = "1234aBcD";
    vector<unsigned char> v;

    to_hex2 transformer(v);

    char *first = s;
    char *second = s + 1;

    for ( ; first != s + 8 && second != s + 9 ; first += 2, second += 2)
    {
        transformer(*first, *second);
    }

    std::copy(v.begin(),v.end(),
              std::ostream_iterator<unsigned char>(cout," "));
    std::cout<<std::endl<<"v.size="<<v.size();
    return 0;
}

希望这能说明 zip_iterator只是让多个迭代器同时前进的一种便捷方式。

最后，为了理解这段代码的用途，您可能应该将结果打印为整数而不是字符。你应该看到这个:

18 52 171 205

它们是原始字符串中包含的十六进制数的十进制表示形式(12 ₁₆ = 18 ₁₀, 34 ₁₆ = 52 ₁₀, AB ₁₆ = 171 ₁₀ 和 CD ₁₆> = 205 ₁₀)。所以基本上，v包含原始十六进制字符串的基数 256 中的表示。