الاستثناءات في C++: throw وwhat() ومعالجة الأخطاء

لماذا توجد الاستثناءات

في الصفحة السابقة استخدمت enum class لتمنح حالات الخطأ أسماءً ذات معنى. هذا ممتاز للنتائج التي تتوقعها الدالة ويُفترض أن يفحصها المُستدعي. لكن بعض حالات الفشل مختلفة: دالة في عمق مكدّس الاستدعاءات لديك تكتشف أن ملفًا لا يُفتح، أو أن وسيطًا لا معنى له، وهي لا تملك أدنى فكرة عمّا ينبغي للبرنامج فعله حيال ذلك. إرجاع رمز خطأ لا ينجح إلا إذا تذكّر كل مُستدعٍ في السلسلة فحصه وتمريره إلى الأعلى. أهمِل فحصًا واحدًا فقط، فيمضي البرنامج مبحرًا ببيانات تالفة.

الاستثناءات تحلّ هذا. عندما يحدث خطأ ما، تُطلق كائنًا باستخدام throw. يتوقف التنفيذ فورًا، ويُفرَّغ المكدّس (فيُشغَّل المُدمِّر لكل كائن محلي بين الإطلاق والمعالِج)، ويقفز التحكّم إلى أقرب catch مطابق. لا يمكن تجاهل استثناء غير معالَج بصمت: إن لم يلتقطه شيء، يستدعي البرنامج std::terminate ويُجهَض.

#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";   // يُطلق الاستثناء قبل الطباعة
    } catch (const runtime_error& e) {
        cout << "caught: " << e.what() << "\n";
    }
    return 0;
}

تركّز هذه الصفحة على جانب الإطلاق، أي كائنات الخطأ نفسها. أما الصفحة التالية فتتعمّق في آلية try/catch بالتفصيل.

الإطلاق ورسالة what()

تقنيًا يمكنك أن تُطلق (throw) أي قيمة —throw 42; أو throw "oops"; كلاهما قانوني— لكن لا تفعل ذلك. العُرف الذي يتبعه الجميع هو إطلاق كائن مشتق من std::exception. يعلن هذا الصنف الأساسي عن دالة افتراضية واحدة، what()، تُرجع وصفًا من نوع const char* للمشكلة. الالتزام بالعُرف يعني أن catch (const std::exception& e) واحدة تستطيع معالجة أي شيء.

تمنحك ترويسة <stdexcept> أنواعًا جاهزة يأخذ مُنشِئها الرسالة:

#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;
}

لاحظ أن what() تُرجع السلسلة النصية ذاتها التي أنشأت بها الاستثناء. ولاحظ أيضًا أننا التقطناه باستخدام const exception& رغم أننا أطلقنا runtime_error؛ وهذا ينجح لأن runtime_error هو std::exception (علاقة ستعرفها من صفحة الوراثة).

تسلسل الاستثناءات القياسي

قبل أن تكتب نوع استثناء خاصًا بك، تحقّق ممّا إذا كانت المكتبة القياسية تملك بالفعل نوعًا مناسبًا. جميعها ترث من std::exception وتنقسم إلى عائلتين في <stdexcept>:

• logic_error — عيب في منطق البرنامج كان يمكن، مبدئيًا، اكتشافه قبل التشغيل. تشمل أنواعه الفرعية invalid_argument وout_of_range وdomain_error وlength_error.
• runtime_error — فشل لا يظهر إلا أثناء التشغيل وليس خطأ برمجيًا بحدّ ذاته. تشمل أنواعه الفرعية range_error وoverflow_error وunderflow_error.

كثير من دوال المكتبة تُطلق هذه نيابةً عنك. على سبيل المثال، تُجري std::vector::at() فحصًا للحدود وتُطلق out_of_range بدلًا من السماح لك بالقراءة بعد النهاية:

#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";   // خارج النطاق -> يُطلق الاستثناء
    } catch (const out_of_range& e) {
        cout << "bad index: " << e.what() << "\n";
    }
    return 0;
}

