Boost C++ 库

Boost 1.51

解包表达式

在 Boost 1.51 中，Proto 获得了简单的解包模式。在使用 Proto 转换时，解包表达式对于将表达式的子表达式解包到函数调用或对象构造函数中非常有用，同时可以选择性地对每个子表达式依次应用一些转换。

有关更多信息，请参见解包表达式部分。

Boost 1.44

行为变更：proto::and_<>

在 Boost 1.44 中，proto::and_<>作为转换的行为发生了变化。以前，它只应用与集合中最后一个语法相关的转换。现在，它应用所有转换，但只返回最后一个的结果。这使得它的行为类似于 C++ 的逗号运算符。例如，像这样的语法

proto::and_< G0, G1, G2 >

当使用表达式e进行评估时，现在的行为如下

((void)G0()(e), (void)G1()(e), G2()(e))

行为变更：proto::as_expr() 和 proto::as_child()

函数 proto::as_expr() 和 proto::as_child() 用于保证对象是一个 Proto 表达式，如果它还不是，则通过使用可选指定的域将其转换为一个。在以前的版本中，当这些函数传递一个与指定域不同的 Proto 表达式时，它们会应用指定域的生成器，从而导致一个二次包装的表达式。这种行为让一些用户感到惊讶。

这两个函数的新行为是始终保持 Proto 表达式不变，而不管表达式的域如何。

行为变更：proto::(pod_)generator<> 和 proto::basic_expr<>

熟悉 Proto 扩展机制的用户可能在定义他们的域时，使用了 proto::generator<> 或 proto::pod_generator<> 和包装器模板。过去，Proto 会使用 proto::expr<> 的实例来实例化您的包装器模板。在 Boost 1.44 中，Proto 现在使用一种新类型：proto::basic_expr<> 的实例来实例化您的包装器模板。

例如

// An expression wrapper
template<class Expr>
struct my_expr_wrapper;

// A domain
struct my_domain
  : proto::domain< proto::generator< my_expr_wrapper > >
{};

template<class Expr>
struct my_expr_wrapper
  : proto::extends<Expr, my_expr_wrapper<Expr>, my_domain>
{
  // Before 1.44, Expr was an instance of proto::expr<>
  // In 1.44, Expr is an instance of proto::basic_expr<>
};

此更改的动机是提高编译时间。proto::expr<> 是一种实例化成本很高的类型，因为它定义了大量成员函数。在定义您自己的表达式包装器时，proto::expr<> 的实例作为隐藏的数据成员函数位于您的包装器中，并且未使用 proto::expr<> 的成员。因此，这些成员函数的成本被浪费了。相比之下，proto::basic_expr<> 是一种非常轻量级的类型，根本没有成员函数。

绝大多数程序应该无需任何源代码更改即可重新编译。但是，如果您在某个地方假设您将获得专门的 proto::expr<> 实例，您的代码将会中断。

新特性：子域

在 Boost 1.44 中，Proto 引入了一个重要的新特性，称为“子域”。这为您提供了一种指定一个域与另一个域兼容的方式，以便一个域中的表达式可以与另一个域中的表达式自由混合。您可以使用 proto::domain<> 的第三个模板参数来定义一个域是另一个域的子域。

例如

// Not shown: define some expression
// generators genA and genB

struct A
  : proto::domain< genA, proto::_ >
{};

// Define a domain B that is the sub-domain
// of domain A.
struct B
  : proto::domain< genB, proto::_, A >
{};

域 A 和 B 中的表达式可以具有不同的包装器（因此，具有不同的接口），但可以将它们组合成更大的表达式。如果没有子域关系，这将是一个错误。在这种情况下，结果表达式的域将是 A。

子域的完整描述可以在 proto::domain<> 和 proto::deduce_domain 的参考部分中找到。

新特性：特定于域的 as_expr() 和 as_child()

Proto 始终允许用户通过在定义他们的域时指定一个 Generator 来事后定制表达式。但它从未允许用户首先控制 Proto 如何组装子表达式。从 Boost 1.44 开始，用户现在拥有这种能力。

定义自己的域的用户现在可以指定 proto::as_expr() 和 proto::as_child() 在他们的域中如何工作。他们可以通过在他们的域类中定义名为 as_expr 和/或 as_child 的嵌套类模板来轻松地做到这一点。

例如

