Bagikan melalui

Fungsi <exception>

  • Artikel

current_exception

Mendapatkan penunjuk cerdas ke pengecualian saat ini.

exception_ptr current_exception();

Tampilkan Nilai

Objek exception_ptr menunjuk ke pengecualian saat ini.

Keterangan

current_exception Panggil fungsi dalam blok tangkapan. Jika pengecualian dalam penerbangan dan blok tangkapan dapat menangkap pengecualian, current_exception fungsi mengembalikan exception_ptr objek yang mereferensikan pengecualian. Jika tidak, fungsi mengembalikan objek null exception_ptr .

Fungsi ini current_exception menangkap pengecualian yang sedang dalam penerbangan terlepas dari apakah catch pernyataan menentukan pernyataan deklarasi pengecualian.

Destruktor untuk pengecualian saat ini dipanggil di akhir catch blok jika Anda tidak menumbuhkan kembali pengecualian. Namun, bahkan jika Anda memanggil current_exception fungsi di destruktor, fungsi mengembalikan exception_ptr objek yang mereferensikan pengecualian saat ini.

Panggilan berturut-turut ke current_exception objek pengembalian exception_ptr fungsi yang merujuk ke salinan yang berbeda dari pengecualian saat ini. Akibatnya, objek membandingkan sebagai tidak sama karena merujuk ke salinan yang berbeda, meskipun salinan memiliki nilai biner yang sama.

make_exception_ptr

Membuat objek exception_ptr yang menyimpan salinan pengecualian.

template <class E>
    exception_ptr make_exception_ptr(E Except);

Parameter

Kecuali
Kelas dengan pengecualian untuk disalin. Biasanya, Anda menentukan objek kelas pengecualian sebagai argumen ke make_exception_ptr fungsi, meskipun objek kelas apa pun dapat menjadi argumen.

Tampilkan Nilai

Objek exception_ptr menunjuk ke salinan pengecualian saat ini untuk Kecuali.

Keterangan

Memanggil make_exception_ptr fungsi setara dengan melemparkan pengecualian C++, menangkapnya di blok tangkapan, lalu memanggil fungsi current_exception untuk mengembalikan exception_ptr objek yang mereferensikan pengecualian. Implementasi Microsoft dari make_exception_ptr fungsi ini lebih efisien daripada melemparkan dan kemudian menangkap pengecualian.

Aplikasi biasanya tidak memerlukan make_exception_ptr fungsi, dan kami mencegah penggunaannya.

rethrow_exception

Melempar pengecualian yang diteruskan sebagai parameter.

void rethrow_exception(exception_ptr P);

Parameter

P
Pengecualian tertangkap untuk melemparkan kembali. Jika P adalah exception_ptr null, fungsi akan melempar std::bad_exception.

Keterangan

Setelah Anda menyimpan pengecualian yang tertangkap dalam exception_ptr objek, utas utama dapat memproses objek. Di utas utama Anda, panggil rethrow_exception fungsi bersama dengan exception_ptr objek sebagai argumennya. Fungsi ini rethrow_exception mengekstrak pengecualian dari exception_ptr objek dan kemudian melemparkan pengecualian dalam konteks utas utama.

get_terminate

Mendapatkan fungsi saat ini terminate_handler .

terminate_handler get_terminate();

set_terminate

Menetapkan yang baru terminate_handler untuk dipanggil pada penghentian program.

terminate_handler set_terminate(terminate_handler fnew) throw();

Parameter

fnew
Fungsi yang akan dipanggil saat penghentian.

Tampilkan Nilai

Alamat fungsi sebelumnya yang digunakan untuk dipanggil saat penghentian.

Keterangan

Fungsi ini menetapkan terminate_handler baru sebagai fungsi * fnew. Dengan demikian, fnew tidak boleh menjadi pointer null. Fungsi mengembalikan alamat handler penghentian sebelumnya.

Contoh

// exception_set_terminate.cpp
// compile with: /EHsc
#include <exception>
#include <iostream>

using namespace std;

void termfunction()
{
    cout << "My terminate function called." << endl;
    abort();
}

int main()
{
    terminate_handler oldHandler = set_terminate(termfunction);

    // Throwing an unhandled exception would also terminate the program
    // or we could explicitly call terminate();

    //throw bad_alloc();
    terminate();
}

get_unexpected

Mendapatkan fungsi saat ini unexpected_handler .

unexpected_handler get_unexpected();

rethrow_if_nested

template <class E>
    void rethrow_if_nested(const E& e);

Keterangan

Jika bukan jenis kelas polimorfik, atau jika nested_exception tidak dapat diakses atau ambigu, tidak ada efek. Jika tidak, lakukan pemeran dinamis.

set_unexpected

Menetapkan baru unexpected_handler untuk menjadi ketika pengecualian tak terduga ditemui.

unexpected_handler set_unexpected(unexpected_handler fnew) throw();

