Esta es probablemente una pregunta filosófica, pero me encontré con el siguiente problema:

Si define una función std ::, y no la inicializa correctamente, su aplicación se bloqueará, como esta:

typedef std::function<void(void)> MyFunctionType;
MyFunctionType myFunction;
myFunction();

Si la función se pasa como argumento, así:

void DoSomething (MyFunctionType myFunction)
   {
   myFunction();
   }

Entonces, por supuesto, también se bloquea. Esto significa que me veo obligado a agregar un código de verificación como este:

void DoSomething (MyFunctionType myFunction)
   {
   if (!myFunction) return;
   myFunction();
   }

Requirir estas comprobaciones me devuelve un recuerdo de los viejos días C, donde también tenía que verificar todos los argumentos de puntero explícitamente:

void DoSomething (Car *car, Person *person)
   {
   if (!car) return;      // In real applications, this would be an assert of course
   if (!person) return;   // In real applications, this would be an assert of course
   ...
   }

fortunadamente, podemos usar referencias en C ++, lo que me impide escribir estas comprobaciones (suponiendo que la persona que llama no pasó el contenido de un nullptr a la función:

void DoSomething (Car &car, Person &person)
   {
   // I can assume that car and person are valid
   }

Entonces, ¿por qué las instancias std :: function tienen un constructor predeterminado? Sin el constructor predeterminado, no tendría que agregar controles, al igual que para otros argumentos normales de una función. Y en esos casos 'raros' en los que desea pasar una función std :: 'opcional', aún puede pasarle un puntero (o usar boost :: opcional).