c++ - 在 C++ 中顺序迭代任意数量的 vector

Question

我有一个函数可以收集并连接一定数量的 vector (当然，具有相同类型的元素)。这是它的基本概念:

vector<A> combined;
...
for(int i = 0; i < someNumber; i++)
    combined.insert(combined.end(), GetNextRange().begin(), GetNextRange().end());

所有这些都已完成，以便我可以按顺序迭代组合集。我想在没有所有复制业务的情况下实现这一目标。

由于 GetNextRange() 实际上返回了对行中下一个 vector 的引用，我如何利用这一事实并将引用放在一起/将它们排列成所需的访问方法？

Answer 1

首先，如果 GetNextRange() 实际上确实返回下一个 vector ，则您使用 GetNextRange() 两次来获取 begin() 和 end() 对你没有多大好处。至少你需要按照以下方式做一些事情

for (int i = 0; i != someNumber; ++i) {
    std::vector<A> const& tmp(GetNextRange());
    combined.insert(combined.end(), tmp.begin(), tmp.end());
}

如果你想让这有点好，你可以创建一个自定义迭代器，它在内部存储当前 vector 、索引和当前位置。它可能是一个输入迭代器，实际上将当前信息存储在合适的共享记录中，以便可以复制。

这是一个简单的(未经测试的)实现:

class joined_iterator {
    struct record {
        record(int limit)
            : index(0)
            , limit(limit)
            , current(limit? &GetNextRange(): 0)
            , pos()
        {
            if (this->current) {
                this->current->begin();
            }
        }
        int                            index;
        int                            limit;
        std::vector<A> const*          current;
        std::vector<A>::const_iterator pos;
    };
    std::shared_ptr<record> ptr;
public:
    joined_iterator(int limit): ptr(std::make_shared<record>(limit)) {}
    bool operator== (joined_iterator const& other) const {
        return this->ptr->current
            ? bool(other.ptr->current)
            : !bool(other.ptr->current);
    }
    bool operator!= (joined_iterator const& other) const {
        return !(*this == other);
    }
    A const& operator*() const { return *this->ptr->pos; }
    A const* operator->() const { return &*this->ptr->pos; }
    joined_iterator& operator++() {
        if (++this->ptr->pos == this->ptr->current->end()) {
            if (++this->ptr->index == this->ptr->limit) {
                this->ptr->current = 0;
            }
            else {
                this->ptr->current = &GetNextRange();
                this->ptr->pos = this->ptr->current->begin();
            }
        }
        return *this;
    }
    joined_iterator operator++(int) {
        joined_iterator rc(*this);
        this->operator++();
        return rc;
    }
};