Penanganan Pengecualian C++

Pengecualian adalah masalah yang muncul selama eksekusi program. Pengecualian C++ adalah respons terhadap keadaan luar biasa yang muncul saat program sedang berjalan, seperti upaya untuk membagi dengan nol.

Pengecualian menyediakan cara untuk mentransfer kontrol dari satu bagian program ke bagian lain. Penanganan pengecualian C++ dibangun di atas tiga kata kunci:coba, tangkap, dan melempar .

• melempar Sebuah program melempar pengecualian ketika masalah muncul. Ini dilakukan dengan menggunakan lemparan kata kunci.

• menangkap Sebuah program menangkap eksepsi dengan penangan pengecualian di tempat dalam program di mana Anda ingin menangani masalah tersebut. tangkapan kata kunci menunjukkan penangkapan pengecualian.

• coba coba blok mengidentifikasi blok kode yang pengecualian tertentu akan diaktifkan. Ini diikuti oleh satu atau lebih blok tangkapan.

Dengan asumsi blok akan memunculkan pengecualian, metode menangkap pengecualian menggunakan kombinasi coba dan menangkap kata kunci. Blok coba/tangkap ditempatkan di sekitar kode yang mungkin menghasilkan pengecualian. Kode dalam blok try/catch disebut sebagai kode yang dilindungi, dan sintaks untuk menggunakan try/catch sebagai berikut −

try {
   // protected code
} catch( ExceptionName e1 ) {
   // catch block
} catch( ExceptionName e2 ) {
   // catch block
} catch( ExceptionName eN ) {
   // catch block
}

Anda dapat membuat daftar beberapa tangkapan pernyataan untuk menangkap berbagai jenis pengecualian jika Anda mencoba blok memunculkan lebih dari satu pengecualian dalam situasi yang berbeda.

Melempar Pengecualian

Pengecualian dapat dilempar di mana saja dalam blok kode menggunakan lemparan penyataan. Operand dari pernyataan throw menentukan tipe eksepsi dan dapat berupa ekspresi apa saja dan tipe hasil ekspresi menentukan tipe eksepsi yang dilempar.

Berikut ini adalah contoh pelemparan eksepsi ketika pembagian dengan kondisi nol terjadi

double division(int a, int b) {
   if( b == 0 ) {
      throw "Division by zero condition!";
   }
   return (a/b);
}

Menangkap Pengecualian

tangkapan blokir setelah coba blok menangkap pengecualian apa pun. Anda dapat menentukan jenis pengecualian apa yang ingin Anda tangkap dan ini ditentukan oleh deklarasi pengecualian yang muncul dalam tanda kurung setelah kata kunci catch.

try {
   // protected code
} catch( ExceptionName e ) {
  // code to handle ExceptionName exception
}

Kode di atas akan menangkap pengecualian ExceptionName Tipe. Jika Anda ingin menentukan bahwa blok catch harus menangani semua jenis pengecualian yang dilemparkan ke blok try, Anda harus meletakkan elipsis, ..., di antara tanda kurung yang melampirkan deklarasi pengecualian sebagai berikut −

try {
   // protected code
} catch(...) {
  // code to handle any exception
}

Berikut ini adalah contoh, yang melempar pembagian dengan pengecualian nol dan kami menangkapnya di blok tangkapan.

Demo Langsung

#include <iostream>
using namespace std;

double division(int a, int b) {
   if( b == 0 ) {
      throw "Division by zero condition!";
   }
   return (a/b);
}

int main () {
   int x = 50;
   int y = 0;
   double z = 0;
 
   try {
      z = division(x, y);
      cout << z << endl;
   } catch (const char* msg) {
     cerr << msg << endl;
   }

   return 0;
}

Karena kami memunculkan pengecualian tipe const char* , jadi saat menangkap pengecualian ini, kita harus menggunakan const char* di blok catch. Jika kita mengkompilasi dan menjalankan kode di atas, ini akan menghasilkan hasil sebagai berikut

Division by zero condition!

Pengecualian Standar C++

C++ menyediakan daftar pengecualian standar yang didefinisikan dalam yang dapat kita gunakan dalam program kita. Ini diatur dalam hierarki kelas induk-anak yang ditunjukkan di bawah ini

Berikut adalah deskripsi kecil dari setiap pengecualian yang disebutkan dalam hierarki di atas −

No.No	Pengecualian &Deskripsi
1	std::pengecualian Pengecualian dan kelas induk dari semua pengecualian standar C++.
2	std::bad_alloc Ini dapat dilempar oleh baru .
3	std::bad_cast Ini dapat dilemparkan oleh dynamic_cast .
4	std::bad_exception Ini adalah perangkat yang berguna untuk menangani pengecualian tak terduga dalam program C++.
5	std::bad_typeid Ini dapat dilempar oleh typeid .
6	std::logic_error Pengecualian yang secara teoritis dapat dideteksi dengan membaca kode.
7	std::domain_error Ini adalah pengecualian yang dilontarkan ketika domain yang secara matematis tidak valid digunakan.
8	std::invalid_argument Ini dibuang karena argumen yang tidak valid.
9	std::length_error Ini dilempar ketika std::string yang terlalu besar dibuat.
10	std::out_of_range Ini dapat dilempar dengan metode 'at', misalnya std::vector dan std::bitset<>::operator[]().
11	std::runtime_error Pengecualian yang secara teoritis tidak dapat dideteksi dengan membaca kode.
12	std::overflow_error Ini dilempar jika terjadi overflow matematis.
13	std::range_error Ini terjadi saat Anda mencoba menyimpan nilai yang berada di luar jangkauan.
14	std::underflow_error Ini dilempar jika terjadi underflow matematis.

Tentukan Pengecualian Baru

Anda dapat menentukan pengecualian Anda sendiri dengan mewarisi dan mengganti pengecualian fungsionalitas kelas. Berikut adalah contohnya, yang menunjukkan bagaimana Anda dapat menggunakan kelas std::exception untuk mengimplementasikan pengecualian Anda sendiri dengan cara standar −

Demo Langsung

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

struct MyException : public exception {
   const char * what () const throw () {
      return "C++ Exception";
   }
};
 
int main() {
   try {
      throw MyException();
   } catch(MyException& e) {
      std::cout << "MyException caught" << std::endl;
      std::cout << e.what() << std::endl;
   } catch(std::exception& e) {
      //Other errors
   }
}

Ini akan menghasilkan hasil berikut

MyException caught
C++ Exception

Di sini, apa() adalah metode publik yang disediakan oleh kelas pengecualian dan telah ditimpa oleh semua kelas pengecualian anak. Ini mengembalikan penyebab pengecualian.