int i=3;
std::cout << arg1(i) << std::endl;        // prints 3

Boost.Phoenix is the most important Boost library for functional programming. While libraries like Boost.Bind or Boost.Lambda provide some support for functional programming, Boost.Phoenix includes the features of these libraries and goes beyond them.

In functional programming, functions are objects and can be processed like objects. With Boost.Phoenix, it is possible for a function to return another function as a result. It is also possible to pass a function as a parameter to another function. Because functions are objects, it’s possible to distinguish between instantiation and execution. Accessing a function isn’t equal to executing it.

Tip

Don’t use Boost.Phoenix to create complex functions. It is better to use lambda functions from C++11. While Boost.Phoenix comes close to C++ syntax, using keywords like if_ or code blocks between square brackets doesn’t necessarily improve readability.

...Во-вторых, лямбда-выражения как правило работают быстрее. Дело в том что std::bind захватывает и хранит указатель на функцию, поэтому компилятор имеет мало шансов встроить (inline) ее, ...

using namespace std;
using namespace placeholders;

int f(int x, int y) { return x+y; }

int __attribute__((noinline)) g1(int x, int y)
{
  return f(x,y);
}

int __attribute__((noinline)) g2(int x, int y)
{
  auto w = bind(f, _1, _2);
  return w(x, y);
}

int __attribute__((noinline)) g3(int x, int y)
{
  auto w = bind(&f, _1, y);
  return w(x);
}

int __attribute__((noinline)) g4(int x, int y)
{
  auto w = bind(&f, x, _1);
  return w(y);
}

// теперь массив
int arr[] = {1,2,3,4,5,6,7,8,9};

int __attribute__((noinline)) a1(int y)
{
  transform( begin(arr), end(arr), begin(arr), [y](int& a){ return f(a, y);} );
  return arr[0];
}

int __attribute__((noinline)) a2(int y)
{
  transform( begin(arr), end(arr), begin(arr), bind(f, _1, y) );
  return arr[0];
}

0000000000400600 <f(int, int)>:
  400600:       8d 04 37                lea    (%rdi,%rsi,1),%eax
  400603:       c3                      retq
  400604:       66 66 66 2e 0f 1f 84    data32 data32 nopw %cs:0x0(%rax,%rax,1)
  40060b:       00 00 00 00 00

0000000000400610 <g1(int, int)>:
  400610:       8d 04 37                lea    (%rdi,%rsi,1),%eax
  400613:       c3                      retq
  400614:       66 66 66 2e 0f 1f 84    data32 data32 nopw %cs:0x0(%rax,%rax,1)
  40061b:       00 00 00 00 00

0000000000400620 <g2(int, int)>:
  400620:       8d 04 3e                lea    (%rsi,%rdi,1),%eax
  400623:       c3                      retq
  400624:       66 66 66 2e 0f 1f 84    data32 data32 nopw %cs:0x0(%rax,%rax,1)
  40062b:       00 00 00 00 00

0000000000400630 <g3(int, int)>:
  400630:       8d 04 3e                lea    (%rsi,%rdi,1),%eax
  400633:       c3                      retq
  400634:       66 66 66 2e 0f 1f 84    data32 data32 nopw %cs:0x0(%rax,%rax,1)
  40063b:       00 00 00 00 00

0000000000400640 <g4(int, int)>:
  400640:       8d 04 37                lea    (%rdi,%rsi,1),%eax
  400643:       c3                      retq
  400644:       66 66 66 2e 0f 1f 84    data32 data32 nopw %cs:0x0(%rax,%rax,1)
  40064b:       00 00 00 00 00

0000000000400650 <a1(int)>:
  400650:       b8 a0 1b 40 00          mov    $0x401ba0,%eax
  400655:       0f 1f 00                nopl   (%rax)
  400658:       01 38                   add    %edi,(%rax)
  40065a:       48 83 c0 04             add    $0x4,%rax
  40065e:       48 3d c4 1b 40 00       cmp    $0x401bc4,%rax
  400664:       75 f2                   jne    400658 <a1(int)+0x8>
  400666:       8b 05 34 15 00 00       mov    0x1534(%rip),%eax        # 401ba0 <arr>
  40066c:       c3                      retq
  40066d:       0f 1f 00                nopl   (%rax)

0000000000400670 <a2(int)>:
  400670:       b8 a0 1b 40 00          mov    $0x401ba0,%eax
  400675:       0f 1f 00                nopl   (%rax)
  400678:       01 38                   add    %edi,(%rax)
  40067a:       48 83 c0 04             add    $0x4,%rax
  40067e:       48 3d c4 1b 40 00       cmp    $0x401bc4,%rax
  400684:       75 f2                   jne    400678 <a2(int)+0x8>
  400686:       8b 05 14 15 00 00       mov    0x1514(%rip),%eax        # 401ba0 <arr>
  40068c:       c3                      retq
  40068d:       00 00                   add    %al,(%rax)

