std::runtime_error în C++

Excepție pentru erorile care apar doar la rulare, din cauze externe: fișier lipsă, rețea, date greșite.

Sintaxă
#include <stdexcept>
throw std::runtime_error("mesaj");

Ce face std::runtime_error

std::runtime_error este excepția de folosit pentru probleme pe care programul nu le putea evita prin cod corect: un fișier care nu există, o conexiune căzută, un răspuns invalid de la server. Mesajul dat constructorului este returnat de what().

Biblioteca are câteva clase derivate: std::overflow_error, std::underflow_error, std::range_error, iar std::system_error și std::filesystem::filesystem_error moștenesc tot din ea. Pentru greșeli de logică ale programatorului (argumente invalide, index greșit) există familia std::logic_error.

Poți moșteni std::runtime_error pentru excepțiile tale: primești gratuit mesajul și what().

Parametri

Parametru Descriere
mesaj Textul erorii (std::string sau const char*).

Ce returnează

Un obiect excepție, de aruncat cu throw.

Exemple

Exemplul 1: Fișier care nu poate fi deschis

#include <fstream>
#include <print>
#include <stdexcept>
#include <string>

std::string citestePrimaLinie(const std::string& cale) {
    std::ifstream f(cale);
    if (!f) throw std::runtime_error("Nu pot deschide " + cale);
    std::string linie;
    std::getline(f, linie);
    return linie;
}

int main() {
    std::ofstream("salut.txt") << "Bună ziua din Iași\n";

    for (const char* cale : {"salut.txt", "lipsa.txt"}) {
        try {
            std::println("{}", citestePrimaLinie(cale));
        } catch (const std::runtime_error& e) {
            std::println("Eroare: {}", e.what());
        }
    }
}

Rezultat

Bună ziua din Iași
Eroare: Nu pot deschide lipsa.txt

Exemplul 2: Clasă proprie derivată

#include <print>
#include <stdexcept>
#include <string>

class EroarePlata : public std::runtime_error {
public:
    EroarePlata(const std::string& mesaj, int cod)
        : std::runtime_error(mesaj), cod_(cod) {}
    int cod() const { return cod_; }
private:
    int cod_;
};

int main() {
    try {
        throw EroarePlata("Card expirat", 54);
    } catch (const EroarePlata& e) {
        std::println("{} (cod {})", e.what(), e.cod());
    }
}

Rezultat

Card expirat (cod 54)

Greșeli frecvente

  • Arunci excepții pentru situații normale (de exemplu „utilizatorul nu a fost găsit” la o căutare). Excepțiile sunt pentru erori; pentru rezultate care pot lipsi folosește std::optional sau std::expected.
  • Arunci un text simplu: throw "eroare";. Tipul aruncat este const char*, care nu este prins de catch (const std::exception&).

Comenzi înrudite

  • std::exception: Clasa de bază a tuturor excepțiilor din biblioteca standard; what() returnează mesajul erorii.
  • std::logic_error: Excepție pentru greșeli de logică ce puteau fi evitate prin cod corect; domain_error: valoare în afara domeniului.
  • std::overflow_error: Excepție pentru un rezultat prea mare ca să încapă în tipul folosit (depășire aritmetică).
  • throw: Aruncă o excepție: oprește execuția normală și trimite eroarea la cel mai apropiat catch potrivit.
  • std::expected: Rezultatul unei operații care poate eșua: conține fie valoarea (T), fie motivul erorii (E).