Valaki felvilagositana hogy a try kifejezes mire jo, mire alkalmazhato?

A try hibakezelés szempontjából tölt be fontos szerepet. A try blokkot mindig követi egy vagy több catch blokk (és opcionálisan egy finally blokk). A lényege annyi, hogy a try blokkban levő utasításokat megpróbálja lefuttatni a program, és ha bárminemű hiba történne, akkor ahelyett, hogy elszállna hibával a program, belép a megfelelő catch ágba, ahol kezelni tudod az adott hibát, majd folytatódik rendesen tovább a program futása a try-catch blokk után.

Fontos, hogy több catch ágat is megadhatsz, aminek azért van jelentősége, mert a catch ágakban megtudod adni, hogy milyen típusú hibát vársz az adott ágon, és és sorban haladva csak az első olyan catch ág fog lefutni, amelyre illeszkedik a dobott hiba. Példának okáért:

try{

someClassObj->operationThatMayFail(params);

}

catch(ClassSpecificException e)

{

someClassObj->cleanUpOperation();

}

catch(Exception e)

{

printf(e); //Output the error message

}

A fenti példában ha a try blokkban meghívott metódus az általad definiált ClassSpecificException hibát dobja, akkor meghívódik rajta a cleanUpOperation, bármilyen más Exception esetében pedig egyszerűen kiírjuk a hibaüzenetet. Fontos, hogy ha fordított sorrendben írnám fel a catch ágakat, akkor mindig a sima Exception ág futna le, mert azt ellenőrzi elsőként, és arra minden Exception ráillik. Azt is fontos megjegyezni, hogy ha a sime Exception ágat kihagynánk, akkor ha bármi olyan hiba lép fell a try blokkban, ami nem illik a ClassSpecificException kivételre, akkor ugyanúgy elszáll a program.

Opcionálisan megadható egy finally blokk is, ami többé-kevésbé mindig lefut, akár hibára lépett a try blokk, akár nem. AZért többé-kevésbé, mert ha kezeletlen hiba történik (ahogy az imént említettem) akkor ugyanúgy elmaradhat a finally blokk. Felvetülhet a kérdés, hogy mi értelme a finally blokknak, ha a program futása úgyis folytatódik a try-catch után, miért ne lehetne a finally blokkba szánt kódot egyszerűen utánaírni? Az az értelme, hogy a finally blokk scope-ja megegyezik a try blokkal, tehát a finally blokkban hozzáférsz olyan változókhoz, objektumokhoz, amiket a try blokkban hoztál létre, és ha szükséges elvégezhetsz rajtuk még bizonyos plusz műveleteket, amiket mindenképp lefuttatnál rajtuk. Ezt a try-catch blokk után már nem tudod megtenni, mert ott már kilépsz a try scope-jából, és a benne létrehozott változókat már nem éred el többé.

A try kifejezéssel külön választhatjuk a program logikát a hibakezeléstől.

Ha nem használnák try-t, akkor bizonyos funkciók meghívása után ellenőrizni kellene, hogy az hibásan futott-e le, vagy nem. Ha épp ciklusban vagyunk, akkor azt is be kell programoznunk, hogy kilépünk-e a ciklusból, vagy nem. Ha egy funkcióban vagyunk, akkor be kell programoznunk, hogy az a funkció hogy jelzi a meghívó funkciójának, hogy hiba történt benne. A meghívó funkcióban is be kell programoznunk a hibakezelést. Szóval try használata nélkül sok probléma van a hibakezeléssel.

De a try használatával könnyebb a hibakezelést megoldani. Azoknál az utasításoknál, amelyeknél kivételre lehet számítani, minden utasítást beteszel egy try-catch blokkba, és kész is a hibakezelés.

"try blokkot mindig követi egy vagy több catch blokk"

Ez nem feltétlen igaz. Lehet try-finally-t is csinálni catch nélkül.

Ez arra jó, ha valamit mindenképp le akarsz futtatni hiba esetén is, de az exceptiont nem akarod elkapni. (Majd kintebb valamelyik hívó kezeli le)

Nem minden nyelven van úgy ahogy leírtátok. pl. Delphi-ben Try...except és Try...finally van, kivételkezelésnél az on, on E: is játszik ha többféléről van szó főleg.

De mivel nem volt a nyelv meghatározva elég kimerítő magyarázatot kapott a kérdező.