Waarom moet je het gegevenstype double niet gebruiken voor uitzonderingen?

Het gebruik van drijvende-kommagetallen, zoals double, voor uitzonderingen wordt om verschillende redenen niet aanbevolen:

• Onnauwkeurigheid van de representatie: Waarden van het type double kunnen afrondingsfouten bevatten vanwege hun interne representatie als drijvende-kommagetallen. Bij het vergelijken van uitzonderingen kan dit leiden tot valse positieven of gemiste fouten.
• Gebrek aan semantiek van de fout: double heeft geen expliciete semantiek om een specifiek type fout aan te duiden. Uitzonderingen moeten duidelijk aangeven wat er precies is gebeurd, wat het afhandelen en debuggen vergemakkelijkt.
• Complexiteit in verwerking: Het opvangen en verwerken van een uitzondering die slechts een numerieke waarde is, bemoeilijkt het schrijven van begrijpelijke en betrouwbare code.
• Gespecialiseerde uitzonderingsklassen: C++ biedt een idiomatische manier om met fouten om te gaan via gespecialiseerde uitzonderingsklassen die erven van std::exception. Dit is leesbaarder, uitbreidbaarder en veiliger.

In plaats van double voor uitzonderingen, moet je gebruiken:

• Standaard uitzonderingsklassen (bijvoorbeeld std::runtime_error, std::logic_error).
• Aangepaste uitzonderingsklassen die erven van std::exception om specifieke fouten weer te geven.

// Voorbeeld van gebruik van een standaard uitzondering
#include <iostream>
#include <stdexcept>

void process_data(double value) {
    if (value < 0) {
        // Gebruik van een gespecialiseerde uitzondering in plaats van double
        throw std::invalid_argument("Waarde moet niet-negatief zijn.");
    }
    // ... gegevensverwerking
}

int main() {
    try {
        process_data(-1.0);
    } catch (const std::exception& e) {
        std::cerr << "Fout: " << e.what() << std::endl;
    }
    return 0;
}