Phenquestions
Erori de sintaxă
O expresie, o instrucțiune sau o construcție tastate greșit este o eroare de sintaxă.
Luați în considerare următoarele două afirmații:
int arr [] = 1, 2, 3; //corectint arr = 1, 2, 3; // eroare de sintaxă, lipsește []
Sunt definiții ale aceluiași tablou. Primul este corect. Al doilea lipsește [], iar aceasta este o eroare de sintaxă. Un program cu o eroare de sintaxă nu reușește să compileze. Compilația eșuează cu un mesaj de eroare care indică eroarea de sintaxă. Un lucru bun este că o eroare de sintaxă poate fi întotdeauna reparată dacă programatorul știe ce face.
Eroare logică
O eroare logică este o eroare comisă de programator atunci când se face o codare logică greșită. Poate fi rezultatul ignoranței de la programator la caracteristicile limbajului de programare sau a unei neînțelegeri a ceea ce ar trebui să facă programul.
În această situație, programul este compilat cu succes. Programul funcționează bine, dar produce rezultate greșite. O astfel de eroare se poate datora faptului că o buclă iterează de 5 ori când se face să itereze de 10 ori. De asemenea, se poate întâmpla ca o buclă să fie făcută inconștient pentru a itera infinit. Singura modalitate de a rezolva acest tip de eroare este de a face o programare atentă și de a testa programul temeinic înainte de a-l preda clientului.
Erori de execuție
Intrările greșite sau excepționale provoacă erori în timpul rulării. În acest caz, programul a fost compilat cu succes și funcționează bine în multe situații. În anumite situații, programul se blochează (și se oprește).
Imaginați-vă că într-un segment de cod de program, 8 trebuie împărțit la un număr de numitori. Deci, dacă numărătorul 8 este împărțit la numitorul 4, răspunsul (coeficientul) ar fi 2. Cu toate acestea, dacă utilizatorul introduce 0 ca numitor, programul se va prăbuși. Împărțirea cu 0 nu este permisă în matematică și nici în calcul. Divizarea la zero ar trebui să fie prevenită în programare. Manevrarea excepțiilor gestionează erorile de execuție, cum ar fi divizarea la zero. Următorul program arată cum să gestionați problema diviziunii cu zero fără a utiliza caracteristica de excepție în C ++:
#includefolosind spațiul de nume std;
int main ()
int numerator = 8;
int numitor = 2;
if (numitor != 0)
int result = numărător / numitor;
cout << result << '\n';
altceva
cout << "Division by zero is not permitted!" << '\n';
retur 0;
Ieșirea este 4. Dacă numitorul ar fi 0, rezultatul ar fi fost:
„Împărțirea la zero nu este permisă!”
Codul principal aici este o construcție if-else. Dacă numitorul nu este 0, va avea loc împărțirea; dacă este 0, împărțirea nu va avea loc. Un mesaj de eroare va fi trimis utilizatorului, iar programul continuă să ruleze fără să se blocheze. Erorile de rulare sunt de obicei tratate prin evitarea executării unui segment de cod și trimiterea unui mesaj de eroare utilizatorului.
Funcția de excepție din C ++ folosește un bloc de încercare pentru blocul if și un bloc de blocare pentru blocul else pentru a gestiona eroarea, după cum urmează:
#includefolosind spațiul de nume std;
int main ()
int numerator = 8;
int numitor = 2;
încerca
if (numitor != 0)
int result = numărător / numitor;
cout << result << '\n';
altceva
arunca 0;
prinde (int err)
if (err == 0)
cout << "Division by zero is not permitted!" << '\n';
retur 0;
Rețineți că antetul try nu are un argument. De asemenea, rețineți că blocajul de blocare, care este ca o definiție a funcției, are un parametru. Tipul de parametru trebuie să fie același cu operandul (argumentul) expresiei throw. Expresia de aruncare se află în blocul de încercare. Aruncă un argument la alegerea programatorului care este legat de eroare, iar blocajul îl prinde. În acest fel, codul din blocul de încercare nu este executat. Apoi, blocarea afișează mesajul de eroare.
Acest articol explică gestionarea excepțiilor în C++. Cunoașterea de bază în C ++ este o condiție prealabilă pentru ca cititorul să înțeleagă acest articol.
Conținutul articolului:
- Funcția Aruncarea unei excepții
- Mai mult de un blocaj pentru un singur bloc
- Blocuri de încercare / prindere imbricate
- noexcept-specifier
- Funcția Special std :: terminate ()
- Concluzie
Funcția care aruncă o excepție:
O funcție poate arunca, de asemenea, o excepție la fel ca ceea ce face blocajul de încercare. Aruncarea are loc în cadrul definiției funcției. Următorul program ilustrează acest lucru:
#includefolosind spațiul de nume std;
void fn (const char * str)
if (islower (str [0]))
arunca 'l';
int main ()
încerca
fn („fierar”);
prinde (char ch)
if (ch == 'l')
cout << "Person's name cannot begin in lowercase!" << '\n';
retur 0;
Observați că de data aceasta, blocul try are doar apelul funcțional. Este funcția numită care are operația de aruncare. Blocul de captură prinde excepția, iar ieșirea este:
„Numele persoanei nu poate începe cu litere mici!”
De data aceasta, tipul aruncat și prins este un char.
Mai multe blocuri de blocare pentru un bloc de încercare:
Pot exista mai multe blocuri de blocare pentru un bloc de încercare. Imaginați-vă situația în care o intrare poate fi oricare dintre caracterele tastaturii, dar nu o cifră și nu un alfabet. În acest caz, trebuie să existe două blocuri: unul pentru un număr întreg pentru a verifica cifra și unul pentru un caracter pentru a verifica alfabetul. Următorul cod ilustrează acest lucru:
#includefolosind spațiul de nume std;
char input = '*';
int main ()
încerca
if (isdigit (input))
arunca 10;
if (isalpha (input))
arunca 'z';
prinde (int)
cout << "Digit input is forbidden!" << '\n';
prinde (char)
cout << "Character input is forbidden!" << '\n';
retur 0;
Nu există ieșire. Dacă valoarea de intrare a fost o cifră, e.g., „1”, rezultatul ar fi fost:
"Introducerea cifrelor este interzisă!"
Dacă valoarea de intrare a fost un alfabet, e.g., „a”, rezultatul ar fi fost:
"Introducerea de caractere este interzisă!"
Rețineți că în lista de parametri a celor două blocuri, nu există un nume de identificator. Rețineți, de asemenea, că în definiția celor două blocuri, argumentele particulare aruncate nu au fost verificate dacă valorile lor sunt exacte sau nu.
Ceea ce contează pentru o captură este tipul; o captură trebuie să se potrivească cu tipul de operand aruncat. Valoarea particulară a argumentului (operand) aruncat poate fi utilizată pentru verificări ulterioare, dacă este necesar.
Mai multe gestionare pentru același tip
Este posibil să aveți doi manipulatori de același tip. Când se aruncă o excepție, controlul este transferat la cel mai apropiat handler cu un tip de potrivire. Următorul program ilustrează acest lucru:
#includefolosind spațiul de nume std;
char input = '1';
int main ()
încerca
if (isdigit (input))
arunca 10;
prinde (int)
cout << "Digit input is forbidden!" << '\n';
prinde (int)
cout << "Not allowed at all: digit input!" << '\n';
retur 0;
Ieșirea este:
"Introducerea cifrelor este interzisă!"Blocuri de încercare / captură imbricate:
blocurile try / catch pot fi cuibărite. Programul de mai sus pentru introducerea de caractere non-alfanumerice de la tastatură se repetă aici, dar cu codul de eroare alfabetic imbricat:
#includefolosind spațiul de nume std;
char input = '*';
int main ()
încerca
if (isdigit (input))
arunca 10;
încerca
if (isalpha (input))
arunca 'z';
prinde (char)
cout << "Character input is forbidden!" << '\n';
prinde (int)
cout << "Digit input is forbidden!" << '\n';
retur 0;
Eroarea alfabetică try / catch-block este cuibărită în try-block-ul codului de cifră. Funcționarea acestui program și operația anterioară din care este copiat sunt aceleași.
noexcept-specifier
Luați în considerare următoarea funcție:
void fn (const char * str) noexceptif (islower (str [0]))
arunca 'l';
Observați specificatorul „noexcept” imediat după paranteze dreapta a listei parametrilor funcției. Aceasta înseamnă că funcția nu ar trebui să arunce o excepție. Dacă funcția lansează o excepție, ca în acest caz, se va compila cu un mesaj de avertizare, dar nu va rula. O încercare de a rula programul va apela funcția specială std :: terminate (), care ar trebui să oprească programul cu grație în loc să-i permită doar să se blocheze literalmente.
Specificatorul noexcept are diferite forme. Acestea sunt după cum urmează:
tasta func () noexcept; : nu permite o expresie de aruncaretasta func () noexcept (true); : permite o expresie de aruncare
tip func () throw (); : nu permite o expresie de aruncare
tasta func () noexcept (false); : permite o expresie de aruncare, care este opțională
tip func (); : permite o expresie de aruncare, care este opțională
adevărat sau fals între paranteze poate fi înlocuit cu o expresie care are drept rezultat adevărat sau fals.
Funcția Special std :: terminate ():
Dacă o excepție nu poate fi gestionată, ar trebui să fie aruncată din nou. În acest caz, expresia aruncată poate avea sau nu un operand. Funcția specială std :: terminate () va fi apelată la runtime, care ar trebui să oprească programul cu grație în loc să îi permită doar să se blocheze literalmente.
Tastați, compilați și rulați următorul program:
#includefolosind spațiul de nume std;
char input = '1';
int main ()
încerca
if (isdigit (input))
arunca 10;
prinde (int)
arunca;
retur 0;
După o compilare reușită, programul s-a încheiat fără să ruleze, iar mesajul de eroare de pe computerul autorului este:
„Terminați apelul după lansarea unei instanțe de„ int ”
Întrerupt (nucleul aruncat) "
Concluzie:
Funcția de excepție din C ++ împiedică executarea unui segment de cod pe baza unui anumit tip de intrare. Programul continuă să se execute după cum este necesar. Construcția de excepție (prevenirea erorilor) constă dintr-un try-block și un catch-block. Blocarea de încercare are segmentul de cod de interes, care poate fi ocolit, în funcție de anumite condiții de intrare. Blocul de încercare are expresia throw, care aruncă un operand. Acest operand este, de asemenea, numit excepție. Dacă tipul de operand și tipul pentru parametrul blocului de captură sunt aceleași, atunci excepția este capturată (gestionată). Dacă excepția nu este surprinsă, programul va fi terminat, dar totuși, fiți în siguranță, deoarece segmentul de cod care urma să fie executat pentru a da rezultatul greșit nu a fost executat. Tratarea tipică a excepțiilor înseamnă ocolirea segmentului de cod și trimiterea unui mesaj de eroare utilizatorului. Segmentul de cod este executat pentru intrări normale, dar este ocolit pentru intrări greșite.
