Bibliothèque de gestion des exceptions C++ <stdexcept>
<stdexcept>Est un fichier d'en-tête de la bibliothèque standard C++ qui définit un ensemble de classes d'exception standard pour gérer les conditions d'erreur pendant l'exécution du programme.
Les exceptions sont des erreurs qui se produisent pendant l'exécution du programme ; elles peuvent être interceptées et gérées pour éviter une terminaison anormale du programme.<stdexcept>Le fichier d'en-tête définit un ensemble de classes dérivées destd::exceptionClasses d'exception dérivées qui fournissent une manière standard de signaler et de gérer les erreurs.
Syntaxe
Pour utiliser<stdexcept>Pour les classes d'exception concernées, vous devez d'abord inclure ce fichier d'en-tête :
#include <stdexcept>
Ensuite, vous pouvez utiliser ces classes d'exception pour lever et intercepter des exceptions. Par exemple :
throw std::runtime_error("An error occurred");
Classe d’exception
<stdexcept>Le fichier d'en-tête définit les classes d'exception suivantes :
std::exception: La classe de base de toutes les classes d'exception standard.std::bad_exception: Levée lorsqu'une erreur se produit lors de la gestion des exceptions.std::bad_alloc: Levée lorsque l'allocation mémoire échoue.std::bad_cast: Levée lorsque la conversion de type échoue.std::bad_typeid: quandtypeidLevée lorsqu’une opération échoue.std::logic_error: Levée lorsqu’une erreur de logique se produit, comme un paramètre d’entrée invalide.std::domain_error: Levée lorsqu’un argument d’un appel de fonction est en dehors de la plage valide.std::invalid_argument: Levée lorsqu’un argument d’un appel de fonction est invalide.std::length_error: Levée lorsqu’une opération sur un conteneur échoue à cause de contraintes de longueur.std::out_of_range: Levée lorsqu’un index illégal est accédé dans un conteneur.std::overflow_error: Levée lorsque des opérations arithmétiques provoquent un dépassement.std::range_error: Levée lorsqu’une valeur de retour de fonction est en dehors de la plage attendue.std::underflow_error: Levée lorsque des opérations arithmétiques provoquent un sous-dépassement.
Exemple
Ci-dessous se trouve un exemple d’utilisation de<stdexcept>Un exemple simple montrant comment lever et intercepter des exceptions :
Exemple
#include <stdexcept>
void riskyFunction(int x) {
if (x < 0) {
throw std::invalid_argument("Valeur négative non autorisée");
}
std::cout << "Traitement " << x << std::endl;
}
int main() {
try {
riskyFunction(-1);
} catch (const std::invalid_argument& e) {
std::cerr << "Exception interceptée : " << e.what() << std::endl;
}
return 0;
}
Sortie :
Caught an exception: Negative value not allowed
Dans cet exemple,riskyFunctionLa fonction vérifie si le paramètre passé est négatif ; si c'est le cas, elle lancestd::invalid_argumentException. DansmainDans la fonction, nous utilisonstry-catchun bloc pour intercepter et gérer cette exception.
Classes d'exception standard
std::exception
La classe std::exception est la classe de base de toutes les classes d'exception standard. Elle fournit une fonction virtuelle what() qui renvoie une chaîne décrivant l'exception.
Exemple
#include <exception>
int main() {
try {
throw std::exception();
} catch (const std::exception& e) {
std::cout << "Exception interceptée : " << e.what() << std::endl;
}
return 0;
}
std::logic_error
std::logic_error dérive de std::exception et représente des erreurs de logique de programme. Il s'agit d'une classe de base abstraite, généralement concrétisée par des classes dérivées.
Exemple
#include <stdexcept>
int main() {
try {
throw std::logic_error("Logic error occurred");
} catch (const std::logic_error& e) {
std::cout << "Caught logic error: " << e.what() << std::endl;
}
return 0;
}
std::invalid_argument
std::invalid_argument dérive de std::logic_error, indiquant qu'un argument invalide a été passé.
Exemple
#include <stdexcept>
int main() {
try {
throw std::invalid_argument("Invalid argument provided");
} catch (const std::invalid_argument& e) {
std::cout << "Caught invalid argument: " << e.what() << std::endl;
}
return 0;
}
std::domain_error
std::domain_error dérive de std::logic_error, indiquant qu'un argument est en dehors du domaine valide.
Exemple
#include <stdexcept>
int main() {
try {
throw std::domain_error("Domain error occurred");
} catch (const std::domain_error& e) {
std::cout << "Caught domain error: " << e.what() << std::endl;
}
return 0;
}
std::length_error
std::length_error dérive de std::logic_error et représente une erreur de longueur, comme le dépassement de la limite de longueur maximale dans les opérations sur les conteneurs.
Exemple
#include <stdexcept>
int main() {
try {
throw std::length_error("Une erreur de longueur s'est produite");
} catch (const std::length_error& e) {
std::cout << "Erreur de longueur interceptée : " << e.what() << std::endl;
}
return 0;
}
std::out_of_range
std::out_of_range dérive de std::logic_error, indiquant qu'un accès est hors limites.
Exemple
#include <stdexcept>
int main() {
try {
throw std::out_of_range("Une erreur hors limites s'est produite");
} catch (const std::out_of_range& e) {
std::cout << "Erreur hors limites interceptée : " << e.what() << std::endl;
}
return 0;
}
std::runtime_error
std::runtime_error dérive de std::exception et représente les erreurs d'exécution du programme. C'est une classe de base abstraite, généralement rendue concrète par les classes dérivées.
Exemple
#include <stdexcept>
int main() {
try {
throw std::runtime_error("Une erreur d'exécution s'est produite");
} catch (const std::runtime_error& e) {
std::cout << "Erreur d'exécution interceptée : " << e.what() << std::endl;
}
return 0;
}
std::range_error
std::range_error dérive de std::runtime_error, indiquant qu'un résultat de calcul dépasse la plage représentable.
Exemple
#include <stdexcept>
int main() {
try {
throw std::range_error("Une erreur de plage s'est produite");
} catch (const std::range_error& e) {
std::cout << "Erreur de plage interceptée : " << e.what() << std::endl;
}
return 0;
}
std::overflow_error
std::overflow_error dérive de std::runtime_error, indiquant une erreur de dépassement arithmétique.
Exemple
#include <stdexcept>
int main() {
try {
throw std::overflow_error("Une erreur de dépassement s'est produite");
} catch (const std::overflow_error& e) {
std::cout << "Erreur de dépassement interceptée : " << e.what() << std::endl;
}
return 0;
}
std::underflow_error
std::underflow_error dérive de std::runtime_error, indiquant une erreur de sous-dépassement arithmétique.
Exemple
#include <stdexcept>
int main() {
try {
throw std::underflow_error("Une erreur de sous-dépassement s'est produite");
} catch (const std::underflow_error& e) {
std::cout << "Erreur de sous-dépassement interceptée : " << e.what() << std::endl;
}
return 0;
}
Utilisation de classes d'exception personnalisées
Outre les classes d'exception standard, nous pouvons également définir nos propres classes d'exception qui héritent des classes d'exception standard.
Exemple
#include <stdexcept>
class MyException : public std::runtime_error {
public:
MyException(const std::string& message) : std::runtime_error(message) {}
};
int main() {
try {
throw MyException("Mon exception personnalisée s'est produite");
} catch (const MyException& e) {
std::cout << "Exception personnalisée interceptée: " << e.what() << std::endl;
}
return 0;
}
<stdexcept>Il s'agit d'un composant important de la bibliothèque standard C++. Il fournit un ensemble de classes d'exceptions standard, ce qui rend la gestion des erreurs plus cohérente et prévisible. En utilisant ces classes d'exceptions, vous pouvez écrire du code plus robuste et plus maintenable. Pour les débutants, comprendre les concepts de base des exceptions et comment les utiliser ...<stdexcept>Les classes d'exception qu'il contient sont très importantes.