c++ - Boost.Proto:如何制作原始数组的表达式终端而不是 std::vector？

Question

现在我正在尝试为 vector 表达式制作另一种迷你 EDSL(嵌入式领域特定语言)。实际上，Boost.Proto 用户指南已经提供了这样一个 EDSL 示例，“Lazy Vector”，其中 vector 表达式由 std::vector<T> 组成。 .但是我必须改用原始数组的那些表达式。因为原始数组运算仍然是几个科学模拟程序的核心。

因此我添加了一个数组包装类，ArrayWrapper到那个“惰性 vector ”代码并替换为std::vector与 ArrayWrapper .此修改后的源代码已成功编译和链接。但是当我运行它时，核心被转储了。

这是源代码的修改版本:

//  The original version of this file is :
//  "Lazy Vector: Controlling Operator Overloads"
//  in Boost.Proto users' guide.
//  Copyright 2008 Eric Niebler. Distributed under the Boost
//  Software License, Version 1.0.
//
//  It was modified to try protofying a primitive array
//  on May 19 2015.

    #include <vector>
    #include <iostream>
    #include <boost/mpl/int.hpp>
    #include <boost/proto/core.hpp>
    #include <boost/proto/context.hpp>
    namespace mpl = boost::mpl;
    namespace proto = boost::proto;
    using proto::_;


    template <typename T>
    class ArrayWrapper {
    private:
        T* data;
        size_t size_;

    public:
        typedef T value_type;

        explicit ArrayWrapper(std::size_t size = 0, T const & value = T() ):
            data( new T[size]), size_(size) {
            for (std::size_t i = 0; i < size_; i++) data[i] = value;

        }       

        ~ArrayWrapper() {
            std::cerr << "Now destructing an ArrayWrapper" << std::endl;
            delete [] data;
        }

        std::size_t size() { return size_; }

        T& operator[](std::size_t i) { return data[i]; }
        T operator[](std::size_t i) const { return data[i]; }
    };


    template<typename Expr>
    struct lazy_vector_expr;

    // This grammar describes which lazy vector expressions
    // are allowed; namely, vector terminals and addition
    // and subtraction of lazy vector expressions.
    struct LazyVectorGrammar
      : proto::or_<
            proto::terminal< ArrayWrapper<_> >
          , proto::plus< LazyVectorGrammar, LazyVectorGrammar >
          , proto::minus< LazyVectorGrammar, LazyVectorGrammar >
        >
    {};

    // Tell proto that in the lazy_vector_domain, all
    // expressions should be wrapped in laxy_vector_expr<>
    // and must conform to the lazy vector grammar.
    struct lazy_vector_domain
      : proto::domain<proto::generator<lazy_vector_expr>, LazyVectorGrammar>
    {};

    // Here is an evaluation context that indexes into a lazy vector
    // expression, and combines the result.
    template<typename Size = std::size_t>
    struct lazy_subscript_context
    {
        lazy_subscript_context(Size subscript)
          : subscript_(subscript)
        {}

        // Use default_eval for all the operations ...
        template<typename Expr, typename Tag = typename Expr::proto_tag>
        struct eval
          : proto::default_eval<Expr, lazy_subscript_context>
        {};

        // ... except for terminals, which we index with our subscript
        template<typename Expr>
        struct eval<Expr, proto::tag::terminal>
        {
            typedef typename proto::result_of::value<Expr>::type::value_type result_type;

            result_type operator ()( Expr const & expr, lazy_subscript_context & ctx ) const
            {
                return proto::value( expr )[ ctx.subscript_ ];
            }
        };

        Size subscript_;
    };

    // Here is the domain-specific expression wrapper, which overrides
    // operator [] to evaluate the expression using the lazy_subscript_context.
    template<typename Expr>
    struct lazy_vector_expr
      : proto::extends<Expr, lazy_vector_expr<Expr>, lazy_vector_domain>
    {
        lazy_vector_expr( Expr const & expr = Expr() )
          : lazy_vector_expr::proto_extends( expr )
        {}

        // Use the lazy_subscript_context<> to implement subscripting
        // of a lazy vector expression tree.
        template< typename Size >
        typename proto::result_of::eval< Expr, lazy_subscript_context<Size> >::type
        operator []( Size subscript ) const
        {
            lazy_subscript_context<Size> ctx(subscript);
            return proto::eval(*this, ctx);
        }
    };

    // Here is our lazy_vector terminal, implemented in terms of lazy_vector_expr
    template< typename T >
    struct lazy_vector
      : lazy_vector_expr< typename proto::terminal< ArrayWrapper<T> >::type >
    {
        typedef typename proto::terminal< ArrayWrapper<T> >::type expr_type;

        lazy_vector( std::size_t size = 0, T const & value = T() )
          : lazy_vector_expr<expr_type>( expr_type::make( ArrayWrapper<T>(size, value) ) )
        {}

        // Here we define a += operator for lazy vector terminals that
        // takes a lazy vector expression and indexes it. expr[i] here
        // uses lazy_subscript_context<> under the covers.
        template< typename Expr >
        lazy_vector & operator += (Expr const & expr)
        {
            std::size_t size = proto::value(*this).size();
            for(std::size_t i = 0; i < size; ++i)
            {
                proto::value(*this)[i] += expr[i];
            }
            return *this;
        }
    };

    int main()
    {
        // lazy_vectors with 4 elements each.
        lazy_vector< double > v1( 4, 1.0 ), v2( 4, 2.0 ), v3( 4, 3.0 );

        // Add two vectors lazily and get the 2nd element.
        double d1 = ( v2 + v3 )[ 2 ];   // Look ma, no temporaries!
        std::cout << d1 << std::endl;

        // Subtract two vectors and add the result to a third vector.
        v1 += v2 - v3;                  // Still no temporaries!
        std::cout << '{' << v1[0] << ',' << v1[1]
                  << ',' << v1[2] << ',' << v1[3] << '}' << std::endl;

        // This expression is disallowed because it does not conform
        // to the LazyVectorGrammar
        //(v2 + v3) += v1;

        return 0;
    }

