Przykład 1:
Zawarty jest tutaj „iostream”, plik nagłówkowy, w którym zadeklarowano kilka funkcji. Używamy tych funkcji, które są zadeklarowane w tym pliku nagłówkowym w naszym kodzie, więc dołączamy ten plik nagłówkowy. Następnie mamy „std”, który jest tutaj umieszczony, ponieważ zdefiniowano w nim również funkcje takie jak „cin” i „cout”. Nie musimy wpisywać „std” przy wszystkich tych funkcjach, jeśli dodamy „przestrzeń nazw std” na początku naszego kodu. Następnie wywoływana jest funkcja „main()”, która jest również nazywana kodem sterownika programu C++.
Następnie używamy tutaj słowa kluczowego „try”, w którym inicjujemy „my_num1” wartością „35”. Jest to tutaj zmienna typu danych „int”. Teraz umieszczamy tę zmienną wewnątrz „if” i umieszczamy warunek, który mówi, że „moja_liczba1” musi być większa lub równa „98”. Jeśli dany warunek jest spełniony, przechodzi do przodu w obrębie „if” i wykonuje zapisaną tutaj instrukcję. Używamy „cout” i wstawiamy komunikat, który zostanie wyświetlony, gdy warunek zostanie spełniony.
Następnie używamy słowa kluczowego „throw” po umieszczeniu „else”. W tym słowie kluczowym „throw” przekazujemy jako parametr „my_num1”. Poniżej dodajemy część „catch”. Wstawiamy „my_num2” jako parametr „catch()”, a następnie ponownie używamy „cout” w tej części „catch”. Ta część jest wykonywana tylko wtedy, gdy w części „try” wystąpi wyjątek.
Kod 1:
#include
za pomocą przestrzeń nazw st ;
wew główny ( ) {
próbować {
wew mój_num1 = 35 ;
Jeśli ( mój_num1 >= 98 ) {
cout << „Tutaj przyznano dostęp.” ;
} w przeciwnym razie {
rzucić ( mój_num1 ) ;
}
}
złapać ( wew mój_num2 ) {
cout << „W tym miejscu odmówiono dostępu”. << koniec ;
cout << 'Liczba to: ' << mój_num2 ;
}
powrót 0 ;
}
Wyjście:
Wprowadzona liczba to „35”, czyli mniej niż „98”. Zatem występuje tam wyjątek i wyświetlana jest część „catch()”. Odmówiono dostępu do części „try”.
Przykład 2:
Umieszczamy tutaj plik nagłówkowy „iostream” i „przestrzeń nazw std”. Następnie tworzymy funkcję „division()”, w której umieszczamy dwa parametry będące „licznikiem” i „mianownikiem” typu danych „int”. Ustawiamy typ danych tej funkcji „dzielenia” na „podwójny”.
Poniżej dodajemy „if()”, w którym dodajemy warunek, że mianownik jest równy zero. Następnie używamy słowa kluczowego „throw” i wpisujemy tam wiadomość. Ten komunikat jest wyświetlany za każdym razem, gdy w tym kodzie wystąpi wyjątek zgodnie z warunkiem. Poniżej używamy słowa kluczowego „return”, w którym umieszczamy „licznik/mianownik”. Zwraca więc wynik dzielenia. Teraz wywoływana jest funkcja „main()”.
Następnie „num1” i „num2” są inicjalizowane jako zmienne „int” i przypisują im odpowiednio „89” i „0”. Następnie inicjujemy „wynik” typu danych „double”. Tutaj używamy słowa kluczowego „try”. W tej części dodajemy zmienną „result” i przypisujemy do niej funkcję „division()”. Do tej funkcji przekazujemy dwa parametry: „num1” i „num2”. Poniżej wyświetlamy „wynik”, jaki otrzymamy po zastosowaniu funkcji „dzielenie()”. Następnie używamy również „catch” i umieszczamy „const char* msg”, aby wyświetlić wiadomość, którą wcześniej dodaliśmy.
Kod 2:
#includeza pomocą przestrzeń nazw st ;
podwójnie dział ( wew licznik, wew mianownik ) {
Jeśli ( mianownik == 0 ) {
rzucić „Dzielenie przez zero nie jest tutaj możliwe!” ;
}
powrót ( licznik ułamka / mianownik ) ;
}
wew główny ( ) {
wew numer1 = 89 ;
wew liczba2 = 0 ;
podwójnie wynik = 0 ;
próbować {
wynik = dział ( liczba1, liczba2 ) ;
cout << wynik << koniec ;
} złapać ( konst zwęglać * wiadomość ) {
cer << wiadomość << koniec ;
}
powrót 0 ;
}
Wyjście:
Liczba, którą wcześniej wstawiliśmy jako mianownik, to „0”. Zatem w kodzie pojawia się wyjątek i wyświetla podany komunikat.
Przykład 3:
Tworzy się tu funkcję „mnożenie()”, w której jako parametry typu danych „int” umieszczamy „wartość” i „mnożnik”. Następnie używamy „jeśli”, w którym dodajemy warunek mnożenia równy zero. Następnie w miejscu, w którym dodajemy oświadczenie, umieszczamy „rzut”. Następnie mamy „powrót”, w którym umieszczamy zmienne „wartość * mnożnik”, które wcześniej zadeklarowaliśmy. Zwraca więc tutaj wynik mnożenia.
Następnie wywołujemy funkcję „main()”, w której deklarujemy „int wartość 1” i „int wartość 2” z wartościami odpowiednio „34” i „0”. Deklarowana jest także funkcja „int m_res”, którą następnie nazywa się tutaj funkcją „multiplication()”. Po wykonaniu tej funkcji wynik zostanie zapisany w zmiennej „m_res” i następnie wyświetlony. Następnie używamy funkcji „catch” i wstawiamy „const char* msg”, aby wyświetlić wiadomość, którą wcześniej dodaliśmy w części „throw”.
Kod 3:
#includeza pomocą przestrzeń nazw st ;
podwójnie mnożenie ( wew wartość , wew mnożnik ) {
Jeśli ( mnożnik == 0 ) {
rzucić „Nie mnożymy wartości przez zero!” ;
}
powrót ( wartość * mnożnik ) ;
}
wew główny ( ) {
wew wartość1 = 3. 4 ;
wew wartość2 = 0 ;
wew m_res ;
próbować {
m_res = mnożenie ( wartość1, wartość2 ) ;
cout << m_res << koniec ;
} złapać ( konst zwęglać * wiadomość ) {
cer << wiadomość << koniec ;
}
powrót 0 ;
}
Wyjście :
Ponieważ wartość, którą wcześniej wprowadziliśmy, ma jako mnożnik „0”, w kodzie występuje wyjątek, który powoduje wyświetlenie w tym miejscu powiadomienia.
Przykład 4:
Tutaj budujemy funkcję „multiply()” i przekazujemy „number1” i „number2” jako parametry typu danych „int”. Następnie za pomocą operatora „if” dodajemy do niego warunek będący mnożnikiem mniejszym lub równym zero. Następnie dodawana jest instrukcja w miejscu, w którym powinno znajdować się „rzut”. Wynik mnożenia jest następnie zwracany w sekcji „return”, gdzie wstawiamy zmienną „liczba1 * liczba2”, którą wcześniej zadeklarowaliśmy.
Następnie wywołujemy funkcję „main()” i przypisujemy wartości „34” i „12” odpowiednio do „int newNumber1” i „int newNumber2”. W tym przypadku funkcja „multiply()” jest wywoływana po deklaracji „int mResult”. Teraz wynik tej funkcji jest przechowywany w zmiennej „mResult” i jest renderowany poniżej. Następnie używamy funkcji „catch” i dodajemy „const char* msg”, aby wyświetlić komunikat, który napisaliśmy w sekcji „throw”.
Kod 4:
#includeza pomocą przestrzeń nazw st ;
podwójnie zwielokrotniać ( wew numer 1 , wew numer 2 ) {
Jeśli ( numer 2 <= 0 ) {
rzucić „Nie mnożymy wartości przez zero ani wartość ujemną!” ;
}
powrót ( numer 1 * numer 2 ) ;
}
wew główny ( ) {
wew nowyNum1 = 3. 4 ;
wew nowyNum2 = 12 ;
wew mWynik ;
próbować {
mWynik = zwielokrotniać ( nowyNum1, nowyNum2 ) ;
cout << „Wynikiem mnożenia jest” << mWynik << koniec ;
}
złapać ( konst zwęglać * wiadomość ) {
cer << wiadomość << koniec ;
}
powrót 0 ;
}
Wyjście:
Wartość, którą dodajemy, to „12”, na której dodajemy warunek. Zatem funkcja „mnożenie()” jest wykonywana, ponieważ warunek nie jest spełniony. Wyświetlany jest wynik mnożenia. Tutaj wykonywana jest część „try”.
Wniosek
Koncepcja „try-catch” i kody zawarte w tym przewodniku zostały szczegółowo omówione. Dokładnie zbadaliśmy tę koncepcję „try-catch” i pokazaliśmy, jak działa ona w programowaniu w C++. Zdefiniowaliśmy, że termin „rzut” tworzy wyjątek w przypadku znalezienia błędu, który pozwala nam napisać nasz unikalny kod. Za pomocą wyrażenia „catch” możemy określić blok kodu, który zostanie uruchomiony, jeśli w części „try” pojawi się wyjątek.