Va bene lanciare un'eccezione nel normale percorso del codice che elimina un possibile errore del programmatore? [duplicare]

So che l'eccezione dovrebbe essere generata in casi eccezionali (ad es. memoria insufficiente, errore del programmatore). In questi casi, non devo preoccuparmi delle prestazioni che generano queste eccezioni.

Ma cosa succede se si usa l'eccezione nel normale percorso del codice?

Nel mio caso, usalo per fermare la funzione fornita dal codice utente.

Quindi per un dato codice, foo è migliore o foo2 migliore?

È molto probabile che outputFunc restituisca l'eccezione false / throw.

// library provided function
void foo(std::function<void(std::function<bool(int)>)>);

// how user suppose to use it
foo([](std::function<bool(int)> outputFunc){
    while (/*condition*/)
    {
        // user have to check the return value and stop work when it return false
        if (!outputFunc(/*some value*/)) return; 
    }
});

// library provided function
void foo2(std::function<void(std::function<void(int)>)>);

// how user suppose to use it
foo2([](std::function<void(int)> outputFunc){
    while (/*condition*/)
    {
       // this will throw exception and handled internally when it should stop
       // user does not have to check the return value but they need to write exception-safe code
        outputFunc(/*some value*/));
    }
});

Nel mio caso, l'uso dell'eccezione elimina un possibile errore del programmatore (non controllando il valore di ritorno di outputFunc ) e rende il codice più facile da scrivere (non è necessario controllare il valore di ritorno)

E l'eccezione è throw / catch internamente, nessun codice utente richiesto per gestirli (eccetto che hanno bisogno di scrivere codice eccezionalmente sicuro nel lambda, ma dovremmo sempre scrivere codice eccezionalmente sicuro)