Exception C++: throw, what(), dan Penanganan Error

Kenapa Exception Ada

Di halaman sebelumnya kamu memakai enum class untuk memberi nama yang bermakna pada keadaan error. Itu bagus untuk hasil yang memang diperkirakan sebuah fungsi dan seharusnya diperiksa oleh pemanggil. Namun beberapa kegagalan berbeda: sebuah fungsi yang berada jauh di dalam call stack menemukan bahwa sebuah file tidak mau terbuka, atau sebuah argumen tidak masuk akal, dan fungsi itu tidak tahu apa yang harus dilakukan program. Mengembalikan kode error hanya berhasil kalau setiap pemanggil di sepanjang rantai ingat untuk mengeceknya dan meneruskannya ke atas. Lewatkan satu pengecekan, dan program terus berjalan dengan data sampah.

Exception menyelesaikan masalah ini. Saat terjadi kesalahan, kamu melempar (throw) sebuah objek. Eksekusi langsung berhenti, stack di-unwind (setiap objek lokal di antara titik throw dan penanganannya menjalankan destructor-nya), dan kendali melompat ke catch terdekat yang cocok. Exception yang tidak ditangani tidak bisa diabaikan diam-diam: kalau tidak ada yang menangkapnya, program memanggil std::terminate dan berhenti.

#include <iostream>
#include <stdexcept>
using namespace std;

int divide(int a, int b) {
    if (b == 0) {
        throw runtime_error("division by zero");
    }
    return a / b;
}

int main() {
    try {
        cout << divide(10, 2) << "\n";   // 5
        cout << divide(10, 0) << "\n";   // throws before printing
    } catch (const runtime_error& e) {
        cout << "caught: " << e.what() << "\n";
    }
    return 0;
}

Halaman ini berfokus pada sisi pelemparan, yaitu objek error-nya sendiri. Halaman berikutnya membahas mekanisme try/catch secara mendetail.

Melempar Exception dan Pesan what()

Secara teknis kamu bisa melempar (throw) nilai apa saja; throw 42; atau throw "oops"; itu sah, tetapi jangan lakukan. Konvensi yang diikuti semua orang adalah melempar objek yang diturunkan dari std::exception. Base class itu mendeklarasikan satu method virtual, what(), yang mengembalikan const char* berisi penjelasan masalahnya. Mengikuti konvensi ini berarti satu catch (const std::exception& e) bisa menangani apa saja.

Header <stdexcept> menyediakan tipe siap pakai yang constructor-nya menerima pesan:

#include <iostream>
#include <stdexcept>
#include <string>
using namespace std;

int main() {
    string user = "guest";
    try {
        throw runtime_error("user '" + user + "' is not authorized");
    } catch (const exception& e) {
        cout << e.what() << "\n";   // user 'guest' is not authorized
    }
    return 0;
}

Perhatikan bahwa what() mengembalikan string yang persis sama dengan yang kamu pakai untuk membuat exception itu. Perhatikan juga bahwa kita menangkapnya dengan const exception& meskipun yang dilempar adalah runtime_error. Ini berhasil karena runtime_error adalah sebuah std::exception (hubungan yang akan kamu kenali dari halaman pewarisan).

Hierarki Exception Standar

Sebelum menulis tipe exception sendiri, cek dulu apakah standard library sudah punya yang cocok. Semuanya diturunkan dari std::exception dan terbagi menjadi dua keluarga di <stdexcept>:

• logic_error: bug di logika program yang, secara prinsip, bisa ditangkap sebelum program dijalankan. Subtipenya antara lain invalid_argument, out_of_range, domain_error, dan length_error.
• runtime_error: kegagalan yang hanya muncul saat program berjalan dan bukan kesalahan pemrograman itu sendiri. Subtipenya antara lain range_error, overflow_error, dan underflow_error.

Banyak fungsi library melempar exception ini untukmu. Misalnya, at() milik container vector mengecek batas dan melempar out_of_range alih-alih membiarkanmu membaca melewati ujungnya:

#include <iostream>
#include <vector>
#include <stdexcept>
using namespace std;

int main() {
    vector<int> v = {10, 20, 30};

    try {
        cout << v.at(1) << "\n";   // 20
        cout << v.at(9) << "\n";   // out of range -> throws
    } catch (const out_of_range& e) {
        cout << "bad index: " << e.what() << "\n";
    }
    return 0;
}