struct my_domain
  : proto::domain< my_generator >
{
  typedef
      proto::domain< my_generator >
  base_domain;

  // For my_domain, as_child does the same as
  // what as_expr does by default.
  template<class T>
  struct as_child
    : base_domain::as_expr<T>
  {};
};

在上面的例子中，my_domain::as_child<> 只是推迟到 proto::domain::as_expr<>。这具有很好的效果，即导致所有终端都通过值而不是通过引用来捕获，并且同样通过值来存储子表达式。结果是，my_domain 中的表达式可以安全地存储在 auto 变量中，因为它们不会对中间临时表达式有悬空引用。（当然，这也意味着表达式构造具有额外的运行时开销，即复制，编译器可能能够或可能无法将其优化掉。）

Boost 1.43

在 Boost 1.43 中，proto::extends<> 的推荐用法略有变化。新用法如下所示

// my_expr is an expression extension of the Expr parameter
template<typename Expr>
struct my_expr
  : proto::extends<Expr, my_expr<Expr>, my_domain>
{
    my_expr(Expr const &expr = Expr())
      : proto::extends<Expr, my_expr, my_domain>(expr)
    {}

    // NEW: use the following macro to bring
    // proto::extends::operator= into scope.
    BOOST_PROTO_EXTENDS_USING_ASSIGN(my_expr)
};

新的是使用 BOOST_PROTO_EXTENDS_USING_ASSIGN() 宏。为了允许赋值运算符构建表达式树，proto::extends<> 重载了赋值运算符。但是，对于 my_expr 模板，编译器会生成一个默认的复制赋值运算符，该运算符隐藏了 proto::extends<> 中的那些。这通常是不希望的（尽管这取决于您想要允许的语法）。

以前，推荐的用法是这样做

// my_expr is an expression extension of the Expr parameter
template<typename Expr>
struct my_expr
  : proto::extends<Expr, my_expr<Expr>, my_domain>
{
    my_expr(Expr const &expr = Expr())
      : proto::extends<Expr, my_expr, my_domain>(expr)
    {}

    // OLD: don't do it like this anymore.
    using proto::extends<Expr, my_expr, my_domain>::operator=;
};

虽然这在大多数情况下都有效，但它仍然不会抑制默认赋值运算符的隐式生成。因此，形式为 a = b 的表达式可以构建一个表达式模板，或者执行一个复制赋值，这取决于 a 和 b 的类型是否相同。这可能会导致细微的错误，因此行为已更改。

BOOST_PROTO_EXTENDS_USING_ASSIGN() 将 proto::extends<> 中定义的赋值运算符引入到作用域中，并抑制复制赋值运算符的生成。

另请注意，使用 proto::extends<> 的 proto::literal<> 类模板已更改为使用 BOOST_PROTO_EXTENDS_USING_ASSIGN()。以下示例代码中突出显示了相关内容

proto::literal<int> a(1), b(2); // two non-const proto literals
proto::literal<int> const c(3); // a const proto literal

a = b; // No-op. Builds an expression tree and discards it.
       // Same behavior in 1.42 and 1.43.

a = c; // CHANGE! In 1.42, this performed copy assignment, causing
       // a's value to change to 3. In 1.43, the behavior is now
       // the same as above: build and discard an expression tree.

我要感谢 Joel de Guzman 和 Hartmut Kaiser 愿意冒险在 Spirit-2 和 Karma 的工作中使用 Proto，当时 Proto 还只是一个愿景。 他们的要求和反馈是必不可少的。

还要感谢 Thomas Heller 和 Hartmut 在 Phoenix 重新设计期间提供的反馈和建议。 这项工作产生了几个有价值的高级功能，例如子域、外部转换和每个域的 as_child 自定义。

感谢 Daniel James 提供了一个补丁，用于删除对 C++0x 功能的已弃用配置宏的依赖。

感谢 Joel Falcou 和 Christophe Henry 的热情、支持、反馈和幽默； 并感谢他们自愿成为 Proto 的共同维护者。

感谢 Dave Abrahams 的特别详细的审查，并感谢他提供了一个包含 msvc-7.1 的 VM，以便我可以在该编译器上跟踪可移植性问题。

非常感谢 Daniel Wallin，他首先实现了用于在一组中查找公共域的代码，同时考虑了超级域和子域。 还要感谢 Jeremiah Willcock、John Bytheway 和 Krishna Achuthan，他们为这个棘手的编程问题提供了替代解决方案。

还要感谢 PETE 的开发人员。 我在那里找到了许多好主意。