我想我的数组包装器类具有“惰性 vector ”程序的其余部分所需的所有必要成员函数。而且我认为那些成员函数的接口(interface)与std::vector的接口(interface)是一样的。原始“Lazy Vector”程序使用的成员函数。

可能我漏掉了一些重要的点。但是如何解决呢？ (我应该如何使用原始数组制作 proto::terminal<T> 对象？)如果您能给我建议或提示，我将不胜感激。

Answer 1

最后，我找到了一种方法来制作原始数组的表达式终端，从而为 vector 代数制作最小的 EDSL。它可以在初始化表达式模板的终端对象时抑制临时对象的多余拷贝。消除对象复制的关键是在 Vector 类 ' 中放置一个原始数组，为该 Vector 类定义一个返回 true 的特征，并使用 BOOST_PROTO_DEFINE_OPERATORS()。

这是源代码:

#include <iostream>
#include <boost/proto/proto.hpp>

namespace mpl = boost::mpl;
namespace proto = boost::proto;

// This grammar describes which vector expressions
// are allowed; namely, vector terminals and addition
// and subtraction of vector expressions.
struct VecGrammar : proto::or_<
    proto::terminal< proto::_ >,
    proto::plus< VecGrammar, VecGrammar>,
    proto::minus< VecGrammar, VecGrammar>
> {};


// The above grammar is associated with this domain.
template<typename Expr> struct VecExpr;
struct VecDomain
    : proto::domain<proto::generator<VecExpr>, VecGrammar> {};


//
// Context for evaluating an element of matrix expressions
//
struct SubscriptCntxt
    : proto::callable_context<const SubscriptCntxt> {
        typedef double result_type;

        int index;
        SubscriptCntxt(int index_) :  index(index_) {}

        // matrix element
        template<typename Vector>
        double operator()(proto::tag::terminal, const Vector& vec) const {
            return vec[index];
        }

        // addition of vector expression terms
        template<typename E1, typename E2>
        double operator()(proto::tag::plus, const E1& e1, const E2& e2) const {
            return proto::eval(e1, *this) + proto::eval(e2, *this);
        }

        // substraction of vector expression terms
        template<typename E1, typename E2>
        double operator()(proto::tag::minus, const E1& e1, const E2& e2) const {
            return proto::eval(e1, *this) - proto::eval(e2, *this);
        }
};


