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 表达式不变，而不管表达式的域是什么。

行为变更：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 一直允许用户通过在定义域时指定生成器来事后自定义表达式。但它从未允许用户控制 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<> 简单地defer to 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 愿意在 Proto 还只是一个愿景的时候就将 Proto 用于他们在 Spirit-2 和 Karma 上的工作。他们的要求和反馈是不可或缺的。

还要感谢 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 的开发者。我在那里找到了很多好主意。