Boost C++ 库

获取 Proto

您可以通过下载 Boost（Proto 在 1.37 及更高版本中）或访问 SourceForge.net 上的 Boost SVN 存储库来获取 Proto。只需访问 http://svn.boost.org/trac/boost/wiki/BoostSubversion 并按照那里的说明进行匿名 SVN 访问。

使用 Proto 构建

Proto 是一个仅头文件的模板库，这意味着您无需更改构建脚本或链接到任何单独的 lib 文件即可使用它。您只需执行 #include <boost/proto/proto.hpp> 即可。或者，您可能决定只包含 Proto 的核心 (#include <boost/proto/core.hpp>) 以及您恰好使用的任何上下文和转换。

要求

Proto 依赖于 Boost。您必须使用 Boost 版本 1.34.1 或更高版本，或者 SVN trunk 中的版本。

支持的编译器

目前，已知 Boost.Proto 在以下编译器上工作

	注意
	请将任何问题、意见和错误报告发送至 eric <at> boostpro <dot> com。

Proto 是一个大型库，可能与您以前使用过的任何库都非常不同。Proto 使用一些一致的命名约定，以便于导航，下面将对此进行描述。

函数

Proto 的所有函数都在 boost::proto 命名空间中定义。例如，在 boost::proto 中定义了一个名为 value() 的函数，它接受一个终结符表达式并返回终结符的值。

元函数

Proto 定义了与 Proto 的每个自由函数相对应的元函数。元函数用于计算函数的返回类型。Proto 的所有元函数都位于 boost::proto::result_of 命名空间中，并且与它们对应的函数具有相同的名称。例如，有一个类模板 boost::proto::result_of::value<>，您可以使用它来计算 boost::proto::value() 函数的返回类型。

函数对象

Proto 定义了所有自由函数的函数对象等价物。（函数对象是定义 operator() 成员函数的类类型的实例。）Proto 的所有函数对象类型都在 boost::proto::functional 命名空间中定义，并且与其对应的自由函数具有相同的名称。例如，boost::proto::functional::value 是一个类，它定义了一个函数对象，该对象执行与 boost::proto::value() 自由函数相同的事情。

原始转换

Proto 还定义了原始转换——可用于组合更大的转换以操作表达式树的类类型。Proto 的许多自由函数都有相应的原始转换。这些都位于 boost::proto 命名空间中，并且它们的名称带有前导下划线。例如，与 value() 函数对应的转换称为 boost::proto::_value。

下表总结了以上讨论

下面是一个非常简单的程序，它使用 Proto 构建表达式模板，然后执行它。

#include <iostream>
#include <boost/proto/proto.hpp>
#include <boost/typeof/std/ostream.hpp>
using namespace boost;

proto::terminal< std::ostream & >::type cout_ = { std::cout };

template< typename Expr >
void evaluate( Expr const & expr )
{
    proto::default_context ctx;
    proto::eval(expr, ctx);
}

int main()
{
    evaluate( cout_ << "hello" << ',' << " world" );
    return 0;
}

该程序输出以下内容

hello, world

该程序构建一个表示输出操作的对象，并将其传递给 evaluate() 函数，然后该函数执行它。

表达式模板的基本思想是重载所有运算符，以便它们不是立即评估表达式，而是构建表达式的树状表示，以便稍后可以对其进行评估。对于表达式中的每个运算符，必须至少对一个操作数进行 Proto 化，以便找到 Proto 的运算符重载。在表达式中...

cout_ << "hello" << ',' << " world"

... Proto 化的子表达式是 cout_，它是 std::cout 的 Proto 化。 cout_ 的存在“感染”了表达式，并将 Proto 的树构建运算符重载纳入考虑范围。表达式中的任何字面量都通过将它们包装在 Proto 终结符中进行 Proto 化，然后在将它们组合成更大的 Proto 表达式。

一旦 Proto 的运算符重载构建了表达式树，就可以通过遍历树来延迟评估表达式。这就是 proto::eval() 所做的事情。它是一个通用的树遍历表达式评估器，其行为可通过上下文参数自定义。proto::default_context 的使用为表达式中的运算符分配了标准含义。（通过使用不同的上下文，您可以为表达式中的运算符赋予不同的语义。默认情况下，Proto 不会对运算符的实际含义做任何假设。）

Proto 设计理念

在我们继续之前，让我们使用上面的示例来说明 Proto 的一个重要的设计原则。在hello world示例中创建的表达式模板是完全通用和抽象的。它不以任何方式绑定到任何特定的领域或应用程序，并且它本身没有任何特定的含义或行为，除非它在上下文中进行评估。表达式模板实际上只是异构树，它们在一个领域中可能意味着某种东西，而在另一个领域中则完全意味着其他东西。

正如我们稍后将看到的，有一种方法可以创建不是纯粹抽象的 Proto 表达式树，并且这些树具有独立于任何上下文的含义和行为。还有一种方法可以控制为您的特定领域重载哪些运算符。但这不是默认行为。稍后我们将看到为什么默认通常是一件好事。

“Hello, world”很好，但它并没有让您走得太远。让我们使用 Proto 为延迟评估的计算器构建 EDSL（嵌入式领域特定语言）。我们将看到如何定义您的迷你语言中的终结符，如何将它们组合成更大的表达式，以及如何定义评估上下文，以便您的表达式可以执行有用的工作。完成之后，我们将拥有一个迷你语言，该语言将允许我们声明一个延迟评估的算术表达式，例如 (_2 - _1) / _2 * 100，其中 _1 和 _2 是在评估表达式时要传入的值的占位符。

定义终结符

首要任务是定义占位符 _1 和 _2。为此，我们将使用 proto::terminal<> 元函数。

// Define a placeholder type
template<int I>
struct placeholder
{};

// Define the Protofied placeholder terminals
proto::terminal<placeholder<0> >::type const _1 = {{}};
proto::terminal<placeholder<1> >::type const _2 = {{}};

初始化乍一看可能有点奇怪，但是这样做是有充分理由的。上面的对象 _1 和 _2 不需要运行时构造——它们是静态初始化的，这意味着它们本质上是在编译时初始化的。有关更多信息，请参见静态初始化部分中的原理附录。

构建表达式树

现在我们有了终结符，我们可以使用 Proto 的运算符重载将这些终结符组合成更大的表达式。因此，例如，我们可以立即说出类似以下内容

// This builds an expression template
(_2 - _1) / _2 * 100;

这将创建一个表达式树，其中每个运算符都有一个节点。结果对象的类型很大且复杂，但是我们现在对此并不太感兴趣。

到目前为止，该对象只是一棵表示表达式的树。它没有行为。特别是，它还不是计算器。下面我们将看到如何通过定义评估上下文使其成为计算器。

评估表达式树

毫无疑问，您希望您的表达式模板实际做一些事情。一种方法是定义评估上下文。上下文就像一个函数对象，它将行为与表达式树中的节点类型相关联。以下示例应使其清晰明了。下面对其进行了解释。

struct calculator_context
  : proto::callable_context< calculator_context const >
{
    // Values to replace the placeholders
    std::vector<double> args;

    // Define the result type of the calculator.
    // (This makes the calculator_context "callable".)
    typedef double result_type;

    // Handle the placeholders:
    template<int I>
    double operator()(proto::tag::terminal, placeholder<I>) const
    {
        return this->args[I];
    }
};

在 calculator_context 中，我们通过定义函数调用运算符的适当重载来指定 Proto 应如何评估占位符终结符。对于表达式树中的任何其他节点（例如，算术运算或非占位符终结符），Proto 将以“默认”方式评估表达式。例如，二进制加法节点的评估方式是首先评估左右操作数，然后将结果相加。Proto 的默认评估器使用 Boost.Typeof 库来计算返回类型。

现在我们有了计算器的评估上下文，我们可以使用它来评估我们的算术表达式，如下所示

calculator_context ctx;
ctx.args.push_back(45); // the value of _1 is 45
ctx.args.push_back(50); // the value of _2 is 50

// Create an arithmetic expression and immediately evaluate it
double d = proto::eval( (_2 - _1) / _2 * 100, ctx );

// This prints "10"
std::cout << d << std::endl;

稍后，我们将看到如何定义更有趣的评估上下文和表达式转换，这些上下文和转换使您可以完全控制表达式的评估方式。

自定义表达式树

我们的计算器 EDSL 已经非常有用，对于许多 EDSL 场景，不再需要更多功能。但是让我们继续。想象一下，如果所有计算器表达式都重载了 operator()，以便可以将它们用作函数对象，那将有多好。我们可以通过创建一个计算器域并告知 Proto 计算器域中的所有表达式都具有额外的成员来做到这一点。以下是如何定义计算器域

// Forward-declare an expression wrapper
template<typename Expr>
struct calculator;