J>int __attribute__((noinline)) a1(int y)
J>{
J>  transform( begin(arr), end(arr), begin(arr), [y](int& a){ return f(a, y);} );
J>  return arr[0];
J>}

J>int __attribute__((noinline)) a2(int y)
J>{
J>  transform( begin(arr), end(arr), begin(arr), bind(f, _1, y) );
J>  return arr[0];
J>}
J>

template<typename I, typename O, typename F>
__attribute__((noinline)) O transform(I first, I last, O out, F f)
{
    for(; first!=last; ++first, ++out)
        *out = f(*first);
}

int f(int x, int y) { return x*y; }

int test_lambda(int (&arr)[1111], int y)
{
    transform( begin(arr), end(arr), begin(arr), [=](int &a){ return f(a, y);} );
    return arr[0];
}

int test_bind(int (&arr)[1111], int y)
{
    transform( begin(arr), end(arr), begin(arr), bind(f, _1, y) );
    return arr[0];
}

; g++ -std=c++14 -O2 main.cpp -S && cat main.s
...
_Z9transformIPiS0_Z11test_lambdaRA1111_iiEUlRiE_ET0_T_S6_S5_T1_:
.LFB1390:
    .cfi_startproc
    cmpq    %rsi, %rdi
    je    .L4
    .p2align 4,,10
    .p2align 3
.L6:
    movl    (%rdi), %eax
    addq    $4, %rdi
    addq    $4, %rdx
    imull    %ecx, %eax
    movl    %eax, -4(%rdx)
    cmpq    %rdi, %rsi
    jne    .L6
.L4:
    xorl    %eax, %eax
    ret
    .cfi_endproc
...
_Z11test_lambdaRA1111_ii:
.LFB1279:
    .cfi_startproc
    movl    %esi, %ecx
    leaq    4444(%rdi), %rsi
    movq    %rdi, %r8
    movq    %rdi, %rdx
    call    _Z9transformIPiS0_Z11test_lambdaRA1111_iiEUlRiE_ET0_T_S6_S5_T1_
    movl    (%r8), %eax
    ret
...
_Z9transformIPiS0_St5_BindIFPFiiiESt12_PlaceholderILi1EEiEEET0_T_S9_S8_T1_:
.LFB1429:
    .cfi_startproc
    cmpq    %rsi, %rdi
    je    .L17
    pushq    %r13
    .cfi_def_cfa_offset 16
    .cfi_offset 13, -16
    pushq    %r12
    .cfi_def_cfa_offset 24
    .cfi_offset 12, -24
    movq    %rsi, %r13
    pushq    %rbp
    .cfi_def_cfa_offset 32
    .cfi_offset 6, -32
    pushq    %rbx
    .cfi_def_cfa_offset 40
    .cfi_offset 3, -40
    movq    %rdx, %rbp
    movq    %rdi, %rbx
    movq    %rcx, %r12
    subq    $8, %rsp
    .cfi_def_cfa_offset 48
    .p2align 4,,10
    .p2align 3
.L14:
    movl    (%rbx), %edi
    addq    $4, %rbx
    movl    8(%r12), %esi
    addq    $4, %rbp
    call    *(%r12)
    movl    %eax, -4(%rbp)
    cmpq    %rbx, %r13
    jne    .L14
    addq    $8, %rsp
    .cfi_def_cfa_offset 40
    xorl    %eax, %eax
    popq    %rbx
    .cfi_restore 3
    .cfi_def_cfa_offset 32
    popq    %rbp
    .cfi_restore 6
    .cfi_def_cfa_offset 24
    popq    %r12
    .cfi_restore 12
    .cfi_def_cfa_offset 16
    popq    %r13
    .cfi_restore 13
    .cfi_def_cfa_offset 8
    ret
.L17:
    xorl    %eax, %eax
    ret
    .cfi_endproc
...
_Z9test_bindRA1111_ii:
.LFB1283:
    .cfi_startproc
    pushq    %rbx
    .cfi_def_cfa_offset 16
    .cfi_offset 3, -16
    movq    %rdi, %rdx
    movq    %rdi, %rbx
    subq    $16, %rsp
    .cfi_def_cfa_offset 32
    movl    %esi, 8(%rsp)
    leaq    4444(%rdi), %rsi
    movq    %rsp, %rcx
    movq    $_Z1fii, (%rsp)
    call    _Z9transformIPiS0_St5_BindIFPFiiiESt12_PlaceholderILi1EEiEEET0_T_S9_S8_T1_
    movl    (%rbx), %eax
    addq    $16, %rsp
    .cfi_def_cfa_offset 16
    popq    %rbx
    .cfi_def_cfa_offset 8
    ret
    .cfi_endproc