c++ - 如何为 boost::tokenizer 实现 tokenizer.rbegin() 和 rend()？

Question

我正在使用 boost::tokenizer，但我意识到它不支持 rbegin() 和 rend()。我想请问如何将这两个功能添加到现有类中？

这是来自 boost 网站:

#include <iostream>
#include <string>
#include <boost/tokenizer.hpp>

using namespace std;
using namespace boost;

int main() {
 string str( "12/12/1986" );
 typedef boost::tokenizer<boost::char_separator<char>> tokenizer;
 boost::char_separator<char> sep( "/" );
 tokenizer tokens( str, sep );
 cout << *tokens.begin() << endl;
    // cout << *tokens.rbegin() << endl; How could I implement this?
 return 0;
}

更新
这是我目前的进度。我首先导航到 tokenizer 的 src:

//===========================================================================
  // A container-view of a tokenized "sequence"
  template <
    typename TokenizerFunc = char_delimiters_separator<char>, 
    typename Iterator = std::string::const_iterator,
    typename Type = std::string
  >
  class tokenizer {
  private:
    typedef token_iterator_generator<TokenizerFunc,Iterator,Type> TGen;

    // It seems that MSVC does not like the unqualified use of iterator,
    // Thus we use iter internally when it is used unqualified and
    // the users of this class will always qualify iterator.     
    typedef typename TGen::type iter;

  public:

    typedef iter iterator;
    typedef iter const_iterator;
    typedef Type value_type;
    typedef value_type& reference;
    typedef const value_type& const_reference;
    typedef value_type* pointer;
    typedef const pointer const_pointer;
    typedef void size_type;
    typedef void difference_type;

    tokenizer(Iterator first, Iterator last,
              const TokenizerFunc& f = TokenizerFunc()) 
      : first_(first), last_(last), f_(f) { }

    template <typename Container>
    tokenizer(const Container& c)
      : first_(c.begin()), last_(c.end()), f_() { }

    template <typename Container>
    tokenizer(const Container& c,const TokenizerFunc& f)
      : first_(c.begin()), last_(c.end()), f_(f) { }

    void assign(Iterator first, Iterator last){
      first_ = first;
      last_ = last;
    }

    void assign(Iterator first, Iterator last, const TokenizerFunc& f){
      assign(first,last);
      f_ = f;
    }

    template <typename Container>
    void assign(const Container& c){
      assign(c.begin(),c.end());
    }


    template <typename Container>
    void assign(const Container& c, const TokenizerFunc& f){
      assign(c.begin(),c.end(),f);
    }

    iter begin() const { return iter(f_,first_,last_); }
    iter end() const { return iter(f_,last_,last_); }

  private:
    Iterator first_;
    Iterator last_;
    TokenizerFunc f_;
  };

然后我主要讲两种方法:

iter begin() const { return iter(f_,first_,last_); }
iter end() const { return iter(f_,last_,last_); }

由于它返回类型为 iter( f_, first_, last_ ) 的构造函数，因此我转到此类的源代码。而 iter 实际上是:

 typedef typename TGen::type iter;

这是 token_iterator_generator 类。这个类的实现是:

template <
        class TokenizerFunc = char_delimiters_separator<char>, 
        class Iterator = std::string::const_iterator,
        class Type = std::string
    >
    class token_iterator_generator {

    private: 
    public:
        typedef token_iterator<TokenizerFunc,Iterator,Type> type;
    };

所以现在我想通了，Tokenizer类的iterator其实就是token_iterator<>。 token_iterator 的实现真的把我吓坏了:

template <class TokenizerFunc, class Iterator, class Type>
  class token_iterator
      : public iterator_facade<
            token_iterator<TokenizerFunc, Iterator, Type>
          , Type
          , typename detail::minimum_category<
                forward_traversal_tag
              , typename iterator_traversal<Iterator>::type
            >::type 
          , const Type&
        >
  {

      friend class iterator_core_access;

      TokenizerFunc f_;
      Iterator begin_;
      Iterator end_;
      bool valid_;
      Type tok_;

      void increment(){
          BOOST_ASSERT(valid_);
          valid_ = f_(begin_,end_,tok_);
      }

      const Type&  dereference() const {
          BOOST_ASSERT(valid_);
          return tok_;
      }
      template<class Other>
      bool equal(const Other& a) const{
          return (a.valid_ && valid_)
              ?( (a.begin_==begin_) && (a.end_ == end_) )
              :(a.valid_==valid_);

      }

      void initialize(){
          if(valid_) return;
          f_.reset();
          valid_ = (begin_ != end_)?
              f_(begin_,end_,tok_):false;
      }
  public:
      token_iterator():begin_(),end_(),valid_(false),tok_() { }

      token_iterator(TokenizerFunc f, Iterator begin, Iterator e = Iterator())
          : f_(f),begin_(begin),end_(e),valid_(false),tok_(){ initialize(); }

      token_iterator(Iterator begin, Iterator e = Iterator())
            : f_(),begin_(begin),end_(e),valid_(false),tok_() {initialize();}

      template<class OtherIter>
      token_iterator(
            token_iterator<TokenizerFunc, OtherIter,Type> const& t
            , typename enable_if_convertible<OtherIter, Iterator>::type* = 0)
            : f_(t.tokenizer_function()),begin_(t.base())
            ,end_(t.end()),valid_(!t.at_end()),tok_(t.current_token()) {}

      Iterator base()const{return begin_;}

      Iterator end()const{return end_;};

      TokenizerFunc tokenizer_function()const{return f_;}

      Type current_token()const{return tok_;}

      bool at_end()const{return !valid_;}




  };

这个类非常复杂，我在这里迷路了 :( !iterator_facade<> 的继承部分非常复杂。知道我接下来应该去哪里吗？

谢谢，

Answer 1

您当然可以创建一个新类来实现它，方法是使用普通分词器简单地迭代字符串并将值存储在 vector 中。然后使用 vector 实现 rend 和 rbegin。

简单且几乎没有出错的风险，尽管在运行时可能不是最快的，也不是最少的内存占用。除非您知道这会成为一个问题，否则这就是我要采用的方法，因为它实现起来非常容易和快速。

但是，您特别要求扩展现有类，我认为这是个坏主意。在这种情况下，最简单的方法可能是更改采用容器(您正在使用的容器)的构造函数，以使用容器的 rbegin() 和 rend() 而不是 begin() 和 end() 来实例化内部分词器对象。要实现您自己的 rbegin() 和 rend()，请从您从内部分词器的 begin 和 end 获得的迭代器开始。从这些返回的 token 可能会倒退，所以你需要扭转这些。不过，使用 boost::iterators 包可能很容易实现实际的迭代器类型。

请注意，您需要特别注意采用显式迭代器的构造函数，或者决定只为您的反向迭代器实现类功能的一个子集(在这种情况下，您可能应该使用一个单独的类来保留两个无论如何内部分词器而不是假装是一个 boost::tokenizer)。

替代方法是更改​​ char_separator(和其他分隔符类)，以便您可以明确指定 tokenizer_detail::assign_or_plus_equal 的特化，以便您可以在每个部分字符串的开头添加每个字符，而不是结束。

希望这对您有所帮助。我会选择第一个替代方案，或者只是简单地更改我的要求，这样我就不需要反向迭代器了。