boost.proto +修改表达式树到位

时间:2012-08-25 13:01:00

标签: c++ boost template-meta-programming boost-proto

背景问题:boost.proto + detect invalid terminal before building the expression tree

嗨,我想要实现的是

  1. 创建表达式树的副本,其中所有向量都被替换 他们的开始迭代器(在我的例子中是一个原始指针)
  2. 增加迭代器的位置
  3. 取消引用树中的迭代器,但该部分应该相对容易。
  4. 所以,对于1.我最终得到了这段代码

    ///////////////////////////////////////////////////////////////////////////////
    // A transform that converts all vectors nodes in a tree to iterator nodes
    struct vector_begin : proto::transform <vector_begin>
    {
        template<typename Expr, typename Unused1, typename Unused2>
        struct impl : boost::proto::transform_impl<Expr, Unused1, Unused2>
        {
            // must strip away the reference qualifier (&)
            typedef typename proto::result_of::value<
                    typename boost::remove_reference<Expr>::type
                >::type vector_type;
    
            typedef typename proto::result_of::as_expr
                <typename vector_type::const_iterator>::type result_type;
    
            result_type operator ()(
                  typename impl::expr_param var
                , typename impl::state_param
                , typename impl::data_param) const
            {
                typename vector_type::const_iterator iter(proto::value(var).begin());
                return proto::as_expr(iter); // store iterator by value
            }
        };
    };
    
    struct vector_grammar_begin
            : proto::or_ <
                proto::when <vector_terminal, vector_begin>
                // scalars want to be stored by value (proto stores them by const &), if not the code does not compile... 
              , proto::when <scalar_terminal, boost::proto::_make_terminal(boost::proto::_byval(boost::proto::_value))>
                // descend the tree converting vectors to begin() iterators
              , proto::when <proto::nary_expr<_, proto::vararg<vector_grammar_begin> > >
            >
    {};
    

    以上成功创建了一个树,其中所有向量都被指针替换。到现在为止还挺好。现在,尝试增加 迭代器。我意识到推进迭代器会更好,所以只需一次转换,我就可以得到大部分 随机访问迭代器的行为(取消引用是另一个缺失的部分)。对于2.,所需的转换应该是

    ///////////////////////////////////////////////////////////////////////////////
    // A transform that advances all iterators in a tree
    struct iter_advance : proto::transform <iter_advance>
    {
        template<typename Expr, typename Index, typename Dummy>
        struct impl : boost::proto::transform_impl<Expr, Index, Dummy>
        {
            typedef void result_type;
            result_type operator ()(
                  typename impl::expr_param var
                , typename impl::state_param index // i'm using state to pass a data :(
                , typename impl::data_param) const
            {
                proto::value(var)+=index; // No good... compile error here :(
            }
        };
    };
    
    // Ok, this is brittle, what if I decide the change vector<D,T>'s iterator type ?
    struct iter_terminal
            :   proto::and_<
                    proto::terminal<_>
                 ,  proto::if_<boost::is_pointer<proto::_value>()> 
                >
    {};
    
    
    struct vector_grammar_advance
            : proto::or_ <
                proto::when <iter_terminal, iter_advance>
              , proto::terminal<_>
              , proto::when <proto::nary_expr<_, proto::vararg<vector_grammar_advance> > >
            >
    {};
    

    现在,在主要功能

    template <class Expr>
    void check_advance (Expr const &e)
    {
        proto::display_expr (e);
    
        typedef typename boost::result_of<vector_grammar_begin(Expr)>::type iterator_type;
        iterator_type iter = vector_grammar_begin()(e);
        proto::display_expr (iter);
    
        vector_grammar_advance ()(iter,1);
        proto::display_expr (iter);
     }
    
     int main (int, char**)
     {
        vec<3, double> a(1), b(2), c(3);
        check_advance(2*a+b/c);
        return 0;
     }
    

    我收到以下错误消息(过滤掉垃圾):

    array.cpp:361:13:错误:分配只读位置

    'boost::proto::value<boost::proto::exprns_::expr<boost::proto::tagns_::tag::terminal,
     boost::proto::argsns_::term<const double*>, 0l> >((* & var))'
    

    困扰我的是'((*&amp; var))'部分...无法理解如何解决这个问题。 提前致谢,最好的问候

    PS 不相关的事情:在玩转换后,我使用的一般模式是:

    1. 决定如何对树做什么
    2. 编写执行操作的原始变换
    3. 编写一个识别应该应用变换的语法,使用先前定义的变换
    4. 你认为这是合理的吗?我的意思是,执行一个单一的基本操作是很多代码 一种节点。使用上下文,可以同时定义多个操作,区分节点类型。 也可以通过变换来实现这一点吗?使用的一般模式是什么?

