Esta é provavelmente uma pergunta filosófica, mas me deparei com o seguinte problema:

Se você definir uma função std :: e não a inicializar corretamente, seu aplicativo falhará assim:

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

Se a função for passada como argumento, assim:

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

Então, é claro, também trava. Isso significa que sou obrigado a adicionar código de verificação como este:

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

Exigir essas verificações me dá um retorno aos velhos dias C, onde você também tinha que verificar todos os argumentos do ponteiro explicitament

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
   ...
   }

elizmente, podemos usar referências em C ++, o que me impede de escrever essas verificações (supondo que o chamador não tenha passado o conteúdo de um nullptr para a função:

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

Então, por que as instâncias std :: function têm um construtor padrão? Sem o construtor padrão, você não precisaria adicionar verificações, assim como outros argumentos normais de uma função. E naqueles casos 'raros' em que você deseja passar uma função std :: 'opcional', você ainda pode passar um ponteiro para ela (ou usar o impulso :: opcional