//
// Vector Expression Templates
//
template<typename Expr>
struct VecExpr
    : proto::extends<Expr, VecExpr<Expr>, VecDomain> {
        explicit VecExpr(const Expr& e)
            : proto::extends<Expr, VecExpr<Expr>, VecDomain>(e) {
        }

        // Use a SubscriptCntxt instance to implement subscripting
        // of a vector expression tree.
        typename proto::result_of::eval< Expr, SubscriptCntxt>::type
        operator [](int i) const {
            const SubscriptCntxt ctx(i);
            return proto::eval(*this, ctx);
        }
};

//
// Matrix data are stored in an heap array.
//
class Vector {
    private:
        int sz;
        double* data;

public:
    explicit Vector(int sz_ = 1, double iniVal = 0.0) :
        sz( sz_), data( new double[sz] ) {
        for (int i = 0; i < sz; i++) data[i] = iniVal;
        std::cout << "Created" << std::endl;
    }
    Vector(const Vector& vec) :
        sz( vec.sz), data( new double[sz] ) {
        for (int i = 0; i < sz; i++) data[i] = vec.data[i];
        std::cout << "Copied" << std::endl;
    }

    ~Vector() {
        delete [] data;
        std::cout << "Deleted" << std::endl;
    }

    // accesing to a vector element
    double& operator[](int i) { return data[i]; }
    const double& operator[](int i) const { return data[i]; }

    // assigning the lhs of a vector expression into this matrix
    template<typename Expr>
    Vector& operator=( const Expr& expr ) {
        for(int i=0; i < sz; ++i) {
                // evaluating the i'th element of a matrix expression
                const SubscriptCntxt ctx(i);
                data[i] = proto::eval(proto::as_expr<VecDomain>(expr), ctx);
        }
        return *this;
    }

    // assigning and adding the lhs of a vector expression into this matrix
    template<typename Expr>
    Vector& operator+=( const Expr& expr ) {
        for(int i=0; i < sz; ++i) {
                // evaluating the (i,j) element of a matrix expression
                const SubscriptCntxt ctx(i);
                data[i] += proto::eval(proto::as_expr<VecDomain>(expr), ctx);
        }
        return *this;
    }
};


// Define a trait for detecting vector terminals, to be used
// by the BOOST_PROTO_DEFINE_OPERATORS macro below.
template<typename> struct IsVector : mpl::false_ {};
template<> struct IsVector<Vector> : mpl::true_  {};



namespace VectorOps {
    // This defines all the overloads to make expressions involving
    // Vector objects to build expression templates.
    BOOST_PROTO_DEFINE_OPERATORS(IsVector, VecDomain)
}

int main()
{
    using namespace VectorOps;

    // lazy_vectors with 4 elements each.
    Vector v1( 4, 1.0 ), v2( 4, 2.0 ), v3( 4, 3.0 );

    // Add two vectors lazily and get the 2nd element.
    double d1 = ( v2 + v3 )[ 2 ];   // Look ma, no temporaries!
    std::cout << d1 << std::endl;

    // Subtract two vectors and add the result to a third vector.
    v1 += v2 - v3;                  // Still no temporaries!
    std::cout << '{' << v1[0] << ',' << v1[1]
              << ',' << v1[2] << ',' << v1[3] << '}' << std::endl;

    // This expression is disallowed because it does not conform
    // to the LazyVectorGrammar
    //(v2 + v3) += v1;

    return 0;
}

我确认此代码有效并且输出与 Boost.Proto 用户指南中的“Lazy Vector”示例几乎相同。

虽然我仍然不确定 Boost.Proto 的内部情况如何，但使用它制作 EDSL 原型(prototype)非常有趣。