c++ - 从 std::copy 和 std::copy_n 中提取输入迭代器

Question

我试图实现一种反序列化方法，该方法采用输入迭代器并执行一系列 block 读取(使用 std::copy 和 std::copy_n )。像这样(只是一个例子):

template <class InputIt>
InputIt unserialize(InputIt it)
{
  std::copy_n(it, sizeof(header_type), reinterpret_cast<char*>(&header));
  std::copy_n(it, header.payload_size, std::back_inserter(payload));
  it = optional.unserialize(it);
  return it;
}

在这种情况下我如何推进输入迭代器以便每次调用 std::copy_n继续阅读它，我终于可以归还它了吗？

出于性能原因，我希望对迭代器类别(尤其是 RandomAccessIterator 和 InputIterator)通用，并希望可以使用 std::copy方法而无需重写这些。诸如绑定(bind)检查之类的事情将由迭代器适配器完成，或者如果大小已知，则在反序列化调用之前进行检查。

什么不起作用也 Not Acceptable :

1. 使用 std::copy_n<InputIt&>(it, ...)可能适用于某些类别但不适用于所有类别，而且它太不可靠了。
2. 使用 std::advance每次调用后都会导致某些迭代器再次重新读取同一 block 。对某些来源来说不是可取的，而且可能是不可能的。

更新 作为copy_n 的随机访问迭代器 版本，制作迭代器引用适配器没有帮助。返回指向过去 复制的最后一个元素的指针，而输入迭代器 版本返回指向复制的最后一个元素的指针。所以我猜自己的版本copy_n与用于绑定(bind)检查的附加迭代器适配器配合使用效果最佳。

Answer 1

对于 random access iterator可以使用此表格 - 没问题:

template <class InputIt, class N, class OutputIt>
InputIt copy_n_advance_input(InputIt it, N dist, OutputIt outIt)
{
    std::copy_n(it, dist, outIt);
    return std::next(it, dist);
}

不幸的是 - 问题是当我们想要处理一次输入迭代器时 - 就像这里(得到'd' - 而不是'c'):

std::string s = "abcd";
std::istringstream ss{s};
auto e = copy_n_advance_input(std::istream_iterator<char>(ss), 
                             2, 
                             std::ostream_iterator<char>(std::cout, ","));
std::cout << "\n" << *e << "\n";

所以看起来像STL中一样需要两种形式:

template <class InputIt, class N, class OutputIt>
InputIt copy_n_advance_input_impl(InputIt it, N dist, OutputIt outIt,
                                  std::input_iterator_tag)
{
    while (dist-- > 0)
    {
        *outIt = *it;
        ++outIt;
        ++it;
    }
    return it;
}

template <class InputIt, class N, class OutputIt>
InputIt copy_n_advance_input_impl(InputIt it, N dist, OutputIt outIt, 
                                  std::random_access_iterator_tag)
{
    std::copy_n(it, dist, outIt);
    return std::next(it, dist);
}

template <class InputIt, class N, class OutputIt>
InputIt copy_n_advance_input(InputIt it, N dist, OutputIt outIt)
{
    return copy_n_advance_input_impl(it, dist, outIt, typename std::iterator_traits<InputIt>::iterator_category {});
}

请注意，std::input_iterator_tag 的建议版本不如在 STL 中高效(至少对于 gcc 而言)——它对输入进行额外的迭代——执行复制不需要此迭代——但需要返回“复制后”范围的开始(STL_algo.h):

754   template<typename _InputIterator, typename _Size, typename _OutputIterator>
755     _OutputIterator
756     __copy_n(_InputIterator __first, _Size __n,
757          _OutputIterator __result, input_iterator_tag)
758     {
759       if (__n > 0)
760     {
761       while (true)
762         {
763           *__result = *__first;
764           ++__result;
765           if (--__n > 0)
766         ++__first;
767           else
768         break;
769         }
770     }
771       return __result;
772     }

最后一点 - 对于随机访问迭代器(如 std::vector::iterator)，使用只调用 std 算法的版本是更明智的 - 因为它们可以更加优化 - 例如对于 POD 类型上的连续内存迭代器 - 可以只是 memcpy'ied。或 std::vector<bool> 的一些特化或 std::deque<T>存在，它使用它们的内部结构以最有效的方式执行复制。