at() itu adalah pasangan aman dari v[9]. operator[] biasa tidak mengecek batas: membaca v[9] di sini adalah undefined behavior, bukan exception. Memilih at() adalah cara mengubah kerusakan diam-diam menjadi error yang bisa ditangkap.

Pilih tipe yang menggambarkan error-nya: invalid_argument saat pemanggil memberikan sesuatu yang tidak masuk akal, out_of_range untuk masalah indeks/key, runtime_error untuk "dunia luar gagal saat aku memakainya."

#include <iostream>
#include <stdexcept>
#include <cmath>
using namespace std;

double safe_sqrt(double x) {
    if (x < 0) {
        throw invalid_argument("safe_sqrt: x must be non-negative");
    }
    return sqrt(x);
}

int main() {
    try {
        cout << safe_sqrt(16) << "\n";   // 4
        cout << safe_sqrt(-1) << "\n";   // throws
    } catch (const invalid_argument& e) {
        cout << "error: " << e.what() << "\n";
    }
    return 0;
}

Menulis Tipe Exception Sendiri

Kalau tidak ada tipe standar yang cocok, misalnya kamu ingin melampirkan data tambahan, atau ingin menangkap (catch) error-mu secara khusus dan tidak yang lain, definisikan class yang diturunkan dari std::exception (atau salah satu subtipenya) dan override what(). Menurunkan dari std::runtime_error adalah jalan termudah, karena class itu sudah menyimpan pesannya dan mengimplementasikan what() untukmu:

#include <iostream>
#include <stdexcept>
#include <string>
using namespace std;

class NetworkError : public runtime_error {
    int status_;
public:
    NetworkError(int status, const string& msg)
        : runtime_error(msg), status_(status) {}

    int status() const { return status_; }
};

int main() {
    try {
        throw NetworkError(503, "service unavailable");
    } catch (const NetworkError& e) {
        cout << "HTTP " << e.status() << ": " << e.what() << "\n";
    } catch (const exception& e) {
        cout << "other error: " << e.what() << "\n";
    }
    return 0;
}

Karena NetworkError membawa kode status, penanganannya bisa bereaksi terhadapnya: coba lagi untuk 5xx, menyerah untuk 4xx. String error biasa tidak bisa melakukan itu. Tipe buatan sendiri juga membuat catch (const NetworkError&) hanya menangkap masalah jaringan dan menyerahkan semua yang lain ke penanganan yang lebih umum di bawahnya.

Kalau kamu menurunkan langsung dari std::exception (bukan runtime_error), ingat untuk meng-override what() sendiri, dan tandai dengan noexcept agar cocok dengan signature base class-nya:

class ParseError : public std::exception {
public:
    const char* what() const noexcept override {
        return "failed to parse input";
    }
};

Throw by Value, Catch by Reference

Inilah aturan paling penting dari exception C++, dan yang paling sering salah dilakukan pemula. Lempar objek by value dan tangkap by referensi const.

throw runtime_error("oops");            // by value - correct
catch (const runtime_error& e) { ... }  // by const reference - correct

Menangkap by value, misalnya catch (std::exception e), menyalin exception ke objek base class dan memotong (slicing) bagian turunannya. Setelah terpotong, e.what() memanggil implementasi base, bukan versi yang kamu override, sehingga pesan yang kamu susun dengan cermat menghilang:

try {
    throw NetworkError(503, "service unavailable");
} catch (std::exception e) {       // by value - object slicing!
    std::cout << e.what();         // generic message, status() is gone
}

Referensi (&) mempertahankan tipe dinamis yang sebenarnya, sehingga what() yang virtual dipanggil dengan benar dan kamu tetap bisa mengakses member turunannya. Tambahkan const karena kamu hanya membaca exception itu, tidak mengubahnya. Jangan pernah melempar pointer (throw new runtime_error(...)): penangkapnya harus melakukan delete, tetapi di jalur kode yang mana? Itulah persis kebocoran yang seharusnya dicegah oleh exception.

Berikutnya: try-catch

Sekarang kamu bisa membuat dan melempar (throw) exception yang tersusun dengan baik serta memilih tipe standar yang tepat untuk setiap kegagalan. Separuh cerita lainnya adalah sisi penangkapan. Halaman berikutnya membahas try/catch secara lengkap: mengurutkan beberapa blok catch dari yang paling spesifik ke yang paling umum, catch-all catch (...), melempar ulang dengan throw; saja, dan bagaimana RAII (ingat kembali smart pointer) menjamin resource-mu dilepaskan saat stack di-unwind.