#include <iostream>
#include <string>
#include <stdexcept>

double bol(double pay, double payda) {
    if (payda == 0) {
        // std::runtime_error, standart bir istisna sınıfıdır.
        throw std::runtime_error("Sıfıra bölme hatası!");
    }
    return pay / payda;
}

int main() {
    try {
        // Hata potansiyeli olan kod burada
        double sonuc = bol(10, 0);
        std::cout << "Sonuç: " << sonuc << std::endl;
    } catch (const std::runtime_error& e) {
        // std::runtime_error türünde bir istisna yakalandığında çalışır
        std::cerr << "Hata yakalandı: " << e.what() << std::endl;
    } catch (const std::exception& e) {
        // Diğer standart istisnaları yakalamak için genel bir yakalama
        std::cerr << "Genel bir hata oluştu: " << e.what() << std::endl;
    } catch (...) {
        // Bilinmeyen tüm istisnaları yakalamak için
        std::cerr << "Bilinmeyen bir hata yakalandı." << std::endl;
    }
    
    // Programın çalışmaya devam ettiğini gösterelim
    std::cout << "Program devam ediyor..." << std::endl;
    return 0;
}

bol

std::runtime_error

main

try

std::runtime_error

std::logic_error

std::bad_alloc

#include <iostream>
#include <string>
#include <stdexcept>

// std::logic_error'dan türetilmiş özel istisna sınıfımız
class GecersizYasHatasi : public std::logic_error {
public:
    // Kurucu fonksiyon, ana sınıfın kurucusunu çağırır
    explicit GecersizYasHatasi(const std::string& mesaj)
        : std::logic_error("Geçersiz Yaş Hatası: " + mesaj) {}
};

void kullaniciKaydet(int yas) {
    if (yas < 0 || yas > 120) {
        // Geçersiz yaş durumunda kendi istisnamızı fırlatıyoruz
        throw GecersizYasHatasi("Yaş 0 ile 120 arasında olmalıdır.");
    }
    std::cout << "Kullanıcı başarıyla kaydedildi, Yaş: " << yas << std::endl;
}

int main() {
    try {
        kullaniciKaydet(30);
        kullaniciKaydet(200); // Bu çağrı bir istisna fırlatacak
    } catch (const GecersizYasHatasi& e) {
        std::cerr << "Özel hata yakalandı: " << e.what() << std::endl;
    } catch (const std::exception& e) {
        // Diğer tüm std::exception türevlerini yakalar
        std::cerr << "Genel bir std::exception hatası oluştu: " << e.what() << std::endl;
    } catch (...) {
        // Kalan tüm istisnaları yakalar (çok geneldir, dikkatli kullanılmalı)
        std::cerr << "Bilinmeyen bir türde hata yakalandı." << std::endl;
    }
    
    std::cout << "Uygulama devam ediyor." << std::endl;
    return 0;
}

#include <fstream>
#include <stdexcept>
#include <iostream>
#include <string>

class DosyaYoneticisi {
private:
    std::ofstream dosya;
    std::string dosyaAdi;
public:
    // Yapıcı fonksiyon: Kaynak (dosya) edinilir
    DosyaYoneticisi(const std::string& adi) : dosyaAdi(adi) {
        dosya.open(dosyaAdi);
        if (!dosya.is_open()) {
            throw std::runtime_error("Dosya açılamadı: " + dosyaAdi);
        }
        std::cout << "Dosya başarıyla açıldı: " << dosyaAdi << std::endl;
    }
    
    // Yıkıcı fonksiyon: Kaynak (dosya) serbest bırakılır
    ~DosyaYoneticisi() {
        if (dosya.is_open()) {
            dosya.close();
            std::cout << "Dosya kapatıldı: " << dosyaAdi << std::endl;
        }
    }
    
    // Kopya yapıcı ve atama operatörü silinmeli veya doğru yönetilmeli
    // (kaynakların sahipliğini düzgün devretmek için)
    DosyaYoneticisi(const DosyaYoneticisi&) = delete;
    DosyaYoneticisi& operator=(const DosyaYoneticisi&) = delete;

    void yaz(const std::string& metin) {
        if (dosya.is_open()) {
            dosya << metin << std::endl;
        } else {
            throw std::runtime_error("Dosya yazmak için açık değil.");
        }
    }
};

void dosyaIslemiOrnek(const std::string& dosyaAdi) {
    try {
        DosyaYoneticisi yonetici(dosyaAdi);
        yonetici.yaz("Bu bir deneme metnidir.");
        // Diyelim ki burada beklenmedik bir hata oluştu ve istisna fırlatıldı
        throw std::runtime_error("Dosya yazma işleminde bir sorun oluştu!");
        yonetici.yaz("Bu metin asla yazılmayacak.");
    } catch (const std::exception& e) {
        std::cerr << "Hata yakalandı: " << e.what() << std::endl;
    }
    // yonetici nesnesinin yıkıcısı burada çağrılır, dosya otomatik kapanır
    std::cout << "Dosya işlemi tamamlandı (veya hata ile kesildi)." << std::endl;
}

int main() {
    dosyaIslemiOrnek("ornek.txt");
    // Programdan çıkarken DosyaYoneticisi'nin yıkıcısının çağrıldığını gözlemleyebiliriz.
    return 0;
}

DosyaYoneticisi

~DosyaYoneticisi()

noexcept

noexcept

std::terminate()

void guvenliIslem() noexcept {
    // Bu fonksiyonun istisna fırlatmaması garanti edilir.
    // Eğer fırlatırsa, std::terminate çağrılır.
    std::cout << "Guvenli islem yapiliyor..." << std::endl;
    // throw std::runtime_error("Bu bir hatadir!"); // BU SATIR YORUMDADIR, AKSI TAKDIRDE TERMINATE CAGIRILIR!
}

void potansiyelHataIslem() {
    // Bu fonksiyon istisna fırlatabilir (noexcept olarak işaretlenmedi).
    std::cout << "Potansiyel hata olabilecek islem yapiliyor..." << std::endl;
    // throw std::runtime_error("Beklenmedik bir hata!"); // Hata fırlatılabilir
}

int main() {
    try {
        guvenliIslem();
        potansiyelHataIslem();
    } catch (const std::exception& e) {
        std::cerr << "Hata yakalandı (main'de): " << e.what() << std::endl;
    }
    return 0;
}