Parameter

fnew
Fungsi yang akan dipanggil ketika pengecualian tak terduga ditemui.

Tampilkan Nilai

Alamat dari sebelumnya unexpected_handler.

Keterangan

fnew tidak boleh menjadi pointer null.

Standar C++ mengharuskan yang unexpected dipanggil ketika fungsi melemparkan pengecualian yang tidak ada dalam daftar lemparannya. Implementasi saat ini tidak mendukung ini. Contoh berikut memanggil unexpected secara langsung, yang kemudian memanggil unexpected_handler.

Contoh

// exception_set_unexpected.cpp
// compile with: /EHsc
#include <exception>
#include <iostream>

using namespace std;

void uefunction()
{
    cout << "My unhandled exception function called." << endl;
    terminate(); // this is what unexpected() calls by default
}

int main()
{
    unexpected_handler oldHandler = set_unexpected(uefunction);

    unexpected(); // library function to force calling the
                  // current unexpected handler
}

terminate

Memanggil handler penghentian.

void terminate();

Keterangan

Fungsi ini memanggil handler penghentian, fungsi jenis void. Jika terminate dipanggil langsung oleh program, handler penghentian adalah yang terakhir diatur oleh panggilan ke set_terminate. Jika terminate dipanggil karena salah satu dari beberapa alasan lain selama evaluasi ekspresi lemparan, handler penghentian adalah yang berlaku segera setelah mengevaluasi ekspresi lemparan.

Handler penghentian mungkin tidak kembali ke pemanggilnya. Pada startup program, handler penghentian adalah fungsi yang memanggil abort.

Contoh

Lihat set_unexpected untuk contoh penggunaan terminate.

throw_with_nested

template <class T> [[noreturn]]
    void throw_with_nested(T&& t);

Keterangan

Melemparkan pengecualian dengan pengecualian berlapis.

uncaught_exception

Mengembalikan hanya jika pengecualian yang dilemparkan saat ini sedang diproses true .

bool uncaught_exception();

Tampilkan Nilai

Mengembalikan setelah menyelesaikan evaluasi ekspresi lemparan dan sebelum menyelesaikan inisialisasi true deklarasi pengecualian di handler yang cocok atau panggilan yang tidak terduga sebagai akibat dari ekspresi lemparan. Secara khusus, uncaught_exception akan kembali true ketika dipanggil dari destruktor yang sedang dipanggil selama pengecualian melepas lelah. Pada perangkat, uncaught_exception hanya didukung pada Windows CE 5.00 dan versi yang lebih tinggi, termasuk platform Windows Mobile 2005.

Contoh

// exception_uncaught_exception.cpp
// compile with: /EHsc
#include <exception>
#include <iostream>
#include <string>

class Test
{
public:
   Test( std::string msg ) : m_msg( msg )
   {
      std::cout << "In Test::Test(\"" << m_msg << "\")" << std::endl;
   }
   ~Test( )
   {
      std::cout << "In Test::~Test(\"" << m_msg << "\")" << std::endl
         << "        std::uncaught_exception( ) = "
         << std::uncaught_exception( )
         << std::endl;
   }
private:
    std::string m_msg;
};

// uncaught_exception will be true in the destructor
// for the object created inside the try block because
// the destructor is being called as part of the unwind.

int main( void )
   {
      Test t1( "outside try block" );
      try
      {
         Test t2( "inside try block" );
         throw 1;
      }
      catch (...) {
   }
}

In Test::Test("outside try block")
In Test::Test("inside try block")
In Test::~Test("inside try block")
        std::uncaught_exception( ) = 1
In Test::~Test("outside try block")
        std::uncaught_exception( ) = 0

tidak terduga

Memanggil handler yang tidak terduga.

void unexpected();

Keterangan

Standar C++ mengharuskan yang unexpected dipanggil ketika fungsi melemparkan pengecualian yang tidak ada dalam daftar lemparannya. Implementasi saat ini tidak mendukung ini. Contoh memanggil unexpected secara langsung, yang memanggil handler yang tidak terduga.

Fungsi ini memanggil handler yang tidak terduga, fungsi jenis void. Jika unexpected dipanggil langsung oleh program, handler yang tidak terduga adalah yang terakhir diatur oleh panggilan ke set_unexpected.

Handler tak terduga mungkin tidak kembali ke pemanggilnya. Ini dapat mengakhiri eksekusi dengan:

  • Melempar objek jenis yang tercantum dalam spesifikasi pengecualian atau objek dari jenis apa pun jika handler yang tidak terduga dipanggil langsung oleh program.

  • Melempar objek jenis bad_exception.

  • Panggilan dihentikan, abort atau exit.

Pada startup program, handler tak terduga adalah fungsi yang memanggil dihentikan.

Contoh

Lihat set_unexpected untuk contoh penggunaan unexpected.