Solutions aux problèmes courants de gestion des exceptions en C++

Les solutions aux problèmes courants de gestion des exceptions en C++ nécessitent des exemples de code spécifiques

Introduction :
Lors de l'écriture de programmes C++, vous rencontrez souvent des exceptions dans le programme, telles qu'un diviseur par 0, un tableau hors limites et un accès au pointeur nul, etc. . Ces exceptions peuvent provoquer le blocage du programme ou produire des résultats imprévisibles. Afin d'améliorer la stabilité et la fiabilité du programme, nous devons utiliser un mécanisme de gestion des exceptions pour capturer et gérer ces exceptions. Cet article présentera les problèmes courants de gestion des exceptions en C++ et donnera les solutions correspondantes et des exemples de code spécifiques.

1. Capture et gestion des exceptions
   En C++, la capture et la gestion des exceptions utilisent le bloc d'instructions try-catch. Le code en cours d'essai est le bloc de code surveillé. Si une exception se produit, il passera à catch pour être traité. Le catch peut être suivi de plusieurs blocs de code de gestion des exceptions de différents types, et chaque bloc de code de gestion peut gérer le type d'exception correspondant. S'il n'y a pas de bloc catch approprié, l'exception continuera à être levée vers le haut jusqu'à ce qu'un bloc de code de gestion approprié soit trouvé.

Ce qui suit est un exemple simple :

try {
    // 可能发生异常的代码
    throw 1;  // 抛出一个整型异常
} catch (int e) {
    // 处理整型异常
    cout << "捕获到异常：" << e << endl;
}

2. Classes d'exceptions standard
   C++ fournit un ensemble de classes d'exceptions standard, qui héritent toutes de la classe std::exception. Nous pouvons utiliser ces classes d’exceptions pour gérer les situations d’exception courantes.

Voici quelques classes d'exceptions standard courantes et leurs conditions d'exception correspondantes :

• std::bad_alloc : classe d'exception pour les échecs d'allocation de mémoire, utilisée pour gérer les situations de mémoire insuffisante.
• std::bad_cast : classe d'exception d'erreur de conversion de type, utilisée pour gérer l'échec de la conversion de type.
• std::out_of_range : classe d'exception de tableau hors de portée, utilisée pour gérer les situations d'accès au tableau hors de portée.
• std::overflow_error : classe d'exceptions d'erreur de débordement, utilisée pour gérer les situations de débordement numérique.
• std::underflow_error : classe d'exceptions d'erreur de sous-débit, utilisée pour gérer les situations de sous-débordement numérique.

Voici un exemple d'utilisation de la classe d'exception std::out_of_range :

try {
    int arr[5] = {1, 2, 3, 4, 5};
    cout << arr[10] << endl;  // 数组访问越界
} catch (std::out_of_range& e) {
    // 处理数组越界异常
    cout << "捕获到数组越界异常：" << e.what() << endl;
}

3. Classe d'exception personnalisée
   En plus d'utiliser des classes d'exception standard, nous pouvons également personnaliser les classes d'exception pour gérer des situations d'exception spécifiques. La classe d'exception personnalisée doit hériter de la classe std::exception et remplacer la méthode what() qu'elle contient pour fournir des informations de description d'exception personnalisées.

Ce qui suit est un exemple de classe d'exception personnalisée :

class MyException : public std::exception {
public:
    MyException(const std::string& message) : m_message(message) {}

    const char* what() const noexcept {
        return m_message.c_str();
    }

private:
    std::string m_message;
};

try {
    throw MyException("这是一个自定义异常");  // 抛出自定义异常
} catch (MyException& e) {
    // 处理自定义异常
    cout << "捕获到自定义异常：" << e.what() << endl;
}

4. Livraison d'exception
   Parfois, après avoir détecté une exception, nous souhaitons la transmettre à l'appelant de niveau supérieur. Ceci peut être réalisé en utilisant l'instruction throw dans le bloc catch.

Ce qui suit est un exemple de livraison d'exceptions :

void doSomething() {
    try {
        // 可能发生异常的代码
        throw std::runtime_error("发生了一个错误");
    } catch (std::exception& e) {
        // 处理异常，并传递给上一级调用者
        cout << "捕获到异常：" << e.what() << endl;
        throw;
    }
}

try {
    doSomething();
} catch (std::exception& e) {
    // 处理传递过来的异常
    cout << "捕获到传递过来的异常：" << e.what() << endl;
}

Conclusion :
La gestion des exceptions est un élément important pour garantir la stabilité et la fiabilité des programmes C++. Cet article présente les problèmes courants de gestion des exceptions en C++ et donne les solutions correspondantes et des exemples de code spécifiques. En utilisant correctement le mécanisme de gestion des exceptions, nous pouvons mieux répondre aux situations anormales qui se produisent dans le programme et améliorer la robustesse du programme.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!