// Define a calculator domain. Expression within
// the calculator domain will be wrapped in the
// calculator<> expression wrapper.
struct calculator_domain
  : proto::domain< proto::generator<calculator> >
{};

calculator<> 类型将是一个表达式包装器。它的行为将与它包装的表达式完全相同，但是它将具有我们将定义的额外成员函数。 calculator_domain 是告知 Proto 关于我们的包装器的内容。它在下面的 calculator<> 的定义中使用。请继续阅读以获取描述。

// Define a calculator expression wrapper. It behaves just like
// the expression it wraps, but with an extra operator() member
// function that evaluates the expression.    
template<typename Expr>
struct calculator
  : proto::extends<Expr, calculator<Expr>, calculator_domain>
{
    typedef
        proto::extends<Expr, calculator<Expr>, calculator_domain>
    base_type;

    calculator(Expr const &expr = Expr())
      : base_type(expr)
    {}

    typedef double result_type;

    // Overload operator() to invoke proto::eval() with
    // our calculator_context.
    double operator()(double a1 = 0, double a2 = 0) const
    {
        calculator_context ctx;
        ctx.args.push_back(a1);
        ctx.args.push_back(a2);

        return proto::eval(*this, ctx);
    }
};

calculator<> 结构是一个表达式扩展。它使用 proto::extends<> 来有效地向表达式类型添加其他成员。当从较小的表达式组合成较大的表达式时，Proto 会记录较小的表达式所属的域。较大的表达式位于同一域中，并自动包装在域的扩展包装器中。

剩下要做的就是将我们的占位符放在计算器域中。我们通过将它们包装在我们的 calculator<> 包装器中来做到这一点，如下所示

// Define the Protofied placeholder terminals, in the
// calculator domain.
calculator<proto::terminal<placeholder<0> >::type> const _1;
calculator<proto::terminal<placeholder<1> >::type> const _2;

任何包含这些占位符的较大表达式都将自动包装在 calculator<> 包装器中，并具有我们的 operator() 重载。这意味着我们可以像下面这样将它们用作函数对象。

double result = ((_2 - _1) / _2 * 100)(45.0, 50.0);
assert(result == (50.0 - 45.0) / 50.0 * 100));

由于计算器表达式现在是有效的函数对象，因此我们可以将它们与标准算法一起使用，如下所示

double a1[4] = { 56, 84, 37, 69 };
double a2[4] = { 65, 120, 60, 70 };
double a3[4] = { 0 };

// Use std::transform() and a calculator expression
// to calculate percentages given two input sequences:
std::transform(a1, a1+4, a2, a3, (_2 - _1) / _2 * 100);

现在，让我们使用计算器示例来探索 Proto 的其他一些有用的功能。

检测无效表达式

您可能已经注意到，您不必定义重载的 operator-() 或 operator/() —— Proto 为您定义了它们。实际上，Proto 为您重载了所有运算符，即使它们在您的领域特定语言中可能没有任何意义。这意味着可能会创建在您的域中无效的表达式。您可以使用 Proto 通过定义您的领域特定语言的语法来检测无效表达式。

为简单起见，假设我们的计算器 EDSL 仅应允许加法、减法、乘法和除法。涉及任何其他运算符的任何表达式均无效。使用 Proto，我们可以通过定义计算器 EDSL 的语法来说明此要求。它看起来如下

// Define the grammar of calculator expressions
struct calculator_grammar
  : proto::or_<
        proto::plus< calculator_grammar, calculator_grammar >
      , proto::minus< calculator_grammar, calculator_grammar >
      , proto::multiplies< calculator_grammar, calculator_grammar >
      , proto::divides< calculator_grammar, calculator_grammar >
      , proto::terminal< proto::_ >
    >
{};

您可以将上面的语法理解为：如果表达式树是二进制加法、减法、乘法或除法节点，其中两个子节点也符合计算器语法；或者，如果它是终结符，则表达式树符合计算器语法。在 Proto 语法中，proto::_ 是一个通配符，它匹配任何类型，因此 proto::terminal< proto::_ > 匹配任何终结符，无论是占位符还是字面量。

	注意
	此语法实际上比我们希望的要宽松一些。只有可转换为 double 的占位符和字面量才是有效的终结符。稍后我们将看到如何在 Proto 语法中表达类似的内容。

定义 EDSL 的语法后，您可以使用 proto::matches<> 元函数来检查给定的表达式类型是否符合语法。例如，我们可能会将以下内容添加到我们的 calculator::operator() 重载中

template<typename Expr>
struct calculator
  : proto::extends< /* ... as before ... */ >
{
    /* ... */
    double operator()(double a1 = 0, double a2 = 0) const
    {
        // Check here that the expression we are about to
        // evaluate actually conforms to the calculator grammar.
        BOOST_MPL_ASSERT((proto::matches<Expr, calculator_grammar>));
        /* ... */
    }
};

BOOST_MPL_ASSERT() 行的添加在编译时强制执行，我们只评估符合计算器 EDSL 语法的表达式。使用 Proto 语法、 proto::matches<> 和 BOOST_MPL_ASSERT()，当 EDSL 的用户不小心误用您的 EDSL 时，很容易为他们提供简短且可读的编译时错误。

	注意
	BOOST_MPL_ASSERT() 是 Boost 元编程库的一部分。要使用它，只需 #include <boost/mpl/assert.hpp>。

控制运算符重载

语法和 proto::matches<> 使检测用户何时创建了无效表达式并发出编译时错误成为可能。但是，如果您想从一开始就阻止用户创建无效表达式怎么办？通过将语法和域一起使用，您可以禁用任何会创建无效表达式的 Proto 运算符重载。这就像在定义域时指定 EDSL 的语法一样简单，如下所示

// Define a calculator domain. Expression within
// the calculator domain will be wrapped in the
// calculator<> expression wrapper.
// NEW: Any operator overloads that would create an
//      expression that does not conform to the
//      calculator grammar is automatically disabled.
struct calculator_domain
  : proto::domain< proto::generator<calculator>, calculator_grammar >
{};

我们唯一更改的是，在定义 calculator_domain 时，我们将 calculator_grammar 添加为 proto::domain<> 模板的第二个模板参数。通过这个简单的添加，我们禁用了任何会创建无效计算器表达式的 Proto 运算符重载。

... 以及更多

希望这能让您了解 Proto 可以为您做哪些事情。但这只是冰山一角。本用户指南的其余部分将更详细地描述所有这些功能和其他功能。

祝您元编程愉快！

正如我们在简介中的计算器示例中看到的那样，启动并运行 EDSL 的最简单方法是简单地定义一些终结符，如下所示。

// Define a literal integer Proto expression.
proto::terminal<int>::type i = {0};

// This creates an expression template.
i + 1;

借助一些终结符和 Proto 的运算符重载，您可以立即开始创建表达式模板。

定义终结符——使用聚合初始化——有时可能有点笨拙。Proto 为字面量提供了一个更易于使用的包装器，该包装器可用于构造 Proto 化的终结符表达式。它被称为 proto::literal<>。

// Define a literal integer Proto expression.
proto::literal<int> i = 0;

// Proto literals are really just Proto terminal expressions.
// For example, this builds a Proto expression template:
i + 1;

还有一个 proto::lit() 函数，用于就地构造 proto::literal<>。上面的表达式可以简单地写成

// proto::lit(0) creates an integer terminal expression
proto::lit(0) + 1;

一旦我们有了一些 Proto 终结符，涉及这些终结符的表达式就会为我们构建表达式树。Proto 为 C++ 的每个可重载运算符在 boost::proto 命名空间中定义了重载。只要一个操作数是 Proto 表达式，运算的结果就是一个表示该运算的树节点。

	注意
	Proto 的运算符重载位于 boost::proto 命名空间中，并通过 ADL（实参依赖查找）找到。这就是为什么表达式必须被 Proto 特性“污染”，Proto 才能能够从表达式中构建树。

由于 Proto 的运算符重载，我们可以说

-_1;        // OK, build a unary-negate tree node
_1 + 42;    // OK, build a binary-plus tree node

在大多数情况下，这“开箱即用”，您无需考虑它，但少数运算符是特殊的，了解 Proto 如何处理它们可能会有所帮助。

赋值、下标和函数调用运算符

Proto 也重载了 operator=、 operator[] 和 operator()，但这些运算符是表达式模板的成员函数，而不是 Proto 命名空间中的自由函数。以下是有效的 Proto 表达式

_1 = 5;     // OK, builds a binary assign tree node
_1[6];      // OK, builds a binary subscript tree node
_1();       // OK, builds a unary function tree node
_1(7);      // OK, builds a binary function tree node
_1(8,9);    // OK, builds a ternary function tree node
// ... etc.

