Boost C++ 库

...世界上最受推崇和设计最精良的 C++ 库项目之一。 — Herb Sutter 和 Andrei Alexandrescu, C++ 编码标准

概述

描述

这是一个简单但功能齐全的 C++14 lambda 库。它利用了标准 <functional> 头文件已经提供了 std::bind 自定义点（is_placeholder，is_bind_expression）和函数对象（例如 std::plus，std::greater，std::logical_not 和 std::bit_xor）的事实，这些函数对象对应于算术、关系、逻辑和位运算符。

这使得该库能够提供一个最小的实现，该实现仍然允许诸如 _1 + 5、_1 % 2 == 0、_1 > _2 或 _1 == ' ' || _1 == '\t' 之类的表达式被组合并用作函数对象。

例如，_1 + 5 被实现为 std::bind(std::plus<>, _1, 5)。

这些“lambda”表达式也可以与 std::bind 自由组合。例如，std::bind( f, _1 ) == std::bind( g, _1 ) 和 std::bind( f, _1 + _2 ) 都可以工作并且具有预期的行为。

用法示例

计数偶数

#include <boost/lambda2.hpp>
#include <algorithm>

using namespace boost::lambda2;

int count_even( int const * first, int const * last )
{
    return std::count_if( first, last, _1 % 2 == 0 );
}

查找第一个空白字符

#include <boost/lambda2.hpp>
#include <algorithm>

char const * find_whitespace( char const * first, char const * last )
{
    using namespace boost::lambda2;

    return std::find_if( first, last,
        _1 == ' ' || _1 == '\t' || _1 == '\r' || _1 == '\n' );
}

依赖项

无。单个自包含的头文件。

支持的编译器

GCC 5 或更高版本，使用 -std=c++14 或更高版本
Clang 3.9 或更高版本，使用 -std=c++14 或更高版本
Visual Studio 2015、2017、2019

在 Github Actions 和 Appveyor 上测试。

修订历史

1.78.0 版本的更改

当第一个参数是流时，在 operator<< 和 operator>> 中添加了特殊情况，以允许 std::cout << _1。
添加了 operator->*。
添加了 first，second。

参考

<boost/lambda2/lambda2.hpp>

概要

namespace boost {
namespace lambda2 {

// placeholders

template<int I> struct lambda2_arg;

inline constexpr lambda2_arg<1> _1{};
inline constexpr lambda2_arg<2> _2{};
inline constexpr lambda2_arg<3> _3{};
inline constexpr lambda2_arg<4> _4{};
inline constexpr lambda2_arg<5> _5{};
inline constexpr lambda2_arg<6> _6{};
inline constexpr lambda2_arg<7> _7{};
inline constexpr lambda2_arg<8> _8{};
inline constexpr lambda2_arg<9> _9{};

// arithmetic operators

template<class A, class B> auto operator+( A && a, B && b );
template<class A, class B> auto operator-( A && a, B && b );
template<class A, class B> auto operator*( A && a, B && b );
template<class A, class B> auto operator/( A && a, B && b );
template<class A, class B> auto operator%( A && a, B && b );
template<class A> auto operator-( A && a );

// relational operators

template<class A, class B> auto operator==( A && a, B && b );
template<class A, class B> auto operator!=( A && a, B && b );
template<class A, class B> auto operator>( A && a, B && b );
template<class A, class B> auto operator<( A && a, B && b );
template<class A, class B> auto operator>=( A && a, B && b );
template<class A, class B> auto operator<=( A && a, B && b );

// logical operators

template<class A, class B> auto operator&&( A && a, B && b );
template<class A, class B> auto operator||( A && a, B && b );
template<class A> auto operator!( A && a );

// bitwise operators

template<class A, class B> auto operator&( A && a, B && b );
template<class A, class B> auto operator|( A && a, B && b );
template<class A, class B> auto operator^( A && a, B && b );
template<class A> auto operator~( A && a );

template<class A, class B> auto operator<<( A && a, B && b );
template<class A, class B> auto operator>>( A && a, B && b );

// additional unary operators

template<class A> auto operator+( A && a );
template<class A> auto operator*( A && a );
template<class A> auto operator++( A && a );
template<class A> auto operator--( A && a );
template<class A> auto operator++( A && a, int );
template<class A> auto operator--( A && a, int );

// compound assignment operators

template<class A, class B> auto operator+=( A && a, B && b );
template<class A, class B> auto operator-=( A && a, B && b );
template<class A, class B> auto operator*=( A && a, B && b );
template<class A, class B> auto operator/=( A && a, B && b );
template<class A, class B> auto operator%=( A && a, B && b );
template<class A, class B> auto operator&=( A && a, B && b );
template<class A, class B> auto operator|=( A && a, B && b );
template<class A, class B> auto operator^=( A && a, B && b );
template<class A, class B> auto operator<<=( A && a, B && b );
template<class A, class B> auto operator>>=( A && a, B && b );

// additional binary operators

template<class A, class B> auto operator->*( A && a, B && b );

// projections

inline constexpr /unspecified/ first{};
inline constexpr /unspecified/ second{};

} // namespace lambda2
} // namespace boost

