1

为了让自己熟悉 Boost.Proto，我正在尝试通过改编用户指南中的 TArray 示例来为固定但任意大小的浮点向量构建另一个表达式模板库。我要做的第一件事是定义我的向量类：

typedef double real;

// Forward-declare an expression wrapper
template<typename Expr>
struct vector_expr_wrapper; // line 13

class FPVector : vector_expr_wrapper< proto::terminal< FPVector >::type > { // line 16
public:
    FPVector() : numElements(0), elements(0) {}
    FPVector(size_t n) : numElements(n), elements(new real[n]) {}
    ~FPVector() { delete[] elements; }

    real& operator[](size_t i) { return elements[i]; }

    template<typename Expr>
    FPVector const& operator=(vector_expr_wrapper<Expr> vec_expr) {
        for(size_t i=0; i<numElements; i++) {
            elements[i] = vec_expr[i];
        }
        return *this;
    }

private:
    size_t numElements;
    real * elements;
};

vector_expr_wrapper还重载其以使用从终端返回的派生operator[]来评估自身。vector_contextproto::callable_contextvector[index]FPVector

当我编译我的代码并用一个非常简单的语句 ( a = b + c;) 调用它时，我收到错误消息：

../main.cpp:16:18: error: invalid use of incomplete type ‘struct vector_expr_wrapper<boost::proto::exprns_::expr<boost::proto::tagns_::tag::terminal, boost::proto::argsns_::term<FPVector>, 0l> >’
../main.cpp:13:8: error: declaration of ‘struct vector_expr_wrapper<boost::proto::exprns_::expr<boost::proto::tagns_::tag::terminal, boost::proto::argsns_::term<FPVector>, 0l> >’
../main.cpp: In function ‘int main()’:
../main.cpp:121:8: error: no match for ‘operator+’ in ‘b + c’

然后 g++ 列出了可能的候选者的东西......我从中理解的是，我必须在定义vector_expr_wrapper之前给出完整的定义，FPVector但我不能这样做，因为其他一切都vector_expr_wrapper取决于FPVector（语法，评估上下文......）

我该如何解决这个问题（即我应该如何布置我的课程）？

TArray 示例绕过了这个问题——我猜——通过非常晚地定义它们的数组类并用int[3]之前指定它的类型，我认为我无法在我的上下文中重现。

非常感谢您的帮助！

4

1 回答 1

2

这是我的解决方案：

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

namespace proto = boost::proto;
using proto::_;

typedef double real;

struct vector_grammar
  : proto::or_<
        proto::terminal< std::vector<real> >
      , proto::plus< vector_grammar, vector_grammar >
      , proto::minus< vector_grammar, vector_grammar >
      , proto::multiplies< vector_grammar, vector_grammar >
      , proto::divides< vector_grammar, vector_grammar >
    >
{};

template<typename Expr>
struct vector_expr;

// Tell proto that in the vector_domain, all
// expressions should be wrapped in vector_expr<> and
// must conform to the vector_grammar
struct vector_domain
  : proto::domain<
        // use_basic_expr here instructs proto to use the stripped-
        // down proto::basic_expr instead of proto::expr to reduce
        // compile times. It's not necessary.
        proto::use_basic_expr<proto::pod_generator<vector_expr> >
      , vector_grammar
    >
{};

struct vector_subscript_context
  : proto::callable_context< vector_subscript_context const >
{
    typedef real result_type;

    explicit vector_subscript_context(std::ptrdiff_t i)
      : i_(i)
    {}

    // Index array terminals with our subscript. Everything
    // else will be handled by the default evaluation context.
    real operator ()(proto::tag::terminal, std::vector<real> const &data) const
    {
        return data[this->i_];
    }

private:
    std::ptrdiff_t i_;
};

// Forward-declare an expression wrapper
template<typename Expr>
struct vector_expr
{
    BOOST_PROTO_BASIC_EXTENDS(Expr, vector_expr<Expr>, vector_domain)

    // Use the vector_subscript_context to implement subscripting
    // of a vector_expr expression tree.
    real operator []( std::ptrdiff_t i ) const
    {
        vector_subscript_context const ctx(i);
        return proto::eval(*this, ctx);
    }
};

template<typename = proto::is_proto_expr>
struct FPVector_
  : vector_expr<
        proto::basic_expr<
            proto::tag::terminal
          , proto::term< std::vector<real> >
        >
    >
{
    explicit FPVector_(std::size_t n = 0)
    {
        proto::value(*this).resize(n);
    }

    real & operator[](std::ptrdiff_t i)
    {
        return proto::value(*this)[i];
    }

    real const & operator[](std::ptrdiff_t i) const
    {
        return proto::value(*this)[i];
    }

    template<typename Expr>
    FPVector_ & operator=(vector_expr<Expr> const & that)
    {
        std::ptrdiff_t const size =
            static_cast<std::ptrdiff_t>(proto::value(*this).size());
        for(std::ptrdiff_t i = 0; i < size; ++i)
            proto::value(*this)[i] = that[i];
        return *this;
    }
};

typedef FPVector_<> FPVector;

int main()
{
    FPVector a(3), b(3), c(3);
    for(std::ptrdiff_t i = 0; i < 3; ++i)
        b[i] = c[i] = i;

    a = b + c;

    std::cout
        << boost::format("a = {%d, %d, %d}") % a[0] %a[1] %a[2]
        << std::endl; 
}

您显示的代码有许多问题：

// Forward-declare an expression wrapper
template<typename Expr>
struct vector_expr_wrapper; // line 13

class FPVector : vector_expr_wrapper< proto::terminal< FPVector >::type >

您不能vector_expr_wrapper从（具体）类（ ）继承不完整的类模板（ FPVector）。此外，您的FPVector类型正在尝试包含其自身的副本。proto::terminal是对象类型的包装器。将其视为事物本身的替代品，但带有一些额外的 Proto 香料。然后从它或从它继承的东西继承是行不通的。

我发布的代码中唯一真正的技巧是使用proto::is_proto_expr. 这是让 ADL 启动查找boost::proto命名空间中定义的运算符重载的令人讨厌的 hack。这件事在proto 文档的“扩展<>表达式包装器”部分底部的警告中有详细描述。

于 2013-08-21T19:00:26.280 回答