Можно ли принимать вывод `std::bind` напрямую как значение, без преобразования в std::function?

Можно ли заменить std::function каким-то другим объявлением, которое бы получало вывод std::bind напрямую по значению, тем самым избегая динамического выделения памяти?

Да, это так; но тип, возвращаемый std::bind, не указан, поэтому вам нужно будет использовать шаблон для захвата типа;

template <typename F>
void runThisFunction(F func);

О распределении памяти...

В этом вызове выходные данные std::bind преобразуются в std::function, и динамическое выделение памяти происходит как часть этого процесса.

Можно использовать динамическую память (но не всегда), это зависит от размера функтора, связанного с std::function, и качество реализации.

Кроме того, в спецификации C++ есть этот §20.12.12.2.1/11. ;

Здесь на coliru (libstdc++) размер аргумента для std::function должен быть 16 байт или меньше, на MSVC ограничение составляет 32 байта (обе эти платформы выглядят как 32-разрядные платформы) . С 64-битной компиляцией clang++ (libc++) это ограничение составляет 24 байта... Это действительно зависит от реализации, сколько места они будут выделять, прежде чем необходимо будет сделать new распределения.

Я не уверен, насколько критична производительность, но вычисление этого предела для ваших целей также может быть выполнено, а затем применена оптимизация, чтобы аргументы для std::function оставались ниже этих пределов; например используя указатель или ссылку (также std::ref) на struct для аргументов (но нужно следить за тем, чтобы они не оставались висящими).

Если производительность важна, но вам по-прежнему нужен конкретный интерфейс, рассмотрите возможность привязки к лямбде, а не к объекту связывания (через std::bind).

Я провел этот тест на gcc 5.3 (libstdc++, -O2)

#include <functional>

void foo(int, int);

void runThisFunction(std::function<void()> func);

void test()
{
  runThisFunction(std::bind(&foo, 1, 2));
}

void test1()
{
  runThisFunction([]{ foo(1, 2); });
}

test() приводит к вызову new. Однако небольшая оптимизация функции в std::function способна обнаружить, что лямбда в test1() достаточно мала, и вызов new не передается в код:

(примечание: код обработки исключений удален для ясности):

std::_Function_base::_Base_manager<test1()::{lambda()#1}>::_M_manager(std::_Any_data&, std::_Function_base::_Base_manager<test1()::{lambda()#1}> const&, std::_Manager_operation):
        testl   %edx, %edx
        je      .L3
        cmpl    $1, %edx
        jne     .L2
        movq    %rsi, (%rdi)
.L2:
        xorl    %eax, %eax
        ret
.L3:
        movq    typeinfo for test1()::{lambda()#1}, (%rdi)
        xorl    %eax, %eax
        ret
std::_Function_handler<void (), test1()::{lambda()#1}>::_M_invoke(std::_Any_data const&):
        movl    $2, %esi
        movl    $1, %edi
        jmp     foo(int, int)
test1():
        subq    $40, %rsp
        movq    %rsp, %rdi
        movq    std::_Function_handler<void (), test1()::{lambda()#1}>::_M_invoke(std::_Any_data const&), 24(%rsp)
        movq    std::_Function_base::_Base_manager<test1()::{lambda()#1}>::_M_manager(std::_Any_data&, std::_Function_base::_Base_manager<test1()::{lambda()#1}> const&, std::_Manager_operation), 16(%rsp)
        call    runThisFunction(std::function<void ()>)
        movq    16(%rsp), %rax
        testq   %rax, %rax
        je      .L7
        movl    $3, %edx
        movq    %rsp, %rsi
        movq    %rsp, %rdi
        call    *%rax
.L7:
        addq    $40, %rsp
        ret
typeinfo for test1()::{lambda()#1}:
typeinfo name for test1()::{lambda()#1}:

Используя ссылочную оболочку, вы должны избегать выделения кучи:

auto f = std::bind(foo, 1, 2);
runThisFunction(std::ref(f));

Это связано с тем, что reference_wrapper — это небольшой объект, а std::function рекомендуется избегать размещения под него (см. [func.wrap.func.con]):

Примечание. В реализациях рекомендуется избегать использования динамически выделяемой памяти для небольших вызываемых объектов, например, где целью f является объект, содержащий только указатель или ссылку на объект и указатель на функцию-член.

Это будет работать только в том случае, если runThisFunction() не хранит значение std::function для вызова после окончания жизни f.

очень просто (по крайней мере, для gcc):

int someFunc(int a, int b) { return a+b; }
//....
int b = (std::bind(someFunc,3,4))(); // returns 7