占位符

template<int I> struct lambda2_arg
{
    template<class... A> decltype(auto) operator()( A&&... a ) const noexcept;
    template<class T> auto operator[]( T&& t ) const;
};

lambda2_arg 是库提供的占位符 _I 的类型。标准自定义点 std::is_placeholder 专门针对它，从而可以使用 Lambda2 的占位符和 std::bind。

占位符定义了 operator()，这允许它们直接用作函数对象。例如，_1(x, y) 返回 x。

operator[] 也被定义为允许像 _1[x] 或 _1[_2] 这样的表达式。

template<class... A> decltype(auto) operator()( A&&... a ) const noexcept;

返回

std::get<std::size_t{I-1}>( std::tuple<A&&…>( std::forward<A>(a)… ) );

template<class T> auto operator[]( T&& t ) const;

返回

std::bind( fn, *this, std::forward<T>(t) );，其中 fn 是一个函数对象，使得 fn(x, y) 返回 x[y]。

通用要求

后续章节中定义的所有运算符仅在其操作数之一满足以下条件时才参与重载解析：对于其非限定类型 T，表达式 std::is_placeholder<T>::value || std::is_bind_expression<T>::value 为 true。

算术运算符

template<class A, class B> auto operator+( A && a, B && b );

返回

std::bind( std::plus<>(), std::forward<A>(a), std::forward(b) );

template<class A, class B> auto operator-( A && a, B && b );

返回

std::bind( std::minus<>(), std::forward<A>(a), std::forward(b) );

template<class A, class B> auto operator*( A && a, B && b );

返回

std::bind( std::multiplies<>(), std::forward<A>(a), std::forward(b) );

template<class A, class B> auto operator/( A && a, B && b );

返回

std::bind( std::divides<>(), std::forward<A>(a), std::forward(b) );

template<class A, class B> auto operator%( A && a, B && b );

返回

std::bind( std::modulus<>(), std::forward<A>(a), std::forward(b) );

template<class A> auto operator-( A && a );

返回

std::bind( std::negate<>(), std::forward<A>(a) );

关系运算符

template<class A, class B> auto operator==( A && a, B && b );

返回

std::bind( std::equal_to<>(), std::forward<A>(a), std::forward(b) );

template<class A, class B> auto operator!=( A && a, B && b );

返回

std::bind( std::not_equal_to<>(), std::forward<A>(a), std::forward(b) );

template<class A, class B> auto operator>( A && a, B && b );

返回

std::bind( std::greater<>(), std::forward<A>(a), std::forward(b) );

template<class A, class B> auto operator<( A && a, B && b );

返回

std::bind( std::less<>(), std::forward<A>(a), std::forward(b) );

template<class A, class B> auto operator>=( A && a, B && b );

返回

