Как я могу создать std::function с настраиваемым распределителем?

Согласно стандарту, в качестве первого аргумента необходимо указать тип тега. чтобы указать, что вы хотите использовать пользовательский распределитель:

std::function<void(int)> f(std::allocator_arg, MyAlloc<char>{}, [i](int in){
    //...
});

Как указал @Casey и @Potatoswatter в комментариях тип аргумента шаблона, переданный распределителю, не имеет значения, если это тип объекта. Так что char здесь нормально.

Обновление для C++17: оказывается, что поддержка распределителя для std::function имеет ряд фундаментальных проблем, которые приводят к является устаревшим в C++17. Если вы, тем не менее, настаиваете на его использовании, обязательно тщательно проверьте свою реализацию, прежде чем делать это. Стандартная библиотека GCC никогда не реализовывала эти функции, но даже если ваша стандартная библиотека это делает, она может вести себя не так, как вы ожидаете.

Я понимаю, что на этот вопрос был дан правильный ответ, но даже после прочтения этой статьи и ответов я немного боролся с правильным синтаксисом, пытаясь перегрузить распределитель для std::function, который кросс-компилируется на X64, PS4 и Xbox One в VS2012.

Если читателю непонятно, вам нужно будет объявить класс распределителя в соответствии с комментарием Кейси. Хотя это довольно очевидно, если вы прочитали все ответы, что было неясно, так это то, как эти распределители передаются объекту, который не похож на большинство распределителей STL, которые я использовал ранее, которые принимают тип распределителя (не экземпляр). ) как часть спецификации типа.

Для std::function инстанцированный распределитель передается конструктору вашего объекта std::function, как это показано ComicSansMS выше.

Для использования этого с функцией-членом вместо лямбда-кода, показанного в этом примере, становится немного сложнее:

   #include <functional>

    MyAllocType g_myAlloc; // declared somewhere and globally instantiated to persist

    // sample of a member function that takes an int parameter
    class MyClassType
    {
    public:
        void TestFunction( int param )
        {
        }
    };

    MyClassType MyClass; // instantiated object

    // example without allocator
    // note the pointer to the class type that must precede function parameters since 
    // we are using a method. Also std::mem_fn is require to compile in VS2012 :/
    std::function<void(MyClassType*, int)> f( std::mem_fn( &MyClassType::TestFunction ) );

    // usage of function needs an instantiated object (perhaps there is a way around this?)
    f( &MyClass, 10 );

    // example with allocator
    std::function<void(MyClassType*, int)> f(std::allocator_arg, g_myAlloc, std::mem_fn( &MyClassType::TestFunction ) );

    // usage of function is the same as above and needs an instantiated object 
    f( &MyClass, 10 );

    //or a non member function, which is much cleaner looking
    void NonMemberFunction( int param )
    {
    }

    std::function<void(int)> f(std::allocator_arg, g_myAlloc, NonMemberFunction);

Надеюсь, это поможет людям, мне потребовалось больше времени, чем я хотел бы признать, чтобы заставить это работать, и, поскольку я использую этот сайт, я решил, что оставлю здесь комментарий, если только для меня, о том, как его использовать. . :)

2 заключительных вопроса к тем, кто умнее меня:

Вопрос. Можно ли включить распределитель как часть типа?

Вопрос. Есть ли способ использовать функцию-член без экземпляра объекта?

Чтобы обновить это, если вы решите передать один из этих объектов std::function в качестве параметра какой-либо другой функции, я обнаружил, что мне нужно использовать std::function::assign, иначе присваивание приводит к поверхностной копии. Это может быть проблемой, если вы пытаетесь передать его объекту с более длительным жизненным циклом, чем у оригинала.

Пример:

std::function<void(MyClassType*, int)> f(std::allocator_arg, g_myAlloc, std::mem_fn( &MyClassType::TestFunction ) );

void FunctionTakeParam( std::function<void(MyClassType*, int)> &FunctionIn )
{
    // this results in a reallocation using your allocator
    std::function<void(MyClassType*, int)> MyLocalFunction.assign( std::allocator_arg, g_myAlloc, FunctionIn ); 

    // the below results in a shallow copy which will likely cause bad things
    //std::function<void(MyClassType*, int)> MyLocalFunction( std::allocator_arg, g_myAlloc, FunctionIn ); 

    ...
}