对于前两行，赋值和下标，结果表达式节点应该是二元的，这应该不足为奇。毕竟，每个表达式中都有两个操作数。起初可能会令人惊讶的是，看起来像是没有参数的函数调用 _1() 实际上创建了一个带有一个子节点的表达式节点。子节点是 _1 本身。同样，表达式 _1(7) 有两个子节点：_1 和 7。

由于这些运算符只能定义为成员函数，因此以下表达式无效

int i;
i = _1;         // ERROR: cannot assign _1 to an int

int *p;
p[_1];          // ERROR: cannot use _1 as an index

std::sin(_1);   // ERROR: cannot call std::sin() with _1

此外，C++ 对 operator-> 的重载有特殊的规则，这使得它对于构建表达式模板毫无用处，因此 Proto 不会重载它。

取地址运算符

Proto 为表达式类型重载了取地址运算符，因此以下代码创建了一个新的 unary address-of 树节点

&_1;    // OK, creates a unary address-of tree node

它不返回 _1 对象的地址。但是，Proto 中有特殊的代码，使得 unary address-of 节点可以隐式转换为指向其子节点的指针。换句话说，以下代码可以工作，并且可以达到您可能期望的效果，但方式并非显而易见

typedef
    proto::terminal< placeholder<0> >::type
_1_type;

_1_type const _1 = {{}};
_1_type const * p = &_1; // OK, &_1 implicitly converted

如果我们将自己限制在仅使用终端和运算符重载，那么我们的嵌入式领域特定语言就不会很有表现力。想象一下，我们想用全套数学函数（如 sin() 和 pow()）扩展我们的计算器 EDSL，我们可以像下面这样惰性地调用它们。

// A calculator expression that takes one argument
// and takes the sine of it.
sin(_1);

我们希望以上代码创建一个表示函数调用的表达式模板。当评估该表达式时，它应该导致函数被调用。（至少，这是我们希望计算器 EDSL 具有的函数调用的含义。）您可以非常简单地将 sin 定义如下。

// "sin" is a Proto terminal containing a function pointer
proto::terminal< double(*)(double) >::type const sin = {&std::sin};

在上面，我们将 sin 定义为包含指向 std::sin() 函数的指针的 Proto 终端。现在我们可以将 sin 用作惰性函数。我们在导言中看到的 default_context 知道如何评估惰性函数。考虑以下代码

double pi = 3.1415926535;
proto::default_context ctx;
// Create a lazy "sin" invocation and immediately evaluate it
std::cout << proto::eval( sin(pi/2), ctx ) << std::endl;

以上代码打印出

1

我不是三角学专家，但这在我看来是正确的。

我们可以写 sin(pi/2)，因为 sin 对象（它是 Proto 终端）具有重载的 operator()()，它构建一个表示函数调用的节点。sin(pi/2) 的实际类型实际上是这样的

// The type of the expression sin(pi/2):
proto::function<
    proto::terminal< double(*)(double) >::type const &
    proto::result_of::as_child< double const >::type
>::type

此类型进一步扩展为一个难看的节点类型，其 tag 类型为 proto::tag::function，并且有两个子节点：第一个表示要调用的函数，第二个表示函数的参数。（节点标签类型描述了创建节点的操作。a + b 和 a - b 之间的区别在于前者具有标签类型 proto::tag::plus，后者具有标签类型 proto::tag::minus。标签类型是纯编译时信息。）

	注意
	在上面的类型计算中，proto::result_of::as_child<> 是一个元函数，它确保其参数是 Proto 表达式类型。如果它还不是，它将变成 Proto 终端。我们将更多地了解这个元函数，以及它的运行时对应物 proto::as_child()，稍后会学习。现在，您可以忘记它。

重要的是要注意，包含函数指针的终端没有任何特别之处。任何 Proto 表达式都具有重载的函数调用运算符。考虑

// This compiles!
proto::lit(1)(2)(3,4)(5,6,7,8);

乍一看可能很奇怪。它使用 proto::lit() 创建一个整数终端，然后像函数一样一遍又一遍地调用它。这是什么意思？谁知道呢？！您可以决定何时定义评估上下文或转换。但更多内容稍后介绍。

创建惰性函数，续

现在，如果我们想在我们的计算器 EDSL 中添加一个 pow() 函数，用户可以像下面这样调用它，该怎么办？

// A calculator expression that takes one argument
// and raises it to the 2nd power
pow< 2 >(_1);

上面描述的将 pow 作为包含函数指针的终端的简单技术在这里不起作用。如果 pow 是一个对象，那么表达式 pow< 2 >(_1) 不是有效的 C++。（好吧，从技术上讲它是；它的意思是，pow 小于 2，大于 (_1)，这根本不是我们想要的。）pow 应该是一个真正的函数模板。但它必须是一个不寻常的函数：一个返回表达式模板的函数。

对于 sin，我们依靠 Proto 提供重载的 operator()() 来为我们构建一个标签类型为 proto::tag::function 的表达式节点。现在我们需要自己这样做。和以前一样，该节点将有两个子节点：要调用的函数和函数的参数。

对于 sin，要调用的函数是一个原始函数指针，它被包装在 Proto 终端中。在 pow 的情况下，我们希望它是一个包含 TR1 风格函数对象的终端。这将允许我们根据指数来参数化函数。下面是 std::pow 函数的简单 TR1 风格包装器的实现

// Define a pow_fun function object
template< int Exp >
struct pow_fun
{
    typedef double result_type;

    double operator()(double d) const
    {
        return std::pow(d, Exp);
    }
};

按照 sin 示例，我们希望 pow< 1 >( pi/2 ) 具有这样的类型

// The type of the expression pow<1>(pi/2):
proto::function<
    proto::terminal< pow_fun<1> >::type
    proto::result_of::as_child< double const >::type
>::type

我们可以使用类似这样的代码编写 pow() 函数，但这很冗长且容易出错；很容易因为忘记在必要时调用 proto::as_child() 而引入细微的错误，从而导致代码看起来可以工作，但有时却不行。Proto 提供了一种更好的构建表达式节点的方法：proto::make_expr()。

使用 make_expr() 简化惰性函数

Proto 提供了一个用于构建表达式模板的助手，称为 proto::make_expr()。我们可以使用它简洁地定义 pow() 函数，如下所示。

// Define a lazy pow() function for the calculator EDSL.
// Can be used as: pow< 2 >(_1)
template< int Exp, typename Arg >
typename proto::result_of::make_expr<
    proto::tag::function  // Tag type
  , pow_fun< Exp >        // First child (by value)
  , Arg const &           // Second child (by reference)
>::type const
pow(Arg const &arg)
{
    return proto::make_expr<proto::tag::function>(
        pow_fun<Exp>()    // First child (by value)
      , boost::ref(arg)   // Second child (by reference)
    );
}

关于上面的代码，需要注意一些事项。我们使用 proto::result_of::make_expr<> 来计算返回类型。第一个模板参数是我们正在构建的表达式节点的标签类型——在本例中为 proto::tag::function。

proto::result_of::make_expr<> 的后续模板参数表示子节点。如果子类型还不是 Proto 表达式，它将自动使用 proto::as_child() 变为终端。诸如 pow_fun<Exp> 之类的类型会产生按值保存的终端，而诸如 Arg const & 之类的类型（请注意引用）表明结果应按引用保存。

在函数体中是 proto::make_expr() 的运行时调用。它紧密地反映了返回类型计算。proto::make_expr() 要求您将节点的标签类型指定为模板参数。函数的参数成为节点的子节点。当子节点应按值存储时，无需执行任何特殊操作。当子节点应按引用存储时，您必须使用 boost::ref() 函数包装参数。

就是这样！proto::make_expr() 是懒人创建惰性函数的方式。

在本节中，我们将全面学习域。特别是，我们将学习

double data[] = {1., 2., 3., 4.};

// Use the calculator EDSL to square each element ... HOW?
std::transform( data, data + 4, data, _1 * _1 );

extends<> 表达式包装器

赋予您的计算器表达式额外行为的第一步是定义一个计算器域。计算器域中的所有表达式都将充满计算器特性，我们稍后会看到。

// A type to be used as a domain tag (to be defined below)
struct calculator_domain;

当扩展 proto::expr<> 类型时，我们使用此域类型，我们使用 proto::extends<> 类模板来完成此操作。这是我们的表达式包装器，它为表达式注入了计算器特性。下面将对其进行描述。

