Почему экземпляры std::function имеют конструктор по умолчанию?

Верно, но это верно и для других типов. Например. если я хочу, чтобы в моем классе был необязательный объект Person, я делаю свой элемент данных указателем на человека. Почему бы не сделать то же самое для std::functions? Что такого особенного в std::function, что он может иметь «недопустимое» состояние?

У него нет «недопустимого» состояния. Это не более недействительно, чем это:

std::vector<int> aVector;
aVector[0] = 5;

У вас есть пустой function, точно так же, как aVector — это пустой vector. Объект находится в очень четко определенном состоянии: состоянии отсутствия данных.

Теперь давайте рассмотрим ваше предложение «указатель на функцию»:

void CallbackRegistrar(..., std::function<void()> *pFunc);

Как вы должны называть это? Что ж, вот что вы не можете сделать:

void CallbackFunc();
CallbackRegistrar(..., CallbackFunc);

Это не разрешено, потому что CallbackFunc — это функция, а тип параметра — std::function<void()>*. Эти два не конвертируются, поэтому компилятор будет жаловаться. Итак, чтобы сделать звонок, вы должны сделать это:

void CallbackFunc();
CallbackRegistrar(..., new std::function<void()>(CallbackFunc));

Вы только что представили new на картинке. Вы выделили ресурс; кто будет нести ответственность за это? CallbackRegistrar? Очевидно, вы можете захотеть использовать какой-нибудь интеллектуальный указатель, чтобы еще больше загромождать интерфейс:

void CallbackRegistrar(..., std::shared_ptr<std::function<void()>> pFunc);

Это много раздражения и бесполезности API, просто чтобы передать функцию. Самый простой способ избежать этого — оставить std::function пустым. Так же, как мы позволяем std::vector быть пустым. Так же, как мы позволяем std::string быть пустым. Так же, как мы позволяем std::shared_ptr быть пустым. И так далее.

Проще говоря: std::function содержит функцию. Это держатель для вызываемого типа. Следовательно, существует вероятность того, что он не содержит вызываемого типа.

На самом деле ваше приложение не должно падать.

§ 20.8.11.1 Класс bad_function_call [func.wrap.badcall]

1/ Исключение типа bad_function_call создается function::operator() (20.8.11.2.4), когда у объекта-оболочки функции нет цели.

Поведение точно определено.

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

Ответ, вероятно, исторический: std::function предназначен для замены указателей на функции, а указатели на функции могут быть NULL. Таким образом, если вы хотите обеспечить простую совместимость с указателями функций, вам нужно предложить недопустимое состояние.

Идентифицируемое недопустимое состояние на самом деле не нужно, поскольку, как вы упомянули, boost::optional прекрасно справляется с этой задачей. Так что я бы сказал, что std::function здесь просто ради истории.

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

В этом случае вы обязательно должны разорвать цикл, допустив идентифицируемое недопустимое состояние, которое будет исправлено позже. Таким образом, вы создаете первый элемент как «нулевой», создаете второй элемент и переназначаете первый.

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

Точно так же, как вы можете добавить нулевое состояние к типу функтора, у которого его нет, вы можете обернуть функтор классом, который не допускает нулевое состояние. Первый требует добавления состояния, второй не требует нового состояния (только ограничение). Таким образом, хотя я не знаю, в чем смысл дизайна std::function, он поддерживает наиболее экономичное и среднее использование, независимо от того, что вы хотите.

Ура и чт.,

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

template <typename Callback, typename... Ts>
void SendNotification(const Callback & callback, Ts&&... vs)
{
    if (callback)
    {
        callback(std::forward<Ts>(vs)...);
    }
}

И использовать его следующим образом:

std::function<void(int, double>> myHandler;
...
SendNotification(myHandler, 42, 3.15);