私はBoost.Protoで遊んでいましたが、それは主に楽しみのためであり、将来、自分のプロジェクトでそれを利用できるかどうかを確認するためです。とは言うものの、おそらくこのライブラリのほとんどの初心者として、私は「レイジーベクトル」の例の修正バージョンで遊んだことがありますが、評価を実行するためにコンテキストの代わりに変換を使用しています。ベクトルは次のように定義されます（わかりました、私は知っています、「ベクトル」はグローバル名前空間スコープで定義されたものの良い名前ではありません...）
template <std::size_t D, class T>
class vector {
T data_[D];
enum { dimension = D };
// Constructors, destructors...
};
// expression wrapper
template <class> class vector_expr;
これは、ディメンションとデータ型に基づいてテンプレート化されており、boost :: arrayのようなものです（通常この種の方法で行われるように、operator =をオーバーロードして式ツリーを受け入れるため、これは使用しませんでした）。protoのマニュアルのコードを使用してスカラーを定義しました
// scalar = everything convertible to double
struct scalar_terminal :
proto::terminal<proto::convertible_to <double> >
{};
// vector = everything for which the is_vector returns true_
template <class T> struct is_vector : mpl::false_ {};
template <std::size_t D, class T> struct is_vector <vector <D, T> > : mpl::true_ {};
struct vector_terminal :
proto::and_ <
proto::terminal<_>
, proto::if_<is_vector<proto::_value>()>
>
{};
// domain
struct vector_domain
: proto::domain <proto::generator <vector_expr> >
{};
// expression wrapper
template <class Expr>
struct vector_expr : proto::extends <Expr, vector_expr <Expr>, vector_domain>
{
typedef proto::extends <Expr, vector_expr <Expr>, vector_domain> base_type;
// Construct from expression (enough to compile)
vector_expr (Expr const &e) : base_type (e) {}
};
// Bring in operators
BOOST_PROTO_DEFINE_OPERATORS(is_vector, vector_domain)
さて、私が最初にやりたかったことは、式のすべてのベクトル端子が同じ次元Dを持っているかどうかを確認することです。私は次の作業コードになりました。
// a meta-function that returns the vector dimension
template <class T>
struct vector_dim
{
typedef mpl::int_ <T::dimension> type;
};
// a meta-function that combines dimensions from subtrees. int<-1> means
// that sub-trees store vectors of differing static dimension. No good.
template <class D1, class D2>
struct dim_combine
{
typedef mpl::int_ < -1 > type;
};
// ok, dimensions are the same, propagate up the value
template <class D>
struct dim_combine <D, D>
{
typedef D type;
};
// 0 is used to mark scalars. It is ok to mix vectors and scalars
// but propagate up the vector dimension only. This is for vector
// on the left and scalar on the right.
template <class D>
struct dim_combine <D, mpl::int_ <0> >
{
typedef D type;
};
// this is for scalar on the left, vector to the right of some
// binary operator.
template <class D>
struct dim_combine <mpl::int_ <0>, D>
{
typedef D type;
};
// need this too to avoid ambiguity between the two specializations
// above when D is int_ <0>. Even if this combination should never
// happen
template <>
struct dim_combine <mpl::int_ <0>, mpl::int_<0> >
{
typedef mpl::int_<0> type;
};
// A transform that check that all arrays have the same dimension
struct vec_dim_check
: proto::or_ <
proto::when <
vector_terminal
, vector_dim<proto::_value>()
>
, proto::when <
scalar_terminal
, boost::mpl::int_<0>()
>
, proto::when <
proto::nary_expr<_, proto::vararg<_> >
, proto::fold<_, boost::mpl::int_<0>(), dim_combine<vec_dim_check, proto::_state>()>
>
>
{};
template <class E>
void check_dim (E const&)
{
typedef typename boost::result_of<vec_dim_check(E)>::type type;
BOOST_ASSERT(type::value == 3);
}
int main (int, char**)
{
vector <3,double> a,b,c;
check_dim (2*a+b/c);
return 0;
}
問題は、配列の次元がすでに式にエンコードされているため、コンパイル時にすでに無効な組み合わせを検出できるはずです。そもそもツリーの作成を回避することさえ可能であるはずです。これはどのように達成されますか？
よろしくお願いします