// The calculator<> expression wrapper makes expressions
// function objects.
template< typename Expr >
struct calculator
  : proto::extends< Expr, calculator< Expr >, calculator_domain >
{
    typedef
        proto::extends< Expr, calculator< Expr >, calculator_domain >
    base_type;

    calculator( Expr const &expr = Expr() )
      : base_type( expr )
    {}

    // This is usually needed because by default, the compiler-
    // generated assignment operator hides extends<>::operator=
    BOOST_PROTO_EXTENDS_USING_ASSIGN(calculator)

    typedef double result_type;

    // Hide base_type::operator() by defining our own which
    // evaluates the calculator expression with a calculator context.
    result_type operator()( double d1 = 0.0, double d2 = 0.0 ) const
    {
        // As defined in the Hello Calculator section.
        calculator_context ctx;

        // ctx.args is a vector<double> that holds the values
        // with which we replace the placeholders (e.g., _1 and _2)
        // in the expression.
        ctx.args.push_back( d1 ); // _1 gets the value of d1
        ctx.args.push_back( d2 ); // _2 gets the value of d2

        return proto::eval(*this, ctx ); // evaluate the expression
    }
};

我们希望计算器表达式是函数对象，因此我们必须定义一个接受并返回 doubles 的 operator()。calculator<> 上面的包装器借助 proto::extends<> 模板来实现这一点。proto::extends<> 的第一个模板参数是我们正在扩展的表达式类型。第二个是包装表达式的类型。第三个参数是此包装器关联的域。像 calculator<> 这样的包装器类型，它继承自 proto::extends<>，其行为就像它扩展的表达式类型一样，并带有您选择赋予它的任何其他行为。

	注意
	为什么不直接从 proto::expr<> 继承？ 您可能会认为这种表达式扩展业务不必要地复杂化了。毕竟，这不正是 C++ 支持继承的原因吗？为什么 calculator<Expr> 不能直接从 Expr 继承？原因是 Expr，它大概是 proto::expr<> 的实例化，具有表达式模板构建运算符重载，对于派生类型而言，这些重载将是不正确的。它们将通过引用将 *this 存储到 proto::expr<>，有效地切掉任何派生部分。proto::extends<> 为您的派生类型提供运算符重载，这些重载不会切掉您的其他成员。

尽管在本例中不是绝对必要的，但我们使用 BOOST_PROTO_EXTENDS_USING_ASSIGN() 宏将 extends<>::operator= 带入作用域。只有当您希望像 _1 = 3 这样的表达式创建惰性评估的赋值时，这才是真正必要的。proto::extends<> 为您定义了合适的 operator=，但编译器生成的 calculator<>::operator= 将隐藏它，除非您使用宏使其可用。

请注意，在 calculator<>::operator() 的实现中，我们使用我们之前定义的 calculator_context 评估表达式。正如我们之前看到的，上下文是赋予运算符含义的东西。对于计算器，上下文也是定义占位符终端含义的东西。

现在我们已经定义了 calculator<> 表达式包装器，我们需要包装占位符以赋予它们计算器特性

calculator< proto::terminal< placeholder<0> >::type > const _1;
calculator< proto::terminal< placeholder<1> >::type > const _2;

使用 BOOST_PROTO_EXTENDS() 保留 POD 特性

要使用 proto::extends<>，您的扩展类型必须派生自 proto::extends<>。不幸的是，这意味着您的扩展类型不再是 POD，并且其实例不能静态初始化。（有关原因，请参阅 静态初始化 部分中的 原理 附录。）特别是，如上所述，全局占位符对象 _1 和 _2 将需要在运行时初始化，这可能会导致细微的初始化顺序错误。

还有另一种方法可以进行表达式扩展，而不会牺牲 POD 特性：BOOST_PROTO_EXTENDS() 宏。您可以像使用 proto::extends<> 一样使用它。我们可以使用 BOOST_PROTO_EXTENDS() 使 calculator<> 保持 POD，并使我们的占位符静态初始化。

// The calculator<> expression wrapper makes expressions
// function objects.
template< typename Expr >
struct calculator
{
    // Use BOOST_PROTO_EXTENDS() instead of proto::extends<> to
    // make this type a Proto expression extension.
    BOOST_PROTO_EXTENDS(Expr, calculator<Expr>, calculator_domain)

    typedef double result_type;

    result_type operator()( double d1 = 0.0, double d2 = 0.0 ) const
    {
        /* ... as before ... */
    }
};

使用新的 calculator<> 类型，我们可以重新定义我们的占位符以进行静态初始化

calculator< proto::terminal< placeholder<0> >::type > const _1 = {{{}}};
calculator< proto::terminal< placeholder<1> >::type > const _2 = {{{}}};

我们需要进行一个额外的微小更改以适应表达式扩展的 POD 特性，我们将在下面关于表达式生成器的部分中进行描述。

BOOST_PROTO_EXTENDS() 做什么？它定义了正在扩展的表达式类型的数据成员；Proto 所需的一些嵌套 typedef；用于构建表达式模板的 operator=、 operator[] 和 operator() 重载；以及用于计算 operator() 返回类型的嵌套 result<> 模板。但是，在这种情况下，不需要 operator() 重载和 result<> 模板，因为我们在 calculator<> 类型中定义了自己的 operator()。Proto 提供了额外的宏，可以更精细地控制定义哪些成员函数。我们可以按如下方式改进我们的 calculator<> 类型

// The calculator<> expression wrapper makes expressions
// function objects.
template< typename Expr >
struct calculator
{
    // Use BOOST_PROTO_BASIC_EXTENDS() instead of proto::extends<> to
    // make this type a Proto expression extension:
    BOOST_PROTO_BASIC_EXTENDS(Expr, calculator<Expr>, calculator_domain)

    // Define operator[] to build expression templates:
    BOOST_PROTO_EXTENDS_SUBSCRIPT()

    // Define operator= to build expression templates:
    BOOST_PROTO_EXTENDS_ASSIGN()

    typedef double result_type;

    result_type operator()( double d1 = 0.0, double d2 = 0.0 ) const
    {
        /* ... as before ... */
    }
};

请注意，我们现在使用的是 BOOST_PROTO_BASIC_EXTENDS() 而不是 BOOST_PROTO_EXTENDS()。这仅添加数据成员和嵌套 typedef，但不添加任何重载运算符。这些运算符分别通过 BOOST_PROTO_EXTENDS_ASSIGN() 和 BOOST_PROTO_EXTENDS_SUBSCRIPT() 添加。我们省略了函数调用运算符和嵌套的 result<> 模板，这些模板可以使用 Proto 的 BOOST_PROTO_EXTENDS_FUNCTION() 宏来定义。

总而言之，以下是您可以用来定义表达式扩展的宏，以及每个宏的简要说明。

表 30.2. 表达式扩展宏

宏	目的
BOOST_PROTO_BASIC_EXTENDS( expression , extension , domain )	定义类型为 expression 的数据成员和 Proto 所需的一些嵌套 typedef。
BOOST_PROTO_EXTENDS_ASSIGN()	定义 operator=。仅当前面有 BOOST_PROTO_BASIC_EXTENDS() 时才有效。
BOOST_PROTO_EXTENDS_SUBSCRIPT()	定义 operator[]。仅当前面有 BOOST_PROTO_BASIC_EXTENDS() 时才有效。
BOOST_PROTO_EXTENDS_FUNCTION()	定义 operator() 和用于返回类型计算的嵌套 result<> 模板。仅当前面有 BOOST_PROTO_BASIC_EXTENDS() 时才有效。
BOOST_PROTO_EXTENDS( expression , extension , domain )	等效于 BOOST_PROTO_BASIC_EXTENDS(expression, extension, domain) BOOST_PROTO_EXTENDS_ASSIGN() BOOST_PROTO_EXTENDS_SUBSCRIPT() BOOST_PROTO_EXTENDS_FUNCTION()

警告