std::bind( std::greater_equal<>(), std::forward<A>(a), std::forward(b) );

template<class A, class B> auto operator<=( A && a, B && b );

返回

std::bind( std::less_equal<>(), std::forward<A>(a), std::forward(b) );

逻辑运算符

template<class A, class B> auto operator&&( A && a, B && b );

返回

std::bind( std::logical_and<>(), std::forward<A>(a), std::forward(b) );

template<class A, class B> auto operator||( A && a, B && b );

返回

std::bind( std::logical_or<>(), std::forward<A>(a), std::forward(b) );

template<class A> auto operator!( A && a );

返回

std::bind( std::logical_not<>(), std::forward<A>(a) );

位运算符

template<class A, class B> auto operator&( A && a, B && b );

返回

std::bind( std::bit_and<>(), std::forward<A>(a), std::forward(b) );

template<class A, class B> auto operator|( A && a, B && b );

返回

std::bind( std::bit_or<>(), std::forward<A>(a), std::forward(b) );

template<class A, class B> auto operator^( A && a, B && b );

返回

std::bind( std::bit_xor<>(), std::forward<A>(a), std::forward(b) );

template<class A> auto operator~( A && a );

返回

std::bind( std::bit_not<>(), std::forward<A>(a) );

template<class A, class B> auto operator<<( A && a, B && b );

返回

std::bind( fn, std::forward<A>(a), std::forward(b) );，其中 fn 是一个函数对象，使得 fn(x, y) 返回 x << y。

template<class A, class B> auto operator>>( A && a, B && b );

返回

std::bind( fn, std::forward<A>(a), std::forward(b) );，其中 fn 是一个函数对象，使得 fn(x, y) 返回 x >> y。

附加一元运算符

template<class A> auto operator+( A && a );

返回

std::bind( fn, std::forward<A>(a) );，其中 fn 是一个函数对象，使得 fn(x) 返回 +x。

template<class A> auto operator*( A && a );

返回

std::bind( fn, std::forward<A>(a) );，其中 fn 是一个函数对象，使得 fn(x) 返回 *x。

template<class A> auto operator++( A && a );

返回

std::bind( fn, std::forward<A>(a) );，其中 fn 是一个函数对象，使得 fn(x) 返回 ++x。

template<class A> auto operator--( A && a );

返回

std::bind( fn, std::forward<A>(a) );，其中 fn 是一个函数对象，使得 fn(x) 返回 --x。

template<class A> auto operator++( A && a, int );

返回

std::bind( fn, std::forward<A>(a) );，其中 fn 是一个函数对象，使得 fn(x) 返回 x++。

template<class A> auto operator--( A && a, int );

返回

std::bind( fn, std::forward<A>(a) );，其中 fn 是一个函数对象，使得 fn(x) 返回 x--。

复合赋值运算符

template<class A, class B> auto operator@=( A && a, B && b );

返回

std::bind( fn, std::forward<A>(a), std::forward(b) );，其中 fn 是一个函数对象，使得 fn(x, y) 返回 x @= y。

附加二元运算符

template<class A, class B> auto operator->*( A && a, B && b );

返回

std::bind( std::forward(b), std::forward<A>(a) );

注释

此运算符旨在与“投影”函数对象一起使用，例如成员指针或不带参数的成员函数，如 _1->*&X::m 或 _1->*&X::f。

投影

inline constexpr /unspecified/ first{};

一个函数对象，使得 first(x) 返回 std::get<0>(x)。

inline constexpr /unspecified/ second{};

一个函数对象，使得 second(x) 返回 std::get<1>(x)。

代码示例 1. 使用 first 和 second 打印映射

void print( std::map<int, std::string> const & m )
{
    using namespace boost::lambda2;
    std::for_each( m.begin(), m.end(), std::cout << _1->*first << ": " << _1->*second << '\n' );
}

版权和许可证

本文档版权归 2020, 2021 Peter Dimov 所有，并根据 Boost 软件许可证，版本 1.0 分发。