Question

据我所知，在c ++中没有包含迭代器和reverse_iterator的公共基类。

到目前为止，我看到的唯一建议是使用模板解决这个问题（ How to write a function that takes an iterator or collection in a generic way?）

然而，这个解决方案对我来说似乎不起作用。

class MyClass
{
    template<typename Iter> Iter* generate_iterator(...params...)
    {
        //returns either a vector::iterator or vector::reverse_iterator
    }
    template<typename Iter> void do_stuff(Iter *begin, Iter *end)
    {
        //does stuff between elements specified by begin and end
        //I would like this function to remain agnostic of which direction it is working in!
    }
    void caller()
    {
        //I would like this function to remain agnostic of which direction it is working in too...
           do_stuff(generate_iterator(blah),generate_iterator(foo));
    }
};

在这种情况下，generate_iterator（）无法按需使用，因为编译器抱怨“generate_iterator不是MyClass类的成员”，大概是因为我没有指定它（我实际上不能这样做因为调用者应该是不可知的迭代器类型）。

有人可以帮忙吗？提前谢谢！

编辑：正如Mark B所指出的那样，generate_iterator必须返回一个指针 - 现已更正

更新：刚刚开始使用此http://thbecker.net/free_software_utilities/type_erasure_for_cpp_iterators/start_page.html，它似乎有用......

Answer 1

您可以创建自己的迭代器类，该类知道如何向两个方向前进。封装两种类型的迭代器，并在内部选择您初始化的那个。

这是一个开始：

template<typename Container>
class BiIterator
{
public:
    BiIterator(Container::iterator i) : m_fwd(i), m_isforward(true) {}
    BiIterator(Container::reverse_iterator i) : m_rev(i), m_isforward(false) {}
    bool operator==(const BiIterator & left, const BiIterator & right);
    Container::value_type & operator*()
    {
        if (m_isforward)
            return *m_fwd;
        return *m_rev;
    }
    const Container::value_type & operator*() const;
    BiIterator & operator++()
    {
        if (m_isforward)
            ++m_fwd;
        else
            ++m_rev;
        return *this;
    }
private:
    Container::iterator         m_fwd;
    Container::reverse_iterator m_rev;
    bool                        m_isforward;
};

Answer 2

在C ++中，您无法编写返回两种不同类型的函数。在您的模板案例中，它将根据实例化返回一个或另一个。你可能会返回一个指向多态迭代器的基指针，但这会让我问你在这里真正想做什么。即使是标准容器也不会尝试这样做：他们有begin和rbegin来正确区分。我建议有两个单独的函数，每个函数都做正确的事情并返回一种类型的迭代器或另一种类型的上下文指示。

作为一方，请注意，您不能隐式确定仅用于函数返回类型的类型的模板实例化。

Answer 3

通过使用boost tuple和boost any，您的问题可以轻松解决。我用boost :: any编写了一个例子，见下文：

#include <boost/any.hpp>
using boost::any_cast;
#define MSG(msg) cout << msg << endl;
boost::any getIterator(std::vector<int>& vec, bool bReverse)
{
    if(!bReverse)
        return boost::any(vec.begin());
    else
        return boost::any(vec.rbegin());
}

int main() 
{
    std::vector<int> myvec;
    myvec.push_back(1);
    myvec.push_back(2);
    myvec.push_back(3);


    typedef std::vector<int>::iterator vecIter;
    typedef std::vector<int>::reverse_iterator vecRIter;
    try
    {
        boost::any iter  = getIterator(myvec, false);
        boost::any iter2 = getIterator(myvec, true);
        vecIter  it1 = any_cast<vecIter>(iter);
        vecRIter it2 = any_cast<vecRIter>(iter2);
        MSG(*it1);//output 1
        MSG(*it2);//output 3
        return true;
    }
    catch(const boost::bad_any_cast &)
    {
        return false;
    }
}

Answer 4

使用boost::variant或boost::any。

boost::variant< reverse_iterator, iterator >
generate_iterator(...) {
  if(...) return iterator();
  else return reverse_iterator();
}

// user code
boost::variant< reverse_iterator, iterator > v = generate_iterator();

if(reverse_iterator* it = boost::get<reverse_iterator>(v))
  ...;
else if(...)
  ...;

虽然可以通过访问者更好地访问variant。

缺点是你需要一些锅炉板来提取正确的类型，这正是any_iterator这样的东西可能是更明智的选择的原因。

如何编写一个可以返回iterator或reverse_iterator的c ++函数

4 个答案: