Przykład 1:
„iostream” to dołączony plik nagłówkowy, który umieściliśmy, abyśmy mogli wykorzystać metody „cin” lub „cout” w naszym kodzie, ponieważ obie metody są w nim zadeklarowane. Obiekt „cerr” jest również zadeklarowany w tym pliku nagłówkowym. Następnie mamy „standardową przestrzeń nazw”. Teraz nie musimy dodawać tego „std” niezależnie do każdej funkcji.
Następnie wywoływane jest tutaj „main()”. Poniżej wykorzystujemy obiekt „cerr” i umieszczamy komunikat o błędzie, który chcemy wyświetlić na konsoli. Wpisujemy „Wystąpił tutaj błąd!” wiadomość w tym „cerr” po umieszczeniu symboli wstawiania. Gdy uruchomimy ten program, wyświetli się podany komunikat bez użycia komendy „cout”.
Kod 1:
#includeużywając przestrzeni nazw std ;
wew główny ( ) {
cer << „Wystąpił tutaj błąd!” << koniec ;
powrót 0 ;
}
Wyjście:
Komunikat, który wpisujemy po umieszczeniu „cerr <<” jest teraz wyświetlany w tym wyniku, który jest wyświetlany w następujący sposób:
Przykład 2:
Ponieważ zarówno metody „cin”, „cout”, jak i „cerr” są zadeklarowane w pliku nagłówkowym „iostream”, dodajemy tutaj plik nagłówkowy, abyśmy mogli wykorzystać je w naszym kodzie. Następnie mamy „standardową przestrzeń nazw”. Poniżej wywoływana jest funkcja „main()”. Inicjujemy „error_str[]” typu danych „string” i przypisujemy komunikat do „error_str[]”. Następnie wykorzystujemy obiekt „cerr”, w którym umieszczamy komunikat o błędzie i przekazujemy „error_str”. Kiedy więc wykonamy ten program, renderuje on oba komunikaty.
Kod 2:
#includeużywając przestrzeni nazw std ;
wew główny ( ) {
zwęglać błąd_str [ ] = „Nie możemy tutaj odczytać ciągu!” ;
cer << 'Wystąpił błąd : ' << błąd_str << koniec ;
}
Wyjście:
Tekst, który wpisujemy po wpisaniu „cerr <<” jest teraz widoczny w wyniku, podobnie jak komunikat, który dodaliśmy w „error_str”. Wynik jest również pokazany w następujący sposób:
Przykład 3:
Po dołączeniu pliku nagłówkowego i umieszczeniu przestrzeni nazw „std”, wywołujemy metodę „main()”. Następnie deklarowana jest tutaj zmienna całkowita „NumOfLine” i inicjowana za pomocą „__LINE__”. Ta „__LINE__” generuje komunikaty o błędach. Poniżej używamy obiektu „cerr” i umieszczamy komunikat o błędzie, który chcemy wyświetlić użytkownikowi. Umieszczamy także zmienną „NumOfLine”, która pokazuje numer linii, w której występuje błąd w kodzie.
Kod 3:
#includeużywając przestrzeni nazw std ;
wew główny ( ) {
wew Liczba linii = __LINIA__ ;
cer << „Wystąpił błąd w linii: „ << Liczba linii ;
powrót 0 ;
}
Wyjście:
Tutaj pokazuje, że błąd występuje w linii „4”, ponieważ dodaliśmy „__LINE__” w czwartej linii kodu. Komunikat ten jest tutaj wyświetlany za pomocą obiektu „cerr” w C++.
Przykład 4:
Dołączamy jeszcze jeden plik nagłówkowy, „fstream”. Ten plik nagłówkowy „fstream” jest używany w C++ do odczytu, zapisu lub tworzenia pliku, ponieważ jest kombinacją „ofstream” i „ifstream”. Teraz, po dodaniu „std namespace” i wywołaniu „main()”, używamy „fstream” ze zmienną „new_file”.
Następnie używamy tutaj funkcji „open()” z „new_file” i przekazujemy nazwę pliku jako parametr. Nazwa pliku to „myTextFile.txt”, który chcemy otworzyć. Poniżej używamy „if” do przekazania zmiennej „nowy_plik”. Teraz, jeśli plik otworzy się w tym miejscu, zostanie wyrenderowana instrukcja znajdująca się po słowie „if”. W przeciwnym razie renderowana jest instrukcja znajdująca się po „else”, w której dodajemy obiekt „cerr”, aby wyświetlić komunikat o błędzie.
Kod 4:
#include#include
używając przestrzeni nazw std ;
wew główny ( ) {
fstream nowy_plik ;
nowy plik. otwarty ( „mójPlikTekstowy.txt” ) ;
Jeśli ( nowy plik ) {
cout << „Plik został pomyślnie otwarty tutaj!” ;
}
w przeciwnym razie {
cer << „Wystąpił błąd podczas otwierania tutaj pliku!” ;
}
powrót 0 ;
}
Wyjście:
Nie możemy otworzyć pliku, który wcześniej udostępniliśmy. Tutaj wyświetla komunikat o błędzie, który wstawiliśmy po obiekcie „cerr”.
Przykład 5:
Tutaj chcemy otworzyć kolejny plik. Dodajemy więc oba pliki nagłówkowe i przestrzeń nazw „std”. Teraz wywołujemy funkcję „main()”, a następnie wykorzystujemy funkcję „fstream” ze zmienną „t_file”. Następnie w tym przypadku używamy funkcji „open()” z „new_file” i podajemy nazwę pliku jako argument. Plik, który chcemy otworzyć, nazywa się „New.txt”. Używamy instrukcji „if”, przekazując zmienną „t_file”. Teraz, jeśli plik zostanie otwarty, zostanie wyrenderowana linia następująca po „if”. Jeśli nie, renderowana jest instrukcja następująca po „else”, w której dodaliśmy obiekt „cerr” w celu wyświetlenia komunikatu o błędzie.
Kod 5:
#include#include
używając przestrzeni nazw std ;
wew główny ( ) {
fstream plik_t ;
plik_t. otwarty ( „Nowy.txt” ) ;
Jeśli ( plik_t ) {
cout << „Tutaj otwiera się plik!” ;
}
w przeciwnym razie {
cer << 'Wystąpił błąd!' ;
}
powrót 0 ;
}
Wyjście:
Nie można otworzyć podanego przez nas pliku. Tak więc komunikat o błędzie, który dodaliśmy po obiekcie „cerr”, jest wyświetlany w następujący sposób:
Przykład 6:
Dodajemy tutaj plik nagłówkowy „wyjątku”, który służy do sprawdzania błędów, które mogą wystąpić w naszym kodzie. Poniżej inicjujemy tablicę typu całkowitego o nazwie „new_array” i rozmiarze „6”. Następnie ustawiamy „nowy_indeks” zmiennej „int” i przypisujemy tutaj „7”. Teraz inicjujemy także zmienną „new_size” i przypisujemy „*(&new_arr + 1) – new_arr” do zmiennej „new_size”.
Następnie używamy „try”, „throw” i „catch”, które służą do sprawdzania błędów i zgłaszania komunikatu o błędzie. Używamy obiektu „color”, który pokazuje komunikat o błędzie, który dodaliśmy po słowie kluczowym „throw”.
Kod 6:
#include#include
używając przestrzeni nazw std ;
wew główny ( ) {
wew nowy_arr [ 6 ] = { 1 , 9 , 4 , 3 , 8 , 7 } ;
wew nowy_indeks = 7 ;
wew nowy_rozmiar = * ( & nowy_arr + 1 ) - nowy_arr ;
próbować {
Jeśli ( nowy_indeks < 0 || nowy_indeks >= nowy_rozmiar ) rzucić ( „Indeks nie mieści się w zakresie. Tutaj jest poza zakresem” ) ;
w przeciwnym razie
cout << nowy_arr [ nowy_indeks ] ;
}
złapać ( konst zwęglać * błądzić ) {
cer << błądzić ;
}
powrót 0 ;
}
Wyjście:
Tutaj wyświetla komunikat o błędzie, który pokazuje, że „Indeks” jest poza zakresem i otrzymujemy ten błąd, wykorzystując obiekt „cerr”.
Przykład 7:
Tutaj sprawdzamy błąd, który może wystąpić podczas dzielenia liczby przez zero. Tworzymy funkcję „d()”, w której przekazujemy dwie zmienne typu „int” „a1” i „a2”. Poniżej dodajemy „if”, w którym spełniamy warunek „a2==0”. Jeżeli wartość „a2” wynosi zero, zostanie wykonany komunikat, który umieścimy po „rzucie”, który otrzymamy poprzez umieszczenie w kodzie obiektu „cerr”.
Następnie umieszczamy „return”, który zwraca odpowiedź dzielenia, jeśli wartość „a2” jest różna od zera. Teraz wywołujemy funkcję „main()” i przypisujemy „87” do „x” po zainicjowaniu go jako zmiennej „int”. Następnie inicjalizujemy zmienne „b” i „d_res” wartością „0”. Tutaj umieszczamy „try” i „catch”, które wychwytują błąd, a „cerr” wyrzuca komunikat o błędzie, który dodaliśmy po słowie kluczowym „throw”.
Kod 7:
#includeużywając przestrzeni nazw std ;
wew moja_dywizja ( wew a1 , wew a2 ) {
Jeśli ( a2 == 0 ) {
rzucić „Dzielenie przez zero nie jest możliwe!” ;
}
powrót ( a1 / a2 ) ;
}
wew główny ( ) {
wew X = 87 ;
wew I = 0 ;
wew d_nic = 0 ;
próbować {
d_nic = moja_dywizja ( X , I ) ;
cout << d_nic << koniec ;
} złapać ( konst zwęglać * wiadomość ) {
cer << wiadomość << koniec ;
}
powrót 0 ;
}
Wyjście:
Tutaj pojawia się komunikat o błędzie, który oznacza, że chcemy podzielić liczbę przez „0”, co jest niemożliwe.
Wniosek
Obiekt „cerr” jest tutaj szczegółowo badany. Zdefiniowaliśmy, w jaki sposób obiekt „cerr” pomaga w wyświetlaniu komunikatu o błędzie w programowaniu w C++. Przeanalizowaliśmy wiele przykładów, w których umieściliśmy wiele warunków, w których wystąpił błąd. Wykorzystaliśmy także obiekt „cerr” po umieszczeniu metody try-catch i w kodzie otwierającym plik. Pokazaliśmy kod i wynik, w którym „cerr” wyświetla komunikat o błędzie.