Пример 1: Програма за създаване на персонализиран клас изключения в C++
Този прост пример е реализиран, за да демонстрира персонализираната обработка и откриване на изключения в C++.
#include#include <изключение>
използвайки пространство от имена std ;
клас DemoException : публичен изключение
{
виртуален конст въглен * Какво ( ) конст хвърлям ( )
{
връщане „Уловено персонализирано изключение“ ;
}
} ;
вътр основен ( )
{
DemoException dEx ;
опитвам
{
хвърлям dEx ;
}
улов ( изключение и с изключение )
{
cout << с изключение. Какво ( ) << endl ;
}
връщане 0 ;
}
Ние дефинираме заглавния файл в кода, включително „iostream“ и „exception“. „iostream“ се извиква специално за входния и изходния поток, докато библиотеката „exception“ се извиква, за да се справи с изключението. След това създаваме класа „DemoException“, който е извлечен от класа „изключение“ на C++. Тук задаваме виртуалната функция what(), която се използва за предоставяне на const char*, който показва резултатите от съобщение за грешка, което е свързано с изключението.
След това извикваме функция main(), където създаваме обекта „dEx“ на класа „DemoException“. След това имаме дефиниция на блок „try“, която хвърля изключението, ако се срещне. Тук хвърляме обекта 'dEx'.
След това настройваме блока „catch“, за да улови изключението и да го обработи. Предаваме препратката към изключението на класа като параметър, за да уловим изключението, което е извлечено от него. В блока „catch“ извикваме функцията what() на „except“, за да получим съобщението за изключение на конзолата.
След изпълнение на дадената програма, персонализираното съобщение за изключение се прихваща и хвърля на конзолата:
Пример 2: Програма за създаване на персонализирано изключение с помощта на два класа
Програмата набляга на работата с множество изключения, които могат да се обработват независимо чрез дефиниране на множество класове.
#include
използвайки пространство от имена std ;
клас оценка1 { } ;
клас оценка2 { } ;
вътр основен ( ) {
опитвам {
хвърлям оценка1 ( ) ;
}
улов ( оценка1 e ) {
cout << „Уловено изключение за оценка 1!“ << endl ;
}
опитвам {
хвърлям оценка2 ( ) ;
}
улов ( оценка2 e ) {
cout << „Уловено изключение за оценка 2!“ << endl ;
}
връщане 0 ;
}
В дадения код имаме дефиницията на два класа, „Evaluation1“ и „Evaluation2“, които сега са празни. След това изпълняваме функцията main() на програмата. Тук задаваме блока try{}, където ключовата дума „throw“ се използва за хвърляне на екземпляра на класа „Evaluation1()“. Това означава, че изключението „Evaluation1“ се хвърля, ако в програмата възникне изключение в този блок „try“. След това имаме блок catch{}, където изключението се улавя и показва съобщението за изключението.
По подобен начин имаме дефиниция на друг блок try{} за класа „Evaluation2“. Вътре в блока try{} хвърляме екземпляра на класа „Evaluation2“. Това хвърля изключение на „Evaluation2“, ако тук възникне грешка. След това извикваме блока catch{}, за да покажем съобщението за изключение, използвайки командата „cout“, ако изключението е уловено в този блок.
Двете изключения на различните блокове „try-catch“ се хвърлят в конзолата, които се обработват от двата различни класа.
Пример 3: Програма за създаване на персонализирано изключение с конструктор
Програмата използва конструктора за обработка на изключението. Въпреки че не можем да получим стойностите от конструктора, можем да постигнем това с помощта на блока “try-catch”.
#includeизползвайки пространство от имена std ;
клас Тест {
вътр вал ;
публичен :
Тест ( вътр н )
{
опитвам {
ако ( н == 0 )
вал = н ;
дисплей ( ) ;
}
улов ( конст въглен * експ ) {
cout << „Намерено е изключение \н ' ;
cout << експ << endl ;
}
}
невалиден дисплей ( )
{
cout << 'Стойност = ' << вал << endl ;
}
} ;
вътр основен ( )
{
Тест ( 0 ) ;
cout << „Отново се създава екземпляр \н ' ;
Тест ( 1 ) ;
}
В дадения код ние установяваме класа „Тест“, където променливата е декларирана като „вал“ от тип integer. След това имаме дефиниция на функцията конструктор „Test()“, която се предава с променливата „n“. След това задаваме блока „try-catch“ във функцията на конструктора „Test()“. Блокът try се извиква с израза if(). Ако стойността на „n“ е равна на нула, блокът „catch“ ще улови изключението и съобщението за изключение ще бъде хвърлено при подканата. Стойността на „n“ се съхранява в променливата „val“, докато я инициализираме.
След това извикваме функцията display(), за да покажем стойността, която се съхранява в променливата „val“. След това имаме дефиницията на блока „catch“, където се обработва изключението, хвърлено от блока „try“. Накрая извикваме функцията main(). Вътре в който извикваме конструктора „Test()“. Конструкторът се задейства, когато обектът от класа “Test()” е създаден и определен със стойността “0”, на която е хвърлено изключението.
След това отново извикваме класа „Test()“, за да създадем екземпляр, който се предава със стойност 1. Тук конструкторът няма да хвърли изключение, тъй като стойността не е равна на 0. Функцията display() ще изпълнете и отпечатайте стойността на „val“.
Персонализираното изключение се хвърля на конзолата чрез извикване на конструктора. Освен това, когато условието е изпълнено, конструкторът се изпълнява без изключение.
Пример 4: Програма за създаване на дефинирано от потребителя персонализирано изключение
Програмата тук обработва и улавя изключението, което е дефинирано от потребителя, когато бъде попитано в подканата.
#include#include <изключение>
използвайки пространство от имена std ;
клас MyDemo : публичен изключение {
публичен :
конст въглен * Какво ( ) конст хвърлям ( )
{
връщане „Изключение! Опитах деление на нула.! \н ' ;
}
} ;
вътр основен ( )
{
опитвам
{
вътр n1, n2 ;
cout << 'Въведете двете цели числа: \н ' ;
храня се >> n1 >> n2 ;
ако ( n2 == 0 )
{
MyDemo n3 ;
хвърлям n3 ;
}
друго
{
cout << 'n1/n2 = ' << n1 / n2 << endl ;
}
}
улов ( изключение и изкл )
{
cout << изкл. Какво ( ) ;
}
}
В дадения код първо дефинираме класа „MyDemo()“, който е зависимият клас на изключението. След това задаваме публичната функция what() с ключовата дума „virtual“. Функцията what() се извиква, за да получи причината за изключението в програмата, когато функцията throw() хвърли изключението. След това имаме функция main(), където блоковете try-catch{} са дефинирани за откриване и обработка на изключението. В блока try{} ние декларираме две променливи, „n1“ и „n2“, чиито стойности се вземат от потребителя с помощта на командата „cin“. Когато се получат стойностите за всяка променлива „n1“ и „n2“, условието „if“ ще провери дали променливата „n2“ е равна на 0 или не. Ако е така, се хвърля изключение или се връщат резултатите от разделянето. И накрая, имаме блок catch{}, който приема препратката към класа „изключение“ като параметър, наследен от него.
Изходът показва, когато условието не е изпълнено и програмата се изпълнява без изключение:
Също така, ние дефинираме стойността на „0“ на променливата „n2“, за да представим как изключението се хвърля и хваща в програмата.
Заключение
В заключение демонстрирахме важната концепция на C++, която е изключение. Изключение възпрепятства редовното изпълнение на програмата. За целта използвахме ключовите думи „throw“, „try“ и „catch“, за да се справим с изключението, което се случва в програмата. Използвахме тези ключови думи в предишните примери, за да обработим изключението по различен начин.