1 个答案:

答案 0 :(得分:4)

你的直觉是正确的;你应该能够就地改变树。我需要研究Proto的pass_through变换似乎有一些常见的古怪,所以解决方案有点不明显。首先,我定义了一些我将在Proto算法中使用的callables。我更喜欢callables到原始变换,因为它们更容易理解,更可重用,并且导致更容易阅读的Proto算法。

struct begin
  : proto::callable
{
    template<typename Sig>
    struct result;

    template<typename This, typename Rng>
    struct result<This(Rng)>
      : boost::range_iterator<Rng>
    {};

    template<typename This, typename Rng>
    struct result<This(Rng &)>
      : boost::range_iterator<Rng>
    {};

    template<typename Rng>
    typename boost::range_iterator<Rng>::type
    operator()(Rng &rng) const
    {
        return boost::begin(rng);
    }

    template<typename Rng>
    typename boost::range_iterator<Rng const>::type 
    operator()(Rng const &rng) const
    {
        return boost::begin(rng);
    }
};

struct advance
  : proto::callable
{
    typedef void result_type;

    template<typename Iter>
    void operator()(Iter &it, unsigned d) const
    {
        it += d;
    }
};

现在,我用一个简单的迭代器适配器来解决你的脆弱性问题:

template<typename Iter>
struct vector_iterator
  : boost::iterator_adaptor<vector_iterator<Iter>, Iter>
{
    vector_iterator()
      : boost::iterator_adaptor<vector_iterator<Iter>, Iter>()
    {}

    explicit vector_iterator(Iter iter)
      : boost::iterator_adaptor<vector_iterator<Iter>, Iter>(iter)
    {}

    friend std::ostream &operator<<(std::ostream &sout, vector_iterator it)
    {
        return sout << "vector_iterator(value: " << *it << " )";
    }
};

这是将包含向量的树转换为包含向量迭代器的树的算法。

// Turn all vector terminals into vector iterator terminals
struct vector_begin_algo
  : proto::or_<
        proto::when<
            proto::terminal<std::vector<_, _> >
          , proto::_make_terminal(
                vector_iterator<begin(proto::_value)>(begin(proto::_value))
            )
        >
      , proto::when<
            proto::terminal<_>
          , proto::_make_terminal(proto::_byval(proto::_value))
        >
      , proto::otherwise<
            proto::_byval(proto::nary_expr<_, proto::vararg<vector_begin_algo> >)
        >
    >
{};

不应该需要最后一个proto::_byvalpass_through使用的proto::nary_expr转换不应该创建const临时节点。对不起。

这是用于在适当位置推进所有迭代器的算法。当你完全理解这一点时,你将真正成为一名Proto大师。

// Mutate in-place by advancing all vector iterators the amount
// in the state parameter
struct vector_advance_algo
  : proto::or_<
        proto::when<
            proto::terminal<vector_iterator<_> >
          , advance(proto::_value, proto::_state)
        >
      , proto::when<
            proto::terminal<_>
          , proto::_void
        >
      , proto::otherwise<
            proto::and_<
                proto::fold<
                    _
                  , proto::_state
                  , proto::and_<
                        vector_advance_algo
                      , proto::_state
                    >
                >
              , proto::_void
            >
        >
    >
{};

了解上述内容的诀窍是:

  1. proto::_void不执行任何操作并返回void
  2. proto::and_,当用作这样的变换时,执行所有指定的变换并返回最后一个变换的结果。
  3. 毕竟,您现在可以执行您要执行的操作:将包含向量的树转换为包含迭代器的树,然后就地推进所有迭代器:

    proto::literal<std::vector<int> > vec1;
    proto::value(vec1).assign(
        boost::make_counting_iterator(0)
      , boost::make_counting_iterator(16)
    );
    
    auto beg = vector_begin_algo()(2 * vec1 + vec1);
    proto::display_expr(beg);
    
    vector_advance_algo()(beg, 1u);
    proto::display_expr(beg);
    
    vector_advance_algo()(beg, 1u);
    proto::display_expr(beg);
    

    我认为如果你没有遇到常见问题,你的代码会有用。另外,如果你编写普通的callables而不是原始的变换,我想你可能会有更轻松的时间。

    希望这有帮助。