Argument-Dependent Lookup 和 BOOST_PROTO_EXTENDS() Proto 的运算符重载在 boost::proto 命名空间中定义，并通过 argument-dependent lookup (ADL) 找到。这通常可以正常工作，因为表达式由位于 boost::proto 命名空间中的类型组成。但是，有时当您使用 BOOST_PROTO_EXTENDS() 时，情况并非如此。考虑 template<class T> struct my_complex { BOOST_PROTO_EXTENDS( typename proto::terminal<std::complex<T> >::type , my_complex<T> , proto::default_domain ) }; int main() { my_complex<int> c0, c1; c0 + c1; // ERROR: operator+ not found } 问题与 argument-dependent lookup 的工作方式有关。my_complex<int> 类型未以任何方式与 boost::proto 命名空间关联，因此未考虑在那里定义的运算符。（如果我们从 proto::extends<> 继承而不是使用 BOOST_PROTO_EXTENDS()，我们将避免该问题，因为从 boost::proto 命名空间中的类型继承足以让 ADL 开始工作。） 那么我们能做什么呢？通过添加一个额外的虚拟模板参数，该参数默认为 boost::proto 命名空间中的类型，我们可以欺骗 ADL 找到正确的运算符重载。解决方案如下所示 template<class T, class Dummy = proto::is_proto_expr> struct my_complex { BOOST_PROTO_EXTENDS( typename proto::terminal<std::complex<T> >::type , my_complex<T> , proto::default_domain ) }; int main() { my_complex<int> c0, c1; c0 + c1; // OK, operator+ found now! } 类型 proto::is_proto_expr 只是一个空结构体，但是通过使其成为模板参数，我们使 boost::proto 成为 my_complex<int> 的关联命名空间。现在 ADL 可以成功找到 Proto 的运算符重载。

// Define the calculator_domain we forward-declared above.
// Specify that all expression in this domain should be wrapped
// in the calculator<> expression wrapper.
struct calculator_domain
  : proto::domain< proto::generator< calculator > >
{};

// If calculator<> uses BOOST_PROTO_EXTENDS() instead of 
// use proto::extends<>, use proto::pod_generator<> instead
// of proto::generator<>.
struct calculator_domain
  : proto::domain< proto::pod_generator< calculator > >
{};

double data[] = {1., 2., 3., 4.};

// Use the calculator EDSL to square each element ... WORKS! :-)
std::transform( data, data + 4, data, _1 * _1 );

// Define the grammar of calculator expressions
struct calculator_grammar
  : proto::or_<
        proto::plus< calculator_grammar, calculator_grammar >
      , proto::minus< calculator_grammar, calculator_grammar >
      , proto::multiplies< calculator_grammar, calculator_grammar >
      , proto::divides< calculator_grammar, calculator_grammar >
      , proto::terminal< proto::_ >
    >
{};

// Define the calculator_domain. Expressions in the calculator
// domain are wrapped in the calculator<> wrapper, and they must
// conform to the calculator_grammar:
struct calculator_domain
  : proto::domain< proto::generator< calculator >, calculator_grammar  >
{};

// For expressions in my_domain, disable Proto's
// unary address-of operator.
struct my_domain
  : proto::domain<
        proto::generator< my_wrapper >
        // A simple grammar that matches any expression that
        // is not a unary address-of expression.
      , proto::not_< proto::address_of< _ > >
    >
{};

控制子表达式的捕获方式

	注意
	这是一个高级主题。 如果您刚开始使用 Proto，请随意跳过此部分。

Proto 的运算符重载从子表达式构建表达式。 子表达式成为新表达式的子项。 默认情况下，子项通过引用存储在父项中。 本节介绍如何更改该默认设置。

入门：as_child 与 as_expr

Proto 允许您独立自定义 proto::as_child() 和 proto::as_expr() 的行为。 两者都接受对象 x，并通过在必要时将 x 转换为 Proto 终端来返回 Proto 表达式。 虽然相似，但这两种函数在不同的情况下使用，并且默认情况下具有细微不同的行为。 重要的是要了解差异，以便您知道要自定义哪个函数以实现您想要的行为。

例如：proto::as_expr() 通常由您使用，将对象转换为要保存在局部变量中的 Proto 表达式，如下所示

auto l = proto::as_expr(x); // Turn x into a Proto expression, hold the result in a local

无论 x 是否已经是 Proto 表达式，上述方法都有效。 对象 l 保证是有效的 Proto 表达式。 如果 x 是非 Proto 对象，则会将其转换为终端表达式，该表达式按值保存 x。^[28] 如果 x 已经是 Proto 对象，则 proto::as_expr()按值返回它，且不进行修改。

相反，proto::as_child() 由 Proto 内部使用，用于在将对象作为另一个表达式的子项之前对其进行预处理。 由于它是 Proto 内部的，因此您不会显式看到它，但它在幕后存在于如下表达式中

x + y; // Consider that y is a Proto expression, but x may or may not be.

在这种情况下，Proto 从两个子项构建一个加法节点。 两者都在传递给 proto::as_child() 之后进行预处理，然后再将它们作为新节点的子项。 如果 x 不是 Proto 表达式，则它会通过包装在 Proto 终端中而成为 Proto 表达式，该终端通过引用保存它。 如果 x 已经是 Proto 表达式，则 proto::as_child()通过引用返回它，且不进行修改。 将此与上面对 proto::as_expr() 的描述进行对比。

下表总结了上述描述。

表 30.3. proto::as_expr() 与 proto::as_child()

函数	当 t 不是 Proto 表达式时...	当 t 是 Proto 表达式时...
proto::as_expr(t)	（按值）返回一个新的 Proto 终端，该终端t按值保存。	（按值）返回 t，不进行修改。
proto::as_child(t)	（按值）返回一个新的 Proto 终端，该终端t按引用保存。	（按引用）返回 t，不进行修改。

	注意
	Proto 在一个重要的地方同时使用 as_expr和 as_child：proto::make_expr()。 proto::make_expr() 函数要求您为每个子项指定是按值还是按引用保存。 Proto 使用 proto::as_expr() 预处理要按值保存的子项，并使用 proto::as_child() 预处理要按引用保存的子项。

现在您知道了 proto::as_child() 和 proto::as_expr() 是什么，它们在何处使用，以及它们的默认行为是什么，您可能会认为对于您的域，其中一个或两个函数应该具有不同的行为。 例如，给定上面对 proto::as_child() 的描述，以下代码始终是错误的

proto::literal<int> i(0);
auto l = i + 42; // This is WRONG! Don't do this.

为什么这是错误的？ 因为 proto::as_child() 会将整数文字 42 转换为 Proto 终端，该终端保存对使用 42 初始化的临时整数的引用。 该临时变量的生命周期在分号处结束，从而保证局部变量 l 留下对已死亡整数的悬空引用。 该怎么办？ 一种答案是使用 proto::deep_copy()。 另一种是为您的域自定义 proto::as_child() 的行为。 请继续阅读以了解详细信息。

按域 as_child

要控制 Proto 如何在您的域中从子表达式构建表达式，请像往常一样定义您的域，然后在其中定义嵌套的 as_child<> 类模板，如下所示

class my_domain
  : proto::domain< my_generator, my_grammar >
{
    // Here is where you define how Proto should handle
    // sub-expressions that are about to be glommed into
    // a larger expression.
    template< typename T >
    struct as_child
    {
        typedef unspecified-Proto-expr-type result_type;

        result_type operator()( T & t ) const
        {
            return unspecified-Proto-expr-object;
        }
    };
};

有一件重要的事情需要注意：在上面的代码中，模板参数 T 可能是也可能不是 Proto 表达式类型，但结果必须是 Proto 表达式类型，或对其中一个的引用。 这意味着大多数用户定义的 as_child<> 模板将需要检查 T 是否是表达式（使用 proto::is_expr<>），然后通过将非表达式包装为 proto::terminal< /* ... */ >::type 或等效项来将其转换为 Proto 终端。

按域 as_expr

虽然不太常见，但 Proto 也允许您在每个域的基础上自定义 proto::as_expr() 的行为。 该技术与 as_child 的技术相同。 见下文

class my_domain
  : proto::domain< my_generator, my_grammar >
{
    // Here is where you define how Proto should handle
    // objects that are to be turned into expressions
    // fit for storage in local variables.
    template< typename T >
    struct as_expr
    {
        typedef unspecified-Proto-expr-type result_type;

        result_type operator()( T & t ) const
        {
            return unspecified-Proto-expr-object;
        }
    };
};

使 Proto 表达式 auto 安全

让我们再次看看上面描述的问题，其中涉及 C++11 auto 关键字和 proto::as_child() 的默认行为。

proto::literal<int> i(0);
auto l = i + 42; // This is WRONG! Don't do this.

回想一下，问题是为保存值 42 而创建的临时整数的生命周期。 局部变量 l 在其生命周期结束后将留下对其的悬空引用。 如果我们希望 Proto 使表达式可以安全地以这种方式存储在局部变量中怎么办？ 我们可以通过使 proto::as_child() 的行为与 proto::as_expr() 完全一样来非常轻松地做到这一点。 以下代码实现了这一点

template< typename E >
struct my_expr;

struct my_generator
  : proto::pod_generator< my_expr >
{};

struct my_domain
  : proto::domain< my_generator >
{
     // Make as_child() behave like as_expr() in my_domain.
     // (proto_base_domain is a typedef for proto::domain< my_generator >
     // that is defined in proto::domain<>.)
     template< typename T >
     struct as_child
       : proto_base_domain::as_expr< T >
     {};
};

template< typename E >
struct my_expr
{
    BOOST_PROTO_EXTENDS( E, my_expr< E >, my_domain )
};

/* ... */

proto::literal< int, my_domain > i(0);
auto l = i + 42; // OK! Everything is stored by value here.

请注意，my_domain::as_child<> 只是延迟到 proto::domain<> 中找到的 as_expr<> 的默认实现。 通过简单地交叉连接我们域的 as_child<> 到 as_expr<>，我们保证所有可以按值保存的终端都按值保存，并且所有子表达式也都按值保存。 这会增加复制，并可能导致运行时性能成本，但它消除了任何生命周期管理问题的幽灵。

有关另一个示例，请参见 libs/proto/example/lambda.hpp 中 lldomain 的定义。 该示例是在 Boost.Proto 之上对 Boost Lambda Library (BLL) 的完整重新实现。 BLL 生成的函数对象可以安全地存储在局部变量中。 为了使用 Proto 模拟这一点，lldomain 将 as_child<> 交叉连接到 as_expr<>，如上所述，但有一个额外的转折：数组类型的对象也按引用存储。 看看吧。

EDSL 互操作性：子域

	注意
	这是一个高级主题。 如果您刚开始使用 Proto，请随意跳过此部分。

能够组合不同的 EDSL 是它们最令人兴奋的功能之一。 考虑一下如何使用 yacc 构建解析器。 您使用 yacc 的特定于域的语言编写语法规则。 然后，您将用 C 编写的语义动作嵌入到语法中。 Boost 的 Spirit 解析器生成器为您提供了相同的功能。 您使用 Spirit.Qi 编写语法规则，并使用 Phoenix 库嵌入语义动作。 Phoenix 和 Spirit 都是基于 Proto 的特定于域的语言，它们具有自己独特的语法和语义。 但是您可以自由地将 Phoenix 表达式嵌入到 Spirit 表达式中。 本节介绍 Proto 的子域功能，该功能使您可以定义可互操作的域族。

对决域

当您尝试从不同域中的两个子表达式创建表达式时，结果表达式的域是什么？ 这是子域解决的基本问题。 考虑以下代码

#include <boost/proto/proto.hpp>
namespace proto = boost::proto;

// Forward-declare two expression wrappers
template<typename E> struct spirit_expr;
template<typename E> struct phoenix_expr;

// Define two domains
struct spirit_domain  : proto::domain<proto::generator<spirit_expr> > {};
struct phoenix_domain : proto::domain<proto::generator<phoenix_expr> > {};

// Implement the two expression wrappers
template<typename E>
struct spirit_expr
  : proto::extends<E, spirit_expr<E>, spirit_domain>
{
    spirit_expr(E const &e = E()) : spirit_expr::proto_extends(e) {}
};

template<typename E>
struct phoenix_expr
  : proto::extends<E, phoenix_expr<E>, phoenix_domain>
{
    phoenix_expr(E const &e = E()) : phoenix_expr::proto_extends(e) {}
};

int main()
{
    proto::literal<int, spirit_domain> sp(0);
    proto::literal<int, phoenix_domain> phx(0);

    // Whoops! What does it mean to add two expressions in different domains?
    sp + phx; // ERROR
}

上面，我们定义了两个名为 spirit_domain 和 phoenix_domain 的域，并在每个域中声明了两个 int 字面量。 然后，我们尝试使用 Proto 的二元加运算符将它们组合成更大的表达式，但失败了。 Proto 无法确定结果表达式应该在 Spirit 域还是 Phoenix 域中，因此无法确定它应该是 spirit_expr<> 还是 phoenix_expr<> 的实例。 我们必须告诉 Proto 如何解决冲突。 我们可以通过声明 Phoenix 是 Spirit 的子域来做到这一点，如下面的 phoenix_domain 定义所示

// Declare that phoenix_domain is a sub-domain of spirit_domain
struct phoenix_domain
  : proto::domain<proto::generator<phoenix_expr>, proto::_, spirit_domain>
{};

proto::domain<> 的第三个模板参数是超域。 通过如上定义 phoenix_domain，我们表示 Phoenix 表达式可以与 Spirit 表达式组合，并且当这种情况发生时，结果表达式应该是 Spirit 表达式。

	注意
	如果您想知道上面 phoenix_domain 的定义中 proto::_ 的用途是什么，请回想一下 proto::domain<> 的第二个模板参数是域的语法。 “proto::_” 是默认值，表示该域对其中有效的表达式没有限制。

域解析

当给定表达式中存在多个域时，Proto 使用一些规则来确定哪个域“胜出”。 这些规则大致模仿 C++ 继承的规则。 Phoenix_domain 是 spirit_domain 的子域。 您可以将它比作派生/基类关系，这种关系使 Phoenix 表达式可以隐式转换为 Spirit 表达式。 并且由于 Phoenix 表达式可以“转换”为 Spirit 表达式，因此它们可以与 Spirit 表达式自由组合，结果是 Spirit 表达式。

	注意
	超域和子域实际上不是使用继承来实现的。 这只是一种有用的心理模型。

即使在三个域的情况下，当两个域是第三个域的子域时，与继承的类比也成立。 想象一下另一个名为 foobar_domain 的域，它也是 spirit_domain 的子域。 foobar_domain 中的表达式可以与 phoenix_domain 中的表达式组合，结果表达式将在 spirit_domain 中。 这是因为两个子域中的表达式都“转换”为超域，因此允许该操作，并且超域胜出。

默认域

当您不将 Proto 表达式分配给特定域时，Proto 会将其视为所谓的默认域 proto::default_domain 的成员。 甚至非 Proto 对象也被视为默认域中的终端。 考虑

int main()
{
    proto::literal<int, spirit_domain> sp(0);

    // Add 1 to a spirit expression. Result is a spirit expression.
    sp + 1;
}

默认域中的表达式（或像 1 这样的非表达式）可以隐式转换为每个其他域类型的表达式。 更重要的是，您可以将您的域定义为默认域的子域。 这样做，您可以使您域中的表达式转换为每个其他域中的表达式。 这就像一个“自由恋爱”域，因为它将与其他所有域自由混合。

让我们再次考虑 Phoenix EDSL。 由于它提供了通用的 lambda 功能，因此可以合理地假设除了 Spirit 之外的许多其他 EDSL 可能也希望能够嵌入 Phoenix 表达式。 换句话说，phoenix_domain 应该是 proto::default_domain 的子域，而不是 spirit_domain

// Declare that phoenix_domain is a sub-domain of proto::default_domain
struct phoenix_domain
  : proto::domain<proto::generator<phoenix_expr>, proto::_, proto::default_domain>
{};

这样就好多了。 Phoenix 表达式现在可以放在任何地方。

子域摘要

使用 Proto 子域使混合来自多个域的表达式成为可能。 当您希望您域中的表达式与所有表达式自由组合时，请将其设为 proto::default_domain 的子域。

前面关于定义 Proto 前端的讨论都做了一个很大的假设：您有从头开始定义一切的奢侈。 如果您有现有类型，例如矩阵类型和向量类型，并且您想将它们视为 Proto 终端，该怎么办？ Proto 通常只处理其自己的表达式类型，但是使用 BOOST_PROTO_DEFINE_OPERATORS()，它也可以容纳您的自定义终端类型。

例如，假设您有以下类型，并且您无法修改它们以使其成为“原生” Proto 终端类型。

namespace math
{
    // A matrix type ...
    struct matrix { /*...*/ };

    // A vector type ...
    struct vector { /*...*/ };
}

您可以使用 BOOST_PROTO_DEFINE_OPERATORS() 定义适当的运算符重载，以非侵入方式使这些类型的对象成为 Proto 终端。 基本步骤如下

以下代码演示了它的工作原理。

namespace math
{
    template<typename T>
    struct is_terminal
      : mpl::false_
    {};

    // OK, "matrix" is a custom terminal type
    template<>
    struct is_terminal<matrix>
      : mpl::true_
    {};

    // OK, "vector" is a custom terminal type
    template<>
    struct is_terminal<vector>
      : mpl::true_
    {};

    // Define all the operator overloads to construct Proto
    // expression templates, treating "matrix" and "vector"
    // objects as if they were Proto terminals.
    BOOST_PROTO_DEFINE_OPERATORS(is_terminal, proto::default_domain)
}

调用 BOOST_PROTO_DEFINE_OPERATORS() 宏定义了一整套运算符重载，这些重载将 matrix 和 vector 对象视为 Proto 终端。 并且由于运算符是在与 matrix 和 vector 类型相同的命名空间中定义的，因此运算符将通过依赖于参数的查找找到。 使用上面的代码，我们现在可以使用矩阵和向量构造表达式模板，如下所示。

math::matrix m1;
math::vector v1;
proto::literal<int> i(0);

m1 * 1;  // custom terminal and literals are OK
m1 * i;  // custom terminal and Proto expressions are OK
m1 * v1; // two custom terminals are OK, too.

有时，作为 EDSL 设计人员，为了让您的用户轻松生活，您必须让自己的生活变得艰难。 为用户提供自然而灵活的语法通常涉及编写大量重复的函数重载。 这足以给您带来重复性劳损！ 在您伤害自己之前，请查看 Proto 提供的用于自动化许多重复代码生成工作的宏。

想象一下，我们正在编写一个 lambda EDSL，并且我们希望启用使用以下语法构造任何类型的临时对象的语法

// A lambda expression that takes two arguments and
// uses them to construct a temporary std::complex<>
construct< std::complex<int> >( _1, _2 )

为了便于讨论，假设我们已经有一个函数对象模板 construct_impl<>，它接受参数并从中构造新对象。 我们希望上面的 lambda 表达式等效于以下内容

// The above lambda expression should be roughly equivalent
// to the following:
proto::make_expr<proto::tag::function>(
    construct_impl<std::complex<int> >() // The function to invoke lazily
  , boost::ref(_1)                       // The first argument to the function
  , boost::ref(_2)                       // The second argument to the function
);

我们可以将我们的 construct() 函数模板定义如下

template<typename T, typename A0, typename A1>
typename proto::result_of::make_expr<
    proto::tag::function
  , construct_impl<T>
  , A0 const &
  , A1 const &
>::type const
construct(A0 const &a0, A1 const &a1)
{
    return proto::make_expr<proto::tag::function>(
        construct_impl<T>()
      , boost::ref(a0)
      , boost::ref(a1)
    );
}

这适用于两个参数，但我们希望它适用于任意数量的参数，最多为 (BOOST_PROTO_MAX_ARITY - 1)。 （为什么是“- 1”？ 因为一个子项被 construct_impl<T>() 终端占用，只剩下 (BOOST_PROTO_MAX_ARITY - 1) 个其他子项的空间。）

对于这种情况，Proto 提供了 BOOST_PROTO_REPEAT() 和 BOOST_PROTO_REPEAT_FROM_TO() 宏。 要使用它，我们将上面的函数定义转换为宏，如下所示

#define M0(N, typename_A, A_const_ref, A_const_ref_a, ref_a)  \
template<typename T, typename_A(N)>                           \
typename proto::result_of::make_expr<                         \
    proto::tag::function                                      \
  , construct_impl<T>                                         \
  , A_const_ref(N)                                            \
>::type const                                                 \
construct(A_const_ref_a(N))                                   \
{                                                             \
    return proto::make_expr<proto::tag::function>(            \
        construct_impl<T>()                                   \
      , ref_a(N)                                              \
    );                                                        \
}

请注意，我们将该函数转换为一个宏，该宏接受 5 个参数。 第一个是当前的迭代次数。 其余的是生成不同序列的其他宏的名称。 例如，Proto 将宏的名称作为第二个参数传递，该宏将扩展为 typename A0, typename A1, ...。

现在我们已经将我们的函数转换为宏，我们可以将该宏传递给 BOOST_PROTO_REPEAT_FROM_TO()。 Proto 将迭代调用它，为我们生成所有函数重载。

// Generate overloads of construct() that accept from
// 1 to BOOST_PROTO_MAX_ARITY-1 arguments:
BOOST_PROTO_REPEAT_FROM_TO(1, BOOST_PROTO_MAX_ARITY, M0)
#undef M0

非默认序列

如上所述，Proto 将宏的名称作为最后 4 个参数传递给您的宏，这些宏生成各种序列。 宏 BOOST_PROTO_REPEAT() 和 BOOST_PROTO_REPEAT_FROM_TO() 为这些参数选择默认值。 如果默认值不能满足您的需求，则可以使用 BOOST_PROTO_REPEAT_EX() 和 BOOST_PROTO_REPEAT_FROM_TO_EX() 并传递生成不同序列的不同宏。 Proto 定义了许多此类宏，用作 BOOST_PROTO_REPEAT_EX() 和 BOOST_PROTO_REPEAT_FROM_TO_EX() 的参数。 查看 boost/proto/repeat.hpp 的参考部分，以获取所有详细信息。

另外，请查看 BOOST_PROTO_LOCAL_ITERATE()。 它的工作方式类似于 BOOST_PROTO_REPEAT() 及其友元，但是当您想要更改一个宏参数并接受其他参数的默认值时，它可能更容易使用。

将表达式组装成树后，您自然会希望能够反过来操作，并访问节点的子节点。您甚至可能希望能够使用 Boost.Fusion 库中的算法迭代子节点。本节将展示如何实现。

获取表达式标签和元数

表达式树中的每个节点都具有一个描述节点的标签类型，以及一个对应于其子节点数量的元数。您可以使用 proto::tag_of<> 和 proto::arity_of<> 元函数来获取它们。考虑以下示例

template<typename Expr>
void check_plus_node(Expr const &)
{
    // Assert that the tag type is proto::tag::plus
    BOOST_STATIC_ASSERT((
        boost::is_same<
            typename proto::tag_of<Expr>::type
          , proto::tag::plus
        >::value
    ));

    // Assert that the arity is 2
    BOOST_STATIC_ASSERT( proto::arity_of<Expr>::value == 2 );
}

// Create a binary plus node and use check_plus_node()
// to verify its tag type and arity:
check_plus_node( proto::lit(1) + 2 );

对于给定的类型 Expr，您可以直接访问标签和元数，分别为 Expr::proto_tag 和 Expr::proto_arity，其中 Expr::proto_arity 是一个 MPL 整型常量。

获取终端值

没有比终端更简单的表达式，也没有比提取其值更基本的操作了。正如我们已经看到的，这就是 proto::value() 的用途。

proto::terminal< std::ostream & >::type cout_ = {std::cout};

// Get the value of the cout_ terminal:
std::ostream & sout = proto::value( cout_ );

// Assert that we got back what we put in:
assert( &sout == &std::cout );

要计算 proto::value() 函数的返回类型，您可以使用 proto::result_of::value<>。当 proto::result_of::value<> 的参数是非引用类型时，元函数的结果类型是适合按值存储的值的类型；也就是说，顶层引用和限定符会被剥离。但是，当使用引用类型实例化时，结果类型会添加一个引用，从而产生适合按引用存储的类型。如果您想知道终端值的实际类型，包括它是按值存储还是按引用存储，您可以使用 fusion::result_of::value_at<Expr, 0>::type。

下表总结了以上段落的内容。

typename boost::remove_const<
    typename boost::remove_reference<T>::type
>::type [a]

typename boost::add_reference<T>::type

typename boost::add_reference<
    typename boost::add_const<T>::type
>::type

获取子表达式

表达式树中的每个非终端节点都对应于表达式中的一个运算符，而子节点对应于操作数或运算符的参数。要访问它们，您可以使用 proto::child_c() 函数模板，如下所示

proto::terminal<int>::type i = {42};

// Get the 0-th operand of an addition operation:
proto::terminal<int>::type &ri = proto::child_c<0>( i + 2 );

// Assert that we got back what we put in:
assert( &i == &ri );

您可以使用 proto::result_of::child_c<> 元函数来获取表达式节点的第 N 个子节点的类型。通常，您不关心子节点是按值存储还是按引用存储，因此当您请求表达式 Expr（其中 Expr 不是引用类型）的第 N 个子节点的类型时，您将获得从子节点的类型中剥离引用和 cv 限定符后的类型。

template<typename Expr>
void test_result_of_child_c(Expr const &expr)
{
    typedef typename proto::result_of::child_c<Expr, 0>::type type;

    // Since Expr is not a reference type,
    // result_of::child_c<Expr, 0>::type is a
    // non-cv qualified, non-reference type:
    BOOST_MPL_ASSERT((
        boost::is_same< type, proto::terminal<int>::type >
    ));
}

// ...
proto::terminal<int>::type i = {42};
test_result_of_child_c( i + 2 );

但是，如果您请求 Expr & 或 Expr const &（注意引用）的第 N 个子节点的类型，则结果类型将是一个引用，无论子节点实际上是按引用存储还是按值存储。如果您需要确切地知道子节点是如何存储在节点中的，无论是按引用还是按值，您可以使用 fusion::result_of::value_at<Expr, N>::type。下表总结了 proto::result_of::child_c<> 元函数的行为。

typename boost::remove_const<
    typename boost::remove_reference<T>::type
>::type

typename boost::add_reference<T>::type

typename boost::add_reference<
    typename boost::add_const<T>::type
>::type

常用快捷方式

C++ 中的大多数运算符都是一元或二元的，因此访问唯一的操作数，或左操作数和右操作数是非常常见的操作。因此，Proto 提供了 proto::child()、proto::left() 和 proto::right() 函数。proto::child() 和 proto::left() 与 proto::child_c<0>() 同义，而 proto::right() 与 proto::child_c<1>() 同义。

还有 proto::result_of::child<>、proto::result_of::left<> 和 proto::result_of::right<> 元函数，它们只是转发到其对应的 proto::result_of::child_c<>。

当您使用 Proto 构建表达式模板时，所有中间子节点都通过引用持有。这避免了不必要的复制，如果您希望您的 EDSL 在运行时表现良好，这一点至关重要。当然，如果临时对象在您尝试评估表达式模板之前超出作用域，则存在危险。在 C++0x 中，使用新的 decltype 和 auto 关键字时，这个问题尤其突出。考虑以下情况

// OOPS: "ex" is left holding dangling references
auto ex = proto::lit(1) + 2;

如果您使用 BOOST_TYPEOF() 或 BOOST_AUTO()，或者如果您尝试将表达式模板传递到其组成部分的作用域之外，那么在今天的 C++ 中也可能发生这个问题。

在这些情况下，您需要深度复制您的表达式模板，以便所有中间节点和终端都按值持有。这样，您可以安全地将表达式模板分配给局部变量或从函数返回它，而无需担心悬空引用。您可以使用 proto::deep_copy() 来执行此操作，如下所示

// OK, "ex" has no dangling references
auto ex = proto::deep_copy( proto::lit(1) + 2 );

如果您正在使用 Boost.Typeof，它看起来会像这样

// OK, use BOOST_AUTO() and proto::deep_copy() to
// store an expression template in a local variable 
BOOST_AUTO( ex, proto::deep_copy( proto::lit(1) + 2 ) );

为了使上面的代码工作，您必须包含 boost/proto/proto_typeof.hpp 头文件，该文件还定义了 BOOST_PROTO_AUTO() 宏，该宏会自动深度复制其参数。使用 BOOST_PROTO_AUTO()，上面的代码可以写成

// OK, BOOST_PROTO_AUTO() automatically deep-copies
// its argument: 
BOOST_PROTO_AUTO( ex, proto::lit(1) + 2 );

当深度复制表达式树时，所有中间节点和所有终端都按值存储。唯一的例外是函数引用终端，它们会被保留原样。

	注意
	proto::deep_copy() 对数组没有例外，它会按值存储数组。这可能会导致大量数据被复制。

Proto 提供了一个实用程序，用于美观地打印表达式树，当您尝试调试 EDSL 时，它非常方便。它被称为 proto::display_expr()，您可以将要打印的表达式传递给它，并可选择传递一个 std::ostream 以将输出发送到该流。考虑以下示例

// Use display_expr() to pretty-print an expression tree
proto::display_expr(
    proto::lit("hello") + 42
);

上面的代码将以下内容写入 std::cout

plus(
    terminal(hello)
  , terminal(42)
)

为了调用 proto::display_expr()，表达式中的所有终端都必须是可流化的（即可写入 std::ostream）。此外，标签类型也必须都是可流化的。这是一个包含自定义终端类型和自定义标签的示例

// A custom tag type that is Streamable
struct MyTag
{
    friend std::ostream &operator<<(std::ostream &s, MyTag)
    {
        return s << "MyTag";
    }
};

// Some other Streamable type
struct MyTerminal
{
    friend std::ostream &operator<<(std::ostream &s, MyTerminal)
    {
        return s << "MyTerminal";
    }
};

int main()
{
    // Display an expression tree that contains a custom
    // tag and a user-defined type in a terminal
    proto::display_expr(
        proto::make_expr<MyTag>(MyTerminal()) + 42
    );
}

上面的代码打印以下内容

plus(
    MyTag(
        terminal(MyTerminal)
    )
  , terminal(42)
)

下表列出了可重载的 C++ 运算符、每个运算符的 Proto 标签类型以及用于生成相应 Proto 表达式类型的元函数的名称。正如我们稍后将看到的，元函数也可以用作匹配此类节点的语法，以及直通转换。

Boost.Fusion 是一个用于操作异构序列的迭代器、算法、容器和适配器库。本质上，Proto 表达式只是其子表达式的异构序列，因此 Proto 表达式是有效的 Fusion 随机访问序列。这意味着您可以将 Fusion 算法应用于它们，转换它们，将 Fusion 过滤器和视图应用于它们，并使用 fusion::at() 访问它们的元素。Fusion 可以对异构序列执行的操作超出了本用户指南的范围，但下面是一个简单的示例。它接受一个惰性函数调用，如 fun(1,2,3,4)，并使用 Fusion 按顺序打印函数参数。

struct display
{
    template<typename T>
    void operator()(T const &t) const
    {
        std::cout << t << std::endl;
    }
};

struct fun_t {};
proto::terminal<fun_t>::type const fun = {{}};

// ...
fusion::for_each(
    fusion::transform(
        // pop_front() removes the "fun" child
        fusion::pop_front(fun(1,2,3,4))
        // Extract the ints from the terminal nodes
      , proto::functional::value()
    )
  , display()
);

回顾一下引言，proto::functional 命名空间中的类型定义了与 Proto 的自由函数对应的函数对象。因此，proto::functional::value() 创建了一个等效于 proto::value() 函数的函数对象。上面对 fusion::for_each() 的调用显示以下内容

1
2
3
4

终端也是有效的 Fusion 序列。它们只包含一个元素：它们的值。

扁平化 Proto 表达式树

想象一下上面示例的一个轻微变体，我们不是迭代惰性函数调用的参数，而是希望迭代加法表达式中的终端

proto::terminal<int>::type const _1 = {1};

// ERROR: this doesn't work! Why?
fusion::for_each(
    fusion::transform(
        _1 + 2 + 3 + 4
      , proto::functional::value()
    )
  , display()
);

这不起作用的原因是表达式 _1 + 2 + 3 + 4 没有描述终端的扁平序列 --- 它描述的是二叉树。但是，我们可以使用 Proto 的 proto::flatten() 函数将其视为终端的扁平序列。proto::flatten() 返回一个视图，该视图使树看起来像一个扁平的 Fusion 序列。如果最顶层节点的标签类型为 T，则扁平化序列的元素是不具有标签类型 T 的子节点。此过程是递归评估的。因此，以上代码可以正确地写成

proto::terminal<int>::type const _1 = {1};

// OK, iterate over a flattened view
fusion::for_each(
    fusion::transform(
        proto::flatten(_1 + 2 + 3 + 4)
      , proto::functional::value()
    )
  , display()
);

上面对 fusion::for_each() 的调用显示以下内容

1
2
3
4

表达式树可以具有非常丰富和复杂的结构。通常，在处理表达式之前，您需要了解表达式结构的一些信息。本节介绍 Proto 提供的用于查看表达式树内部并发现其结构的工具。正如您将在后面的章节中看到的，所有可以使用 Proto 完成的真正有趣的事情都从这里开始。

proto::terminal< std::istream & >::type cin_ = { std::cin };
proto::terminal< std::ostream & >::type cout_ = { std::cout };

struct Input
  : proto::shift_right< proto::terminal< std::istream & >, proto::_ >
{};

struct Output
  : proto::shift_left< proto::terminal< std::ostream & >, proto::_ >
{};

template< typename Expr >
void input_output( Expr const & expr )
{
    if( proto::matches< Expr, Input >::value )
    {
        std::cout << "Input!\n";
    }

    if( proto::matches< Expr, Output >::value )
    {
        std::cout << "Output!\n";
    }
}

int main()
{
    int i = 0;
    input_output( cout_ << 1 );
    input_output( cin_ >> i );

    return 0;
}

Output!
Input!

template< typename Expr >
typename boost::enable_if< proto::matches< Expr, Input > >::type
input_output( Expr const & expr )
{
    std::cout << "Input!\n";
}

template< typename Expr >
typename boost::enable_if< proto::matches< Expr, Output > >::type
input_output( Expr const & expr )
{
    std::cout << "Output!\n";
}

input_output( cout_ << 1 << 2 ); // oops!

struct Input
  : proto::or_<
        proto::shift_right< proto::terminal< std::istream & >, proto::_ >
      , proto::shift_right< Input, proto::_ >
    >
{};

struct Output
  : proto::or_<
        proto::shift_left< proto::terminal< std::ostream & >, proto::_ >
      , proto::shift_left< Output, proto::_ >
    >
{};

struct CharString
  : proto::terminal< char const * >
{};

typedef proto::terminal< char const[6] >::type char_array;

BOOST_MPL_ASSERT(( proto::matches< char_array, CharString > ));

struct CharString
  : proto::terminal< proto::exact< char const * > >
{};

typedef proto::terminal<char const[6]>::type char_array;
typedef proto::terminal<char const *>::type  char_string;

BOOST_MPL_ASSERT(( proto::matches< char_string, CharString > ));
BOOST_MPL_ASSERT_NOT(( proto::matches< char_array, CharString > ));

struct StdComplex
  : proto::terminal< std::complex< proto::_ > >
{};

struct CharString
  : proto::and_<
        proto::terminal< proto::_ >
      , proto::if_< boost::is_same< proto::_value, char const * >() >
    >
{};