Boost C++ 库

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

Lambda2：一个 C++14 Lambda 库 - Boost 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。

投影（Projections）

inline constexpr /unspecified/ first{};

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

inline constexpr /unspecified/ second{};

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

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

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 Software License, Version 1.0分发。