هذه الدالة at() هي النظير الآمن لـ v[9]. أما operator[] العادي فلا يُجري أي فحص للحدود: قراءة v[9] هنا سلوك غير معرَّف، وليست استثناءً. اختيار at() هو الطريقة التي تحوّل بها فسادًا صامتًا إلى خطأ يمكن التقاطه.

اختر النوع الذي يصف الخطأ: invalid_argument عندما يمرّر المُستدعي شيئًا بلا معنى، وout_of_range لمشكلات الفهرس/المفتاح، وruntime_error لحالات "العالم الخارجي خذلني".

#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";   // يُطلق الاستثناء
    } catch (const invalid_argument& e) {
        cout << "error: " << e.what() << "\n";
    }
    return 0;
}

كتابة نوع استثناء خاص بك

عندما لا يناسبك أي نوع قياسي —تريد إرفاق بيانات إضافية، أو التقاط (catch) خطئك تحديدًا دون سواه— عرِّف صنفًا يرث من std::exception (أو من أحد أنواعه الفرعية) وأعِد تعريف what(). الوراثة من std::runtime_error هي أسهل طريق، لأنه يخزّن الرسالة بالفعل ويُنفّذ what() نيابةً عنك:

#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;
}

بما أن NetworkError يحمل رمز حالة، يستطيع المعالِج أن يتفاعل معه: يعيد المحاولة عند 5xx، ويستسلم عند 4xx. سلسلة خطأ مجرّدة لم تكن لتقدر على ذلك. كما يتيح النوع المخصّص لـ catch (const NetworkError&) أن يلتقط مشكلات الشبكة وحدها، ويترك كل ما عداها للمعالِج الأعمّ الذي يليه.

إذا ورِثت يومًا مباشرةً من std::exception (وليس من runtime_error)، فتذكّر أن تعيد تعريف what() بنفسك، وأن تضع علامة noexcept عليها لتطابق توقيع الصنف الأساسي:

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

أطلِق بالقيمة، والتقِط بالمرجع

هذه أهم قاعدة في استثناءات C++، وهي التي يخطئ فيها المبتدئون. أطلِق الكائنات بالقيمة، والتقِطها بمرجع const.

throw runtime_error("oops");            // بالقيمة - صحيح
catch (const runtime_error& e) { ... }  // بمرجع const - صحيح

أما الالتقاط بالقيمة بدلًا من ذلك —catch (std::exception e)— فينسخ الاستثناء إلى كائن من الصنف الأساسي و_يقتطع_ الجزء المشتق. بعد الاقتطاع، تستدعي e.what() تنفيذ الصنف الأساسي، لا تنفيذك المُعاد تعريفه، فتختفي رسالتك التي صغتها بعناية:

try {
    throw NetworkError(503, "service unavailable");
} catch (std::exception e) {       // بالقيمة - اقتطاع الكائن!
    std::cout << e.what();         // رسالة عامة، وقد اختفت status()
}

المرجع (&) يحفظ النوع الديناميكي الحقيقي، فتُوزَّع what() الافتراضية توزيعًا صحيحًا، ويظل بإمكانك الوصول إلى أعضاء الصنف المشتق. أضِف const لأنك تقرأ الاستثناء فقط ولا تعدّله. لا تُطلق مؤشرًا أبدًا (throw new runtime_error(...)): إذ سيتعيّن على المُلتقِط أن يستدعي delete عليه، وفي أي مسار تنفيذ؟ هذا بالضبط هو التسريب الذي يُفترض بالاستثناءات أن تمنعه.

التالي: try-catch

تستطيع الآن إنشاء استثناءات سليمة الصياغة وإطلاقها بـ throw، واختيار النوع القياسي المناسب لكل حالة فشل. النصف الآخر من القصة هو جانب الالتقاط. تغطّي الصفحة التالية try/catch بالكامل: ترتيب كتل catch المتعددة من الأكثر تخصيصًا إلى الأكثر عمومية، والكتلة الجامعة catch (...)، وإعادة الإطلاق بـ throw; المجرّدة، وكيف يضمن RAII (تذكّر المؤشرات الذكية) تحرير مواردك أثناء تفريغ المكدّس.