`std::logic_error` în C++

Excepție pentru greșeli de logică ce puteau fi evitate prin cod corect; domain_error: valoare în afara domeniului.

Sintaxă

#include <stdexcept>
throw std::logic_error("mesaj");
throw std::domain_error("mesaj");

Ce face `std::logic_error`

std::logic_error semnalează o eroare de logică: o condiție care nu ar trebui să apară într-un program corect (o precondiție încălcată, o ordine greșită a apelurilor). Clasele derivate sunt mai precise: std::invalid_argument, std::out_of_range, std::length_error, std::domain_error.

std::domain_error înseamnă că argumentul este în afara domeniului de definiție al unei funcții matematice (de exemplu radical dintr-un număr negativ, într-o funcție scrisă de tine). Funcțiile matematice standard (std::sqrt) nu aruncă, ci returnează NaN.

Parametri

Parametru	Descriere
`mesaj`	Textul erorii.

Ce returnează

Un obiect excepție, de aruncat cu throw.

Exemple

Exemplul 1: Ordine greșită a apelurilor

#include <print>
#include <stdexcept>

class Comanda {
public:
    void plateste() { platita_ = true; }
    void livreaza() {
        if (!platita_) throw std::logic_error("Comanda trebuie plătită înainte de livrare");
        std::println("Comanda a fost livrată");
    }
private:
    bool platita_ = false;
};

int main() {
    Comanda c;
    try {
        c.livreaza();
    } catch (const std::logic_error& e) {
        std::println("Eroare: {}", e.what());
    }
    c.plateste();
    c.livreaza();
}

Rezultat

Eroare: Comanda trebuie plătită înainte de livrare
Comanda a fost livrată

Exemplul 2: domain_error pentru o funcție matematică

Ambele clase derivă din std::logic_error, deci al doilea catch le-ar prinde și pe ele.

#include <cmath>
#include <print>
#include <stdexcept>

double radical(double x) {
    if (x < 0) throw std::domain_error("radical dintr-un număr negativ");
    return std::sqrt(x);
}

int main() {
    for (double x : {16.0, -4.0}) {
        try {
            std::println("radical({}) = {}", x, radical(x));
        } catch (const std::domain_error& e) {
            std::println("domain_error: {}", e.what());
        } catch (const std::logic_error& e) {
            std::println("logic_error: {}", e.what());
        }
    }
}