“通用” c++ 中的迭代器

Question

我有：

void add_all_msgs(std::deque<Message>::iterator &iter);

如何使该函数“通用”，以便它可以采用任何类型的输入迭代器？ 我并不关心它是在迭代双端队列、向量还是其他东西，只要迭代器在迭代消息即可。 - 这在 C++ 中完全可能吗？

Answer 1

template <typename Iterator>
void add_all_messages(Iterator first, Iterator last)

用法 ：

vector<message> v;
add_all_messages(v.begin(), v.end());

需要指定结束，否则不知道什么时候停止！ 它还使您可以灵活地仅添加容器的子范围。

Answer 2

template<class InputIterator>
void add_all_msgs(InputIterator iter);

用法：

std::deque<Message> deq;
add_all_msgs(deq.begin());

Answer 3

如果您希望编译器检查迭代器是否确实引用 Message 对象，您可以使用如下技术。

template <typename InputIterator, typename ValueType>
struct AddAllMessages { };

template <typename InputIterator>
struct AddAllMessages<InputIterator, Message> {
  static void execute(const InputIterator &it) {
    // ...
  }
};

template <typename InputIterator>
void add_all_msgs(const InputIterator &it) {
  AddAllMessages<InputIterator, 
                 typename std::iterator_traits<InputIterator>::value_type>::execute(it);
}

Answer 4

如果您不想模板化 add_all_msgs 函数，可以使用 adobe::any_iterator：

typedef adobe::any_iterator<Message, std::input_iterator_tag> any_message_iterator;
void add_all_msgs(any_message_iterator begin, any_message_iterator end);

Answer 5

使用 C++ 风格的迭代器很难实现动态多态性。 operator++(int) 按值返回，据我所知这是很棘手的：你不能有一个虚拟成员函数在不被切片的情况下按值返回 *this 。

如果可能的话，我建议像其他人所说的那样使用模板。

但是，如果您确实需要动态多态性，例如因为您无法像模板那样公开 add_all_msgs 的实现，那么我认为您可以假装是 Java，如下所示：

struct MessageIterator {
    virtual Message &get() = 0;
    virtual void next() = 0;
    // add more functions if you need more than a Forward Iterator.
    virtual ~MessageIterator() { };  // Not currently needed, but best be safe
};

// implementation elsewhere. Uses get() and next() instead of * and ++
void add_all_msgs(MessageIterator &it);

template <typename T>
struct Adaptor : public MessageIterator {
    typename T::iterator wrapped;
    Adaptor(typename T::iterator w) : wrapped(w) { }
    virtual Message &get() {
        return *wrapped;
    }
    virtual void next() {
        ++wrapped;
    }
};

int main() {
    std::deque<Message> v;
    Adaptor<std::deque<Message> > a(v.begin());
    add_all_msgs(a);
}

我已经检查过它是否可以编译，但我还没有没有测试过，而且我以前从未使用过这种设计。 我也没有担心 const 性 - 实际上你可能需要一个 const Message &get() const 。 目前适配器无法知道何时停止，但是您开始使用的代码也不知道，所以我也忽略了这一点。 基本上，您需要一个 hasNext 函数，它将 wrapped 与提供给构造函数的结束迭代器进行比较。

您也许可以使用模板函数和常量引用做一些事情，这样客户端就不必了解或声明那个令人讨厌的适配器类型。

[编辑：想一想，最好有一个存根 add_all_msgs 函数模板，将其参数包装在适配器中，然后调用 real_add_all_msgs。 这对客户端完全隐藏了适配器。]

Answer 6

比上面的稍微简单一些（因为它利用了现有的库）：

#include <boost/static_assert.hpp> // or use C++0x static_assert
#include <boost/type_traits/is_same.hpp>

template <typename InputIterator>
void add_all_msgs( InputIterator it ) {
    BOOST_STATIC_ASSERT(( boost::is_same<
        typename std::iterator_traits<InputIterator>::value_type,
        Message>::value ));
    // ...

Answer 7

#include <deque>
#include <vector>
#include <list>
#include <string>
using namespace std;

template<typename T>
void add_all_msgs(T &iter)
{

}

int _tmain(int argc, _TCHAR* argv[])
{
    std::deque<string>::iterator it1;
    std::vector<string>::iterator it2;
    std::list<string>::iterator it3;

    add_all_msgs(it1);
    add_all_msgs(it2);
    add_all_msgs(it3);


    return 0;
}