
Telugu: 
C ++ లో ప్రోగ్రామింగ్
మాడ్యూల్ 37 కు స్వాగతం.
మేము మాడ్యూల్ లో
C - C ++ లో ఎర్రర్ హ్యాండ్లింగ్
(error handling) గురించి చర్చించాము.
వేర్వేరు ఎక్స్సెప్షన్స్(exceptions)
కారణాలు ఏమిటో పరిశీలించాము,
వివిధ రకాల వాటి
మరియు వాటి రకాల
అసమకాలిక మరియు సమకాలీకరణ.
అప్పుడు మేము ఎర్రర్లను
(error) నిర్వహించడానికి,
ఎక్స్సెప్షన్స్(exceptions)
నిర్వహించడానికి

Tamil: 
 
சி ++ இல் புரோகிராமிங்கின்
தொகுதி 39 க்கு வருக. வார்ப்புருக்கள்
அல்லது பொதுவான புரோகிராமிங்,
சி ++ இல் மெட்டா புரோகிராமிங்
பற்றி நாங்கள் விவாதித்து
வருகிறோம், அங்கு
சில செயல்பாடுகள்,
தற்காலிக செயல்பாடுகள்,
ஒன்று அல்லது அதற்கு
மேற்பட்ட வகை மாறிகள்
கொண்ட அளவுருவாக்கப்பட்ட
செயல்பாடுகளை எழுதலாம்,
இதனால் பயன்பாட்டின்

Hindi: 
C - ++ में प्रोग्रामिंग
के मॉड्यूल(module) 37 में
आपका स्वागत है।
हम पहले वाले मॉड्यूल(module)
में C - C ++ में एरर(error)
हैंडलिंग(handling) के
बारे में चर्चा कर
रहे हैं। हमने इस
बात पर ध्यान दिया
है कि विभिन्न अपवाद(exception)

English: 
Welcome to Module 37 of Programming in C++. We have been discussing about Error Handling
in C - C++ in the earlier module. We have
taken a look into what are the different exception
causes are, variety of them and their types
asynchronous and synchronous.
We then took a detailed view in terms of the different mechanism that is available in C
for handling errors, handling exception. And we saw that there is hardly any mechanism
available, actually no mechanism was provided in C with the thought of handling errors,

Tamil: 
அடிப்படையில் வெவ்வேறு
அளவுரு வகை வகைகளின்
வெளிப்படையான அல்லது
மறைமுகமாக வெவ்வேறு
செயல்பாடுகளைப்
பெற முடியும். அதிக
சுமைகளாக உருவாக்கப்பட்டு
செயல்படுத்தப்படலாம். கடைசி
தொகுதியில்
ஒரு ஆழத்தைக் கண்டோம். நாம்
முதலில் வடிவமைக்கப்பட்ட
வடிவத்தில் எழுதப்பட்ட
அதிகபட்ச செயல்பாட்டின்
ஒரு எடுத்துக்காட்டை
ஆழமாகவும், இரட்டிப்பாகவும்
பயன்படுத்தினோம்,
பின்னர் அதை சி சரங்களுக்கு
நிபுணத்துவம் பெற்றோம்,
பின்னர் இது சிக்கலான
போன்ற பயனர் வரையறுக்கும்
வகைகளுக்கும் வேலை
செய்யும் என்பதைக்
காட்டினோம்.
.
தற்போதைய தொகுதியில்,
நாங்கள்
அதைத் தொடருவோம்,
எங்கள் கவனம் சி
++ வைத்திருக்கும்
மற்ற வகை வார்ப்புருக்கள்
ஆகும், இது வகுப்பு
வார்ப்புரு என அழைக்கப்படுகிறது. இது
அவுட்லைன் மற்றும்
நீல

Telugu: 
C లో లభించే వివిధ
మెకానిజం(mechanism) పరంగా
వివరమైన వీక్షణను
తీసుకున్నాము. ఏ
యంత్రాంగాన్ని అందుబాటులో
లేవని మేము గమనించాము,
వాస్తవానికి C లో
ఎర్రర్లను (error) నిర్వహించడం
ఎక్స్సెప్షన్స్(exceptions)
పరిస్థితులను నిర్వహించడం,
మరియు తిరిగి విలువ
మరియు స్థానిక మరియు
స్థానిక గోటో(goto) ఎక్స్సెప్షన్స్(exceptions)
నిర్వహణ కోసం ఉపయోగించబడలేదు.
కానీ అనేక ప్రామాణిక
గ్రంథాలయ లక్షణాలను
అనేక ప్రామాణిక గ్రంధాలయాల
ద్వారా జోడించబడ్డాయి,
వీటిలో C లో ఎర్రర్లను
(error) నిర్వహించడానికి
మద్దతు ఇవ్వడం మరియు
ఇప్పటికీ చాలా చిన్న

Hindi: 
कारण क्या हैं, उनमें
से विभिन्न प्रकार
और उनके प्रकार अतुल्यकालिक(asynchronous)
और तुल्यकालिक(synchronous)
हैं।
हमने तब विभिन्न
तंत्रों के संदर्भ
में एक विस्तृत दृष्टिकोण
लिया, जो त्रुटियों
को संभालने, अपवाद(exception)
को संभालने के लिए
सी में उपलब्ध है।
और हमने देखा कि शायद
ही कोई मैकेनिज्म
उपलब्ध हो, वास्तव
में सी में एरर(error)
हैंडलिंग(handling) की
सोच के साथ कोई भी
मैकेनिज्म मुहैया
नहीं कराया गया था,
अपवाद(exception) स्थितियों
को संभालने के लिए,
लेकिन रिटर्न वैल्यू
और नॉन लोकल और लोकल

English: 
handling exception situations, but the return value and non local and local go to has been
used for exception handling. But there are
several standard library features that what
added through multiple standard libraries
to provide support for handling errors in
C and that still leads to a lot of a short
comings lot of difficulties and in view of
this here we are interested to study about
error handling in C++.
This is a module outline as you know the lower
part; the blue part is what you will be discussing
in the module today.
As we move to C++, certainly the designers
had been very sensitive and cautious about
incorporating the error handling as the part
of the language. The first expectation is
we should be able to separate error handling
code from ordinary code. Ordinary code means

Telugu: 
కదలికలు చాలా ఇబ్బందులకు
దారితీశాయి మరియు
దీని దృష్ట్యా ఇక్కడ
ఎర్రర్( error) హ్యాండ్లింగ్
C ++ లో.
మీరు దిగువ భాగాన్ని
తెలుసుకున్న మాడ్యూల్
సరిహద్దు; నీలం భాగంగా
మీరు మాడ్యూల్ లో
నేడు చర్చించడం ఉంటుంది
ఏమిటి.
మేము C ++ కు వెళ్ళినప్పుడు,
కచ్చితంగా డిజైనర్లు
భాషలో భాగమైన ఎర్రర్(
error) నిర్వహణను కలుపుతూ
గురించి చాలా సున్నితమైన
మరియు జాగ్రత్తగా
ఉన్నారు. మొదటి నిరీక్షణ

Tamil: 
பகுதி என்பது உங்கள்
திரையின் இடதுபுறத்தில்
கிடைக்கும் என்று
நாங்கள் விவாதிக்கிறோம்.
.
இது ஒரு விரைவான
மறுசீரமைப்பிற்கானது,
இது ஒரு வார்ப்புரு
என்னவென்று நாம்
காணப்படுகிறோம்,
அதன் செயல்பாட்டு
பகுதியை நாங்கள்
பார்த்துள்ளோம்.
.
செயல்பாட்டு வார்ப்புருவைப்
பொறுத்தவரை, செயல்பாட்டு
வார்ப்புருக்கள்
அடிப்படையில் அல்காரிதம்களில்
குறியீடு மறுபயன்பாடு
என்பதைக் கண்டோம். எனவே,
உங்களிடம் தேடல்
வழிமுறை உள்ளது,
எங்களிடம் வரிசை
வழிமுறை உள்ளது,
எங்களிடம் நிமிட
வழிமுறை உள்ளது,
எங்களிடம் சராசரி
வழிமுறை உள்ளது. சி
++ இல், இதற்கான குறியீடு
குறிப்பாக
உறுப்பு வகையின்
அடிப்படையில் திரும்ப
வேண்டும். ஆனால்,
பொதுவாக வழிமுறை
உறுப்பு வகைகளின்
அடிப்படையில் மாறாது,

Hindi: 
गोटो(goto) को अपवाद(exception)
हैंडलिंग(handling) के
लिए इस्तेमाल किया
गया है। लेकिन कई
मानक पुस्तकालय विशेषताएं
हैं जो सी में त्रुटियों
से निपटने के लिए
समर्थन प्रदान करने
के लिए कई मानक पुस्तकालयों
के माध्यम से जोड़ते
हैं और जो अभी भी बहुत
सारी छोटी-छोटी परेशानियों
का कारण बनते हैं
और यहां पर हम C ++ में
त्रुटि से निपटने
के बारे में अध्ययन
करने के इच्छुक हैं।
यह एक मॉड्यूल(module)
रूपरेखा है जैसा
कि आप निचले हिस्से

English: 
a normal flow. The normal flow and the error
handling as we saw are often intermixed we
would try to separate this out and that is
a requirement of exception handling in C++.
Second it is a language mechanism rather than
of the library, that is the language should
at the core take
of the fact that errors can happen exceptions
will need to be managed and therefore provide
a language feature for doing that.
Given as a language feature compilers would
be able to track all automatic variables and
take care of the lifetime destroying them
when there is some situation to terminate
or if not terminate a whole program, but to
abnormally terminate the execution of a certain
function the automatic variables will be taken
care off. There are schemes for destruction
of a dynamic memory and we will certainly
aspect that the overhead for the designers

Telugu: 
మేము సాధారణ కోడ్
నుండి ఎర్రర్( error)
నిర్వహణ కోడ్ని వేరుచేయగలగాలి.
సాధారణ కోడ్ అంటే
నార్మల్ ప్లో(normal
flow). నార్మల్ ప్లో(normal
flow) మరియు మేము చూస్తున్నప్పుడు
ఎర్రర్( error) నిర్వహణ
తరచుగా పరస్పరం కలుగజేయబడుతున్నాయి,
దీనిని వేరు చేయటానికి
ప్రయత్నిస్తాము
మరియు C ++ లో ఎక్స్సెప్షన్స్(exceptions)
నిర్వహణ అవసరమవుతుంది.
సెకను ఇది లైబ్రరీ
కాకుండా ఒక భాషా
మెకానిజం(mechanism), ఇది
భాష తప్పనిసరిగా
ఎర్రర్( error) జరిగేలా
నిర్వహించాల్సిన
అవసరం ఉండటం మరియు
నిర్వహించాల్సిన
భాషా ఫీచర్ (language feature)అందించడం

English: 
which we saw in the C style would should be
much less.
This is very very important which we look
at is often the exception does not happen
in the main, it will happen in function which
is in a deep nested call; main has called
one function; that has called another function;
that has called yet another function and so
on. Then in some 3, 4 levels, 5 levels of
calls or 10 levels of calls some exception
has happened so you need to come out of this
deep nesting of calls in the exception situation
so that should be possible. And variety of
situations, we should be able to handle through
a single handler.
These are the expectation with which the exception
mechanism in C++ has been designed and this
is a highest show the same illustration which
I was showing earlier in the earlier module
with the non local go to. So there is a function
f which is calling a function g and this is

Tamil: 
எனவே வார்ப்புருவைப்
பயன்படுத்தி நாம்
செயல்பாட்டு வார்ப்புருக்களை
எழுதலாம், இது இந்த
செயல்பாட்டுக் குறியீடுகளை
வரிசைப்படுத்துதல்,
தேடல், நிமிடம், அதிகபட்சம்,
சராசரி, பொதுவான
வடிவத்தில் உள்ள
அனைத்தையும் எழுதலாம்,
பின்னர் அதன் அடிப்படையில்
உடனடிப்படுத்தலாம்
அந்த வகை.
.
இப்போது, ​​தரவு
கட்டமைப்பின் அடிப்படையில்
குறியீடு மறுபயன்பாட்டைப்
பார்த்தால் மேலும்
பலவற்றைச் செய்யலாம். எடுத்துக்காட்டாக,
முதல் அடுக்கில்
கடைசியாக ஒரு அடுக்கைக்
கவனியுங்கள். பல
சிக்கல்களை
நீங்கள் உதாரணமாக
அடுக்கி வைப்பீர்கள்,
தீவிரத்தை மாற்றியமைப்பது
ஒரு
பாத்திரத்தின் அடுக்கு
தேவை. போஸ்ட்ஃபிக்ஸாக
மாற்றுவதற்கும்,
வெளிப்பாட்டை மாற்றுவதற்கும்
மீண்டும் எழுத்துக்களின்
அடுக்கு தேவைப்படுகிறது. போஸ்ட்ஃபிக்ஸ்
வெளிப்பாடுகளின்
மதிப்பீட்டிற்கு
நாம் மதிப்பீடு செய்ய
விரும்பும் முழு

Hindi: 
को जानते हैं; नीले
भाग को आज आप मॉड्यूल(module)
में चर्चा करेंगे।
जैसा कि हम C ++ में
जाते हैं, निश्चित
रूप से डिजाइनर भाषा
के भाग के रूप में
त्रुटि से निपटने
को शामिल करने के
बारे में बहुत संवेदनशील
और सतर्क थे। पहली
अपेक्षा यह है कि
हमें त्रुटि कोड
को साधारण कोड से
अलग करने में सक्षम
होना चाहिए। साधारण
कोड का अर्थ है एक
सामान्य प्रवाह।
सामान्य प्रवाह और
त्रुटि से निपटने

Telugu: 
వంటివి కావాలనే భాషా
జ్ఞానం తీసుకోవాలి.
ఒక భాషా లక్షణం(language
feature) కంపైలర్లు అన్ని
ఆటోమాటిక్ వేరియబుల్స్ను(automatic
variables) ట్రాక్ చేయగలవు
మరియు మొత్తం ప్రోగ్రామ్
(program) ముగించకపోయినా
లేదా హోల్ ప్రోగ్రామ్(
whole program) ముగించకపోయినా
కొన్ని పరిస్థితులు
ఉన్నప్పుడు వాటిని
నాశనం చేసే జీవితకాల
సంరక్షణను నిర్వహించగలవు,
కానీ అబ్నోర్మల్
టెర్మినెట్(abnormal terminate)
ఒక నిర్దిష్ట ఫంక్షన్
యొక్క అమలును అసాధారణంగా
రద్దు చేయడం ఆటోమేటిక్
వేరియబుల్స్ (automatic
variables) జాగ్రత్త తీసుకోవాలి.
డైనమిక్ మెమరీని
(dynamic memory)నాశనం చేయడానికి
పథకాలు ఉన్నాయి మరియు

English: 
function g. Now what it does it basically
does something called a throw, we will see
what does throw mean. And this is what some
kind of what will say is a exception class.
Once g is called then certainly the first
situation is a happy part, the normal flow;
so g will come out through the return. If
g comes our through the return it has a normal
flow the control goes to the next statement
h which is clear. But if g is called and because
of something happening in between because of some error situation arising in g it
across an error situation that will throw
an exception.
Which means it will throw is a keyword, it
will do throw and then it will put an object
of the exception class; any class can be used
as an exception class really. And if it throws

Tamil: 
எண், இரட்டை, சிக்கலான
பல்வேறு வகையான வகைகள்
தேவைப்படலாம். மூன்றின்
ஆழத்தின் முதல் பயணத்திற்கு
மூன்று முனைகளின்
முனை சுட்டிக்காட்டி
வகைகளின் அடுக்கு
தேவைப்படும். ஒரு
குறிப்பிட்ட
சிக்கல் தீர்வுக்கு
பல்வேறு வகையான அடுக்குகள்
தேவைப்படும் பல சிக்கல்கள்
இருக்கலாம்.
இப்போது, ​​ஒரு
தேர்வு என்னவென்றால்,
இந்த வகைகளில் ஒவ்வொன்றிற்கும்
நமக்குத் தேவையான
போதெல்லாம் ஒரு ஸ்டாக்
வகுப்பை
எழுதுவதுதான், ஆனால்
நாம் எதைப் பார்க்கிறோமோ,
நாம் பொதுவாக ஒரு
ஸ்டாக் குறியீட்டைக்
கொண்டிருக்கலாம்,
இது நாம் விரும்பும்
குறிப்பிட்ட வகையை
உடனடியாகக் கொடுக்கலாம்,
ஏனெனில், ஸ்டேக்
என புஷ், பாப், டாப்,
வெற்று மற்றும் பல
இடைமுகங்களின் தொகுப்பைக்

Hindi: 
के रूप में हमने देखा
कि हम अक्सर इसे अलग
करने की कोशिश करेंगे
और यह C ++ में अपवाद(exception)
हैंडलिंग(handling) की
आवश्यकता है।
दूसरा यह लाइब्ररी
के बजाय एक भाषा तंत्र
है, यही भाषा को इस
तथ्य पर ध्यान देना
चाहिए कि त्रुटियां
हो सकती हैं अपवादों
को प्रबंधित करने
की आवश्यकता होगी
और इसलिए ऐसा करने
के लिए एक भाषा सुविधा
प्रदान करनी चाहिए।
यह देखते हुए कि एक
भाषा सुविधा संकलक
सभी स्वचालित चर
को ट्रैक करने में
सक्षम होगा और जीवन

English: 
then the control does not come back to h,
does not come back to the statement immediately
following g it comes back to what is known
as a catch clause. So from here the control
will come out here and then you can take care
of the exception at this point. So it is called
by exception clause.
If you look into what all have become different
is now we have a try; we say it is a try block,
try is a keyword, catch is another keyword,
so there is a catch block and throw is another
keyword. We will say try throw catch; kind
of or try catch for simple terms. So what
we do in the caller, we put the calls within
a try block and a try block has an associated
catch. And the call function may throw saying
that thus exception as happened.
When it throws the basic behaviour is at this

Tamil: 
கொண்ட ஒரு கருத்து
முதலில் வெளியேறுகிறது,
இது ஸ்டேக் பயன்படுத்தும்
குறிப்பிட்ட உறுப்பு
வகையைப் பொறுத்து
மாறாது. நீங்கள்
மேலும் பார்த்தால்,
வரிசையில் இதேபோன்ற
பொதுவான தன்மையை
நீங்கள் காண்பீர்கள்,
பணி அட்டவணை திட்டமிடல்
செயல்முறை திட்டமிடல்
வரிசை பயனருக்கு
பல சிக்கல்கள் தேவைப்படுகின்றன,
அவை ஸ்டாக் வரிசையை
செயல்படுத்துவது
போன்ற பட்டியல் தேவை,
பின்னர் அவை அனைத்தும்
பொருள் சேகரிப்புகள்
மற்றும் பல.
வர்க்க வார்ப்புருக்கள்
அத்தகைய குறியீடு
மறுபயன்பாட்டிற்கான
ஒரு தீர்வாகும்,
உங்களிடம் ஒரே இடைமுகம்
மற்றும் அதே அல்லது
மிக நெருக்கமான வழிமுறைகள்,
ஒத்த வழிமுறைகள்
உள்ள தரவு கட்டமைப்பின்
பொதுவான பகுதியை

Hindi: 
भर का ध्यान रखते
हुए उन्हें नष्ट
कर देगा, जब किसी कार्यक्रम
को समाप्त करने या
पूरा करने के लिए
कुछ स्थिति न हो, लेकिन
किसी निश्चित कार्य
के निष्पादन को असामान्य
रूप से समाप्त करने
के लिए स्वचालित
चर ध्यान रखा जाएगा।
एक गतिशील मेमोरी
को नष्ट करने की योजनाएं
हैं और हम निश्चित
रूप से इस पहलू पर
ध्यान देंगे कि डिजाइनरों
के लिए ओवरहेड जो
हमने सी शैली में
देखा था, बहुत कम होना
चाहिए।

Telugu: 
మేము సి శైలిలో చూసిన
డిజైనర్ల కోసం ఓవర్
హెడ్ చాలా తక్కువగా
ఉండాలి.
ఇది మనం చూసే చాలా
ముఖ్యమైనది, ఎక్స్సెప్షన్స్(exceptions)
ప్రధానంగా జరగదు,
అది లోతైన సమూహంగా
ఉన్న ఫంక్షన్లో జరుగుతుంది,
ధాని నేస్టెడ్ కాల్
(nested call); ప్రధాన ఒక ఫంక్షన్
అని పిలుస్తారు;
మరొక ఫంక్షన్ అని
పిలుస్తారు; అది
మరో ఫంక్షన్ అని
పిలిచింది. అప్పుడు
3, 4 స్థాయిలు, కాల్స్
5 స్థాయిలు లేదా కాల్స్
యొక్క 10 స్థాయిలు
కాల్స్ కొన్ని ఎక్స్సెప్షన్స్(exceptions)

Tamil: 
நாங்கள் அடையாளம்
காண்கிறோம், ஆனால்
உறுப்பு வகைகளின்
காரணமாக செயல்படுத்தல்கள்
வித்தியாசமாக இருக்க
வேண்டும் பொதுவான
பொதுவான வகுப்பு
வார்ப்புருவின்
அடிப்படையில் அவற்றை
இணைக்கவும்.
              
எனவே, இது ஒரு இடது
மற்றும் வலது என்பதை
விளக்குவதற்கு, நீங்கள்
இங்கே பார்த்தால்
இது ஒரு பாத்திரத்தின்
அடுக்கு, இது தன்மை. இவை
குறிப்பிட்ட அறிவு
குறியீடுகளின் வகைகளாகக்
காட்டப்படுகின்றன,
அவை வகையின் அறிவு
தேவை, இது முழு எண்ணின்
அடுக்கு, எனவே
இவை தேவைப்படும்
கோடுகள். எனவே நீங்கள்
இங்கே முழு எண்ணைக்
கொண்டிருக்கிறீர்கள்,
இங்கே கரி, உங்களிடம்
இங்கே கரி உள்ளது,
உங்களிடம் இங்கே
கரி உள்ளது,

English: 
point the function was called if it throws
the basic is the try does not continue, the
control comes back to the try, but it does
not continue in the immediately next statement,
but it goes to the catch clause. In the catch
clause it tries to find what kind of exception
it as got and accordingly it will try to execute
the catch clause. So it will execute this
catch clause and then it will continue here.
Basically, there is some situation that has
happened here which is given rise to the function
g realising that exceptions needs to be reported,
error needs to be reported. The error object
is created here, then it is reported here
I am talking about the exception stage this
is a create stage if I cleanly draw it. This
is a create stage where you create that this
is a report stage.
And the interesting thing is we do not need
to do anything special for the detect because

Hindi: 
यह बहुत महत्वपूर्ण
है जिसे हम देखते
हैं अक्सर अपवाद(exception)
मुख्य में नहीं होता
है, यह फ़ंक्शन(function)
में होगा जो एक गहरी
नाक कॉल में है; main
ने एक फंक्शन को बुलाया
है; कि एक और समारोह
कहा जाता है; कि एक
और समारोह और इतने
पर बुलाया है। फिर
कुछ 3, 4 स्तरों, कॉलों
के 5 स्तरों या कॉलों
के 10 स्तरों में कुछ
अपवाद(exception) हुआ है,
इसलिए आपको अपवाद(exception)
स्थिति में कॉल की

Telugu: 
జరిగింది కాబట్టి
మీరు తప్పక ఎక్స్సెప్షన్స్(exceptions)
పరిస్థితిలో కాల్స్
ఈ లోతైన గూడు బయటకు
రావాలి. మరియు వివిధ
రకాలైన పరిస్థితుల్లో,
మేము సింగల్ హ్యాండ్లర్
(single handler) ద్వారా నిర్వహించగలగాలి.
ఇవి C ++ లో ఎక్స్సెప్షన్స్(exceptions
)విధానాన్ని రూపొందిస్తున్నట్లుగా
అంచనా వేయబడింది
మరియు ఇది ఇంతకుముందు
స్థానిక గోటో(goto)తో
గతంలో మాడ్యూల్ లో
చూపించిన అదే ఉదాహరణ.
కాబట్టి ఫంక్షన్
g అని పిలిచే ఫంక్షన్
f ఉంది మరియు ఇది ఫంక్షన్
g. ఇప్పుడు అది ఏమి
చేస్తుందో, ఇది ప్రాథమికంగా

English: 
the catch clause as is present will detect
it immediately then it takes care of this
in the code this is called the handler code
the catch handler or the exception handler,
handles it and then you come to the next where
you have the recover. This is how the exception
will get handled in terms of a C++ mechanism.
Let us look at a more detailed example and
try to understand this. I have couple of slides
following this where all these mechanisms
are explained, but first I would explain it
through an example. So, let us first look
at what the example has, forgetting about
the exception situation there is a function
h, there is a function g, there is a function
f and main function. And it is a simple nested
call main calls f, f in turn calls g, g in
turn calls h, h does something. These are
basic structure. The difference that we are

Tamil: 
மற்றும் இங்கே எண்ணாக
இருக்கிறது.
.
தவிர, மீதமுள்ள குறியீடு
சரியாகவே உள்ளது,
எனவே செயல்பாட்டின்
போது நாம் செய்ததைப்
போல ஒரு வகை மாறியால்
இதை ஏன்
மாற்றக்கூடாது. இது
வகை வார்ப்புருவுக்கு
வழிவகுக்கிறது, இது
வகையுடன் அளவுருவாக்கப்பட்டுள்ளது
மற்றும் அளவுரு உறுப்பினர்களின்
செயல்பாடுகளைக்
கொண்டிருக்கலாம். மீதமுள்ள
வரையறை விவரங்களுக்கானது
மற்றும் உதாரணத்தைப்
பார்ப்போம்.
.
எனவே ஸ்டேக்கிற்காக
நாங்கள் இந்த வகை
உறுப்பு வகையை டி
என அளவுருவாக்கியுள்ளோம்.
நீங்கள் அதைச்
செய்யும்போது, ​​உங்களுக்குத்
தேவையான இடங்களை
நீங்கள் பார்க்கும்போது
நீங்கள் தள்ளும்போது
நான் ஒரு உறுப்பு
வகையை அறிந்து கொள்ள
வேண்டும், நான்

Hindi: 
इस गहरी नेस्टिंग
से बाहर आने की आवश्यकता
है ताकि यह संभव हो।
और विभिन्न परिस्थितियों
में, हमें एक ही हैंडलर
के माध्यम से संभालने
में सक्षम होना चाहिए।
ये वे अपेक्षाएँ
हैं जिनके साथ C ++ में
अपवाद(exception) तंत्र
को डिज़ाइन किया
गया है और यह एक उच्चतम
चित्रण है जो मैं
पहले वाले मॉड्यूल(module)
में गैर स्थानीय
गोटो(goto) के साथ दिखा
रहा था। तो एक फंक्शन
f है जो फंक्शन g कह

Telugu: 
త్రో (throw)అని పిలువబడుతుంది.
మరియు ఏమి చెప్పాలో
కొన్ని రకమైన ఎక్స్సెప్షన్స్(exceptions
) క్లాస్ (class).
G అని పిలిచిన తర్వాత
ఖచ్చితంగా మొదటి
పరిస్థితి సంతోషకరమైన
భాగం, నార్మల్ ప్లో(normal
flow) కాబట్టి G తిరిగి
ద్వారా వస్తుంది.
G ద్వారా వస్తుంది
ఉంటే అది ఒక నార్మల్
ప్లో(normal flow) నియంత్రణ
వెళుతుంది తదుపరి
ప్రకటన h వెళ్ళే స్పష్టం.
G అయితే మరియు ఎందుకంటే
ఏదో జరుగుతున్న వాటిలో
ఏదో జరగడం వలన g లో
తలెత్తే ఎర్రర్(
error) ఏర్పడుతుంది,

Tamil: 
ஒரு மேல் செய்யும்
போது டி நான் உறுப்பு
வகையை அறிந்து கொள்ள
வேண்டும், பாப் அதை
அறிய தேவையில்லை,
வெற்று அதை அறிய
தேவையில்லை. இந்த
வகை டி என்பதால்,
நான் அளவுருவாக்கம்
செய்தேன் மற்றும்
செயல்பாட்டின் போது
நான் செய்த வழியை
வார்ப்புரு வகுப்பு
டி அடிப்படையில்
இங்கே ஒரு
டெம்ப்ளேட்டை வைத்தேன்,
இது இங்கே ஒரு டெம்ப்ளேட்
மாறி என்று கூறுகிறேன். இந்த
உறுப்பினர் செயல்பாடுகளின்
அடிப்படையில் அந்த
வார்ப்புரு மாறி
பயன்படுத்தப்படுகிறது.
எனவே, இதுதான் தற்காலிகமாக
வடிவமைக்கப்பட்ட
ஒரு அடுக்கை உருவாக்குகிறது,
இது எதற்கும் உடனடிப்படுத்தப்படலாம். நிச்சயமாக,
இந்த அடுக்கு
வார்ப்புரு வேலை
செய்ய நமக்கு சில

English: 
doing is when main calls f it puts it within
a and has an associated catch.
When f calls g puts it in a try block, has
multiple associated catch blocks. When g calls
h it puts in a try block has multiple associated
catch clause and h does the task, this is
the situation. If we look into any of g, f,
or main, we see that they are calling the
function within the try block expecting or
rather apprehending that this function might
fail and if it fails it will throw something
and whatever it throws I will catch in the
associated catch clause.
Now let us see why it is so many catch clauses
and what happens with that and so on. Let
say I have commented here all of them because
certainly if one throw happens in the function
is gone. Suppose this is not commented, so

Telugu: 
అది ఒక ఎక్స్సెప్షన్స్ని(exceptions)
త్రో (throw) చెస్తుంది.
ఇది త్రో (throw) చేస్తుంది
అర్థం ఒక కీవర్డ్(
keyword), అది త్రో (throw)చేస్తుంది
మరియు అది ఎక్స్సెప్షన్స్(exceptions
) క్లాస్ (class) ఒక ఆబ్జెక్ట్(
object) ఉంటుంది; ఏదైనా
క్లాస్ను(class) ఎక్స్సెప్షన్స్(exceptions)
క్లాస్గా (class) ఉపయోగించుకోవచ్చు.
మరియు అది విసురుతే
అప్పుడు నియంత్రణ
h తిరిగి రాదు, వెంటనే
ప్రకటన రాదు g తరువాత
ఇది క్యాచ్ క్లాజ్(catch
class) అని పిలుస్తారు
తిరిగి వస్తుంది.
ఇక్కడ నుండి నియంత్రణ

Hindi: 
रहा है और यह फंक्शन
g है। अब यह क्या करता
है, यह मूल रूप से
एक थ्रो नामक कुछ
करता है, हम देखेंगे
कि थ्रो का क्या मतलब
है। और यह है कि किसी
प्रकार का क्या कहेंगे
एक अपवाद(exception) वर्ग
है।
एक बार जी कहा जाता
है तो निश्चित रूप
से पहली स्थिति एक
खुश हिस्सा है, सामान्य
प्रवाह; इसलिए जी
वापसी के माध्यम

Telugu: 
ఇక్కడ వస్తాయి మరియు
మీరు ఈ సమయంలో ఎక్స్సెప్షన్స్ను
(exceptions) జాగ్రత్తగా
చూసుకోవచ్చు. కాబట్టి
అది ఎక్స్సెప్షన్స్(exceptions)
నిబంధనతో పట్టుకుంది.
మీరు అన్ని వేర్వేరుగా
మారినట్లయితే ఇప్పుడు
ప్రయత్నించండి.
మేము ఒక ప్రయత్నించండి
బ్లాక్ అని, ప్రయత్నించండి
ఒక కీవర్డ్( keyword) ఉంది,
క్యాచ్ (catch) మరొక కీవర్డ్
ఉంది, కాబట్టి ఒక
క్యాచ్ బ్లాక్ (catch
block) మరియు త్రో (throw)
మరొక కీవర్డ్ (keyword)
ఉంది. మేము త్రో క్యాచ్

Hindi: 
से बाहर आ जाएगा।
यदि जी रिटर्न के
माध्यम से हमारे
पास आता है तो इसका
सामान्य प्रवाह होता
है नियंत्रण अगले
स्टेटमेंट h पर जाता
है जो स्पष्ट है।
लेकिन अगर जी कहा
जाता है और जी में
उत्पन्न होने वाली
कुछ त्रुटि स्थिति
के कारण बीच में कुछ
हो रहा है तो यह एक
त्रुटि स्थिति में
आता है जो अपवाद(exception)

Tamil: 
வகை பண்புகளை பூர்த்தி
செய்ய வகை T, வகை மாறி
T தேவைப்படும். எடுத்துக்காட்டாக,
உருப்படி வகை T மற்றும்
தரவு i வகை T மற்றும்
தரவு உறுப்பு. எனவே
இங்கே ஒரு பணி சாத்தியம்
என்பதைக் காண்கிறோம். நகல்
ஒதுக்கீட்டு
ஆபரேட்டர் இந்த இடத்தில்
இருக்க வேண்டும்,
அது இல்லாமல் நீங்கள்
ஒரு குறிப்பிட்ட
வகையுடன் அடுக்கை
நிறுவ முடியாது.
.
இதைப் பயன்படுத்தி
இப்போது இதைப் பார்த்தால்,
ஸ்டேக் டாட் எச்
தலைப்புக்குச் செல்லும்
அனைத்தும் என்று
கருதி, நான் அதை உடனடியாக
நிறுவுவதைப் போலவே

English: 
what happens is it is doing something comes
across an error and it throws one. If it throws
one what does that mean? What is one? Basically
it is throwing an int kind of object. If it
throws then the controls goes, if we look
into the calls stack then what do we have
we have main, main has called f, f has called
g, g has called h. This is a where we are
at present.
Now if you do throw, then it has detected
that it cannot proceed any further, so throw
is pretty much like as if you want in terms
of control flow you are trying to go out of
this function. So you want to go out and go

Tamil: 
அதை உடனடியாக நிறுவுகிறேன். இது
இப்போது நான்
இதைப் பயன்படுத்தக்கூடிய
எழுத்துக்களின்
அடுக்கைக் கொடுக்கும். இந்த
குறியீடுகளில் இந்த
எண்ணிக்கையை
நாம் பல முறை பார்த்த
இந்த குறியீட்டை
விளக்க நான் செல்லமாட்டேன்,
உண்மையில் அந்த அடுக்கைப்
பயன்படுத்தலாம்.
.
அதே தலைப்பு அடுக்கு
புள்ளி
h உடன். நான் இப்போது
ஒரு தனி விண்ணப்பத்தை
எழுத முடியும். எனவே,
இதே
தலைப்பு அதே மாதிரியான
ஸ்டேக் குறியீடாகும்,
நான் போஸ்ட்ஃபிக்ஸ்
வெளிப்பாட்டை மதிப்பீடு
செய்ய வேறு பயன்பாட்டை
எழுத முடியும். இங்கே
வெளிப்பாடுகள் முழு
எண்ணாக இருப்பதால்,
எனக்கு ஒரு அடுக்கு

English: 
back to g. Now why do you go back in g? In
g the call of h is guarded within the try
block, so it does not go back to this point.
Rather as you throw the control goes to the
list of catch clauses that you have. And what
have been thrown is; one which is an int.
Now once you get there what happens is something
very very interesting it takes this object,
object one and goes over this list of catch
clauses and tries to match. If it finds a
match then it immediately stops there and
executes the corresponding handler. If it
does not find a match it proceeds further.
So what happens in case of if one has been
thrown it is an int object, so catch is aspecting
an int since it is aspecting an int it matches

Telugu: 
ట్రై (try throw catch )అని చెప్పబడును;
రకమైన లేదా సాధారణ
పదాల కోసం ట్రై క్యాచ్(
try catch) . కాబట్టి మేము
కాలర్లో ఏమి చేస్తాం,
ఒక ట్రై బ్లాక్( try
block)బ్లోక్ లోపల కాల్స్
ఉంచాము మరియు ఒక
ట్రై బ్లాక్( try block)ఒక
సంబంధిత క్యాచ్ ఉంది.
మరియు కాల్ ఫంక్షన్
ఎక్స్సెప్షన్స్(exceptions)
త్రో (throw)చెపుతుంధి.
ఇది ప్రాథమిక ప్రవర్తనను
విసిరివేసినప్పుడు,
అది ప్రాథమికంగా
విఫలమైతే, ఆ ప్రయత్నం
కొనసాగించకపోతే,
ఆ ప్రయత్నం తిరిగి
ప్రయత్నిస్తుంది,

Hindi: 
को फेंक देगा।
इसका मतलब है कि यह
फेंक देगा एक कीवर्ड
है, यह फेंक देगा और
फिर यह अपवाद(exception)
वर्ग की एक वस्तु
डाल देगा; किसी भी
वर्ग को वास्तव में
अपवाद(exception) वर्ग के
रूप में इस्तेमाल
किया जा सकता है।
और अगर यह फेंकता
है तो नियंत्रण एच
में वापस नहीं आता
है, जी के तुरंत बाद
बयान पर वापस नहीं

English: 
and it will execute this cout int. This is
just saying that it if as if this is a handler.
Once this is done, then the control will jump
the remaining of the catch clauses and some
here and continue. Now, whatever g has to
do; now the whole thing has already taken
place, the error happened, it was reported,
it has been detected here, it has been handled
here, you recovered and you are proceeding
to this part.
Let us see what happens if you, let us say
again draw the stack that will be important
in every case h, g, f main. Now let us say
this is where something was happening and

Telugu: 
కాని ఇది వెంటనే
తదుపరి ప్రకటనలో
కొనసాగదు, కానీ అది
క్యాచ్ క్లాజ్(catch
clause). క్యాచ్ నిబంధనలో
ఇది ఏ విధమైన ఎక్స్సెప్షన్స్(exceptions)
పొందాలో ప్రయత్నిస్తుంది
మరియు దానికి క్యాచ్
catch నిబంధన అమలు చేయడానికి
ప్రయత్నిస్తుంది.
కనుక ఇది క్యాచ్
నిబంధనను అమలు చేస్తుంది
మరియు అది ఇక్కడ
కొనసాగుతుంది.
ప్రాథమికంగా, ఇక్కడ
జరిగిన కొన్ని పరిస్థితి

Hindi: 
आता है यह जी कैच धारा(clause)
के रूप में जाना जाता
है जो वापस आता है।
इसलिए यहां से नियंत्रण
यहां से बाहर आ जाएगा
और फिर आप इस बिंदु
पर अपवाद(exception) का ख्याल
रख सकते हैं। इसलिए
इसे अपवाद(exception) खंड
द्वारा पकड़ा जाता
है।
यदि आप देखते हैं
कि सभी अलग हो गए हैं
तो अब हमारे पास एक
कोशिश है; हम कहते
हैं कि यह एक कोशिश

Tamil: 
தேவைப்படுகிறது,
இது வெளிப்பாடு மதிப்புகளை
எந்த முழு எண்ணாக
வைத்திருக்கும்,
எனவே இது முழு எண்ணாக
உடனடிப்படுத்தப்படுகிறது. நான்
சி உடன் செய்திருந்தால்,
இரண்டு வெவ்வேறு
ஸ்டேக் செயலாக்கங்கள்,
தலைகீழ் சரத்திற்கான
கரி அடிப்படை செயல்படுத்தல்
மற்றும் இந்த குறிப்பிட்ட
போஸ்ட்ஃபிக்ஸ் மதிப்பீட்டு
சிக்கலுக்கான முழு
தலைகீழ் செயல்படுத்தல்
ஆகியவற்றைப் பயன்படுத்த
வேண்டியிருக்கும்,
ஆனால் நான் அதே மாதிரியான
ஸ்டேக் வரையறை மற்றும்
இரண்டு வெவ்வேறு
வகைகளுடன் உடனடியாக
நிறுவப்பட்டது. இது
வர்க்க வார்ப்புருவின்
அடிப்படை சக்தி
மற்றும் இது குறிப்பிட்ட
மற்றும் வெவ்வேறு

English: 
it re reaches a point where it throws 2.5,
just to show that that is a something different
has happened.
Now what is 2.5? 2.5 is an object of the double
time we know. As it throws the control comes
back to g. Where does it come back? It does
not come back here; it comes back to the beginning
of the catch clause because something has
been thrown. And you starts matching it has
a double object it tries to match int it will
fail it will not be able to match. Catch clause
is do not match by implicit conversion.
If we look into this match strategy this looks
pretty much like the overload matching. So
as if you can think of then thrown as if is
calling a function with a parameter one single
parameter. And there are several functions
as if here, three functions here which takes

Hindi: 
ब्लॉक(block) है, कोशिश
एक कीवर्ड है, कैच
एक अन्य कीवर्ड है,
इसलिए एक कैच ब्लॉक(block)
है और थ्रो एक अन्य
कीवर्ड है। हम कहेंगे
कि थ्रो कैच का प्रयास
करें; सरल शब्दों
के लिए कैच या ट्राई
कैच। तो हम कॉलर में
क्या करते हैं, हम
कॉल को एक कोशिश ब्लॉक(block)
में डालते हैं और
एक कोशिश ब्लॉक(block)
में एक संबद्ध पकड़
होती है। और कॉल फ़ंक्शन(function)

Tamil: 
பயன்பாட்டு வகுப்புகளில்
தரவு கட்டமைப்புகளின்
அடிப்படையில் எங்களுக்கு
நிறைய பொதுமைப்படுத்தலை
வழங்குகிறது.
இப்போது, ​​இயற்கையாகவே
நான் குறிப்பிட்டுள்ளபடி,
இந்த
உடனடி செயலைச் செய்யும்போது. முன்னதாக
நாங்கள் அதை செயல்பாட்டு
வார்ப்புருக்களுக்காகப்
பார்த்தோம்,
இப்போது நீங்கள்
அதை வகுப்பு வார்ப்புருவுக்குப்
பார்க்கிறீர்கள்,
வார்ப்புருவில்
பயன்படுத்தப்படும்
வகை அளவுருக்கள்
அளவுருக்கள் அவை
எந்த வகையிலும் இருக்கலாம்
என்று சில பண்புகளை
பூர்த்தி செய்யும்
என்பதை நாங்கள் உறுதி
செய்ய வேண்டும். மற்ற
அளவுருவாக்கப்பட்ட
வகைகளும் இருக்கலாம்,
அவை வார்ப்புரு தங்களைத்
தட்டச்சு செய்யலாம்,
ஆனால் முக்கியமானது
என்னவென்றால், வகுப்பைச்
செயல்படுத்துவதற்கான

Telugu: 
ఉంది, ఇది ఎక్స్సెప్షన్స్లను
(exceptions) నివేదించాల్సిన
అవసరం ఉందని ఫంక్షన్
G కి పెరుగుతుంది,
ఎర్రర్( error) నివేదించాల్సిన
అవసరం ఉంది. ఎర్రర్(
error) ఆబ్జెక్ట్ (object)
ఇక్కడ సృష్టించబడింది,
అది నివేదించబడింది
ఇక్కడ నేను ఎక్స్సెప్షన్స్(exceptions)
దశల గురించి మాట్లాడుతున్నాను,
నేను దానిని సరిగా
డ్రా చేస్తే ఇది
సృష్టించే దశ. ఇది

Tamil: 
செயல்பாட்டு வார்ப்புருவை
செயல்படுத்துவதற்குத்
தேவையான முறைகளை
அவர்கள் ஆதரிக்க
வேண்டும். எனவே, அவை
போன்ற பண்புகள்,
அவை கட்டமைப்பாளரை
ஆதரிக்க வேண்டியிருக்கலாம்,
அவை வெவ்வேறு ஆபரேட்டர்களை
ஆதரிக்க வேண்டியிருக்கும்,
அதற்கான நிகழ்வுகளை
நாங்கள் கண்டோம். செயல்பாட்டு
வார்ப்புரு மற்றும்
வகுப்பு வார்ப்புரு
இரண்டையும் பின்பற்ற
வேண்டிய அடிப்படை
வகை பண்புகள் அவை.
.
எனவே, செயல்பாட்டு
வார்ப்புருவின்
விஷயத்தில் நீங்கள்
பார்த்தது இதுதான்,
இது உங்கள் மறுபரிசீலனைக்கு
மட்டுமே.
வர்க்க வார்ப்புருவைப்
பொறுத்தவரை, இன்ஸ்டன்டேஷன்
வெளிப்படையாக செய்யப்பட
வேண்டியது அவசியம்,
அது

English: 
an int x a double and takes some dot dot dot
and you are trying to resolve which particular
function, which particular catch clause will
be resolved.
But there are two major distinctions from
the overload resolution; one is overload resolution
allows you for implicit conversion. For example
int will be matched with double double will
be truncated and matched within and so on.
This is not allowed in deciding on the catch
clause. The second is overload resolution
happens over the set of functions as a whole.
Here it will happen according to this order.
And as soon as you found a match you will
not try to find if there is a better match,
you will just end there and call that catch
clause. So what will happen here? They have
a double object; this will not match, but
this will match. Now, it will do print double
and then it will recovered continues here

Hindi: 
यह कहते हुए फेंक
सकता है कि अपवाद(exception)
हुआ है।
जब यह मूल व्यवहार
को फेंकता है तो इस
बिंदु पर फ़ंक्शन(function)
को कहा जाता है यदि
यह फेंकता है तो बुनियादी
कोशिश जारी नहीं
रहती है, नियंत्रण
वापस कोशिश में आता
है, लेकिन यह तुरंत
अगले बयान में जारी
नहीं होता है, लेकिन
यह जाता है पकड़ना।
कैच धारा(clause) में यह

Telugu: 
ఒక రిపోర్టు దశ అని
మీరు సృష్టించే వేదిక.
ఆసక్తికరమైన విషయం
ఏమిటంటే, గుర్తించటానికి
ప్రత్యేకమైనది ఏమీ
లేదు ఎందుకంటే క్యాచ్
క్లాజ్ (catch clause) ప్రస్తుతం
ఉన్నట్లుగా గుర్తించబడుతుంటే
వెంటనే ఈ కోడ్ను
ఈ హ్యాండ్లర్ కోడ్,
క్యాచ్ హ్యాండ్లర్
లేదా ఎక్స్సెప్షన్
హ్యాండ్లర్ (exception
handler) అంటారు. , అది నిర్వహిస్తుంది
మరియు మీరు తిరిగి
ఉన్న తరువాత మీరు
ఇక్కడకు వస్తారు.
ఇందుకు ఎక్స్సెప్షన్(exception)

English: 
that is a sample thing.
Let us continue on this and try to see what
happens next. Main, f, g, h, let us check
this. Here what is my exception, there is
a standard library exception which has a class
called exception predefined which takes care
of all different kinds of exception that can
happen in C++. I have defined a class which
is a specialization of exception class so
some throwing an object of my exception. What
happens again? As the control comes to g that
is starts when this tries to match with int
does not match have a my exception object,
tries to match with catch the double does
not match, then tries to match here, what
is this? This is known as ellipses.

Tamil: 
ஒரு வர்க்கம் என்பதால்
இது மிகவும் சாத்தியமானது,
உண்மையில் வழங்காமல்
வகுப்பை முன்னோக்கி
அறிவிப்பாக வரையறுக்க
முடியும், எனவே இதை
நான் உண்மையில் எழுத
முடியும் ஒரு முழுமையற்ற
அடுக்கு வகை என்று
அழைக்கப்படுகிறது. இது
வகை T ஆல் அளவுருவாக்கப்பட்ட
ஸ்டாக் என்று ஒரு
வர்க்கம் உள்ளது
என்று கணினிக்குச்
சொல்ல இது முன்னோக்கி
அறிவிப்பு என்று
கூறுகிறது, ஆனால்
அது என்ன முறைகள்
மற்றும் பலவற்றைக்
கூறவில்லை. எனவே,
அதனுடன். நான் பொருளை
உடனடிப்படுத்த முயற்சித்தால்,
நான் ஒரு பிழையைப்
பெறுவேன், ஏனென்றால்
கட்டமைப்பாளர், அழிப்பவர்,
பிற ஆபரேட்டர்கள்
மற்றும் உறுப்பினர்கள்

Hindi: 
खोजने की कोशिश करता
है कि उसे किस तरह
का अपवाद(exception) मिला
है और तदनुसार यह
कैच धारा(clause) को निष्पादित
करने का प्रयास करेगा।
इसलिए यह इस कैच धारा(clause)
को अंजाम देगा और
फिर यह यहां जारी
रहेगा।
मूल रूप से, कुछ ऐसी
स्थिति है जो यहां
हुई है, जिसे फ़ंक्शन(function)
जी को यह देखते हुए
दिया गया है कि अपवादों
को रिपोर्ट करने
की आवश्यकता है, त्रुटि
की रिपोर्ट करने

Telugu: 
C ++ యంత్రాంగంతో ఎలా
నిర్వహించబడుతుందో.
మరింత వివరణాత్మక
ఉదాహరణను చూద్దాం
మరియు దీన్ని అర్థం
చేసుకోవడంలో ప్రయత్నించండి.
నేను ఈ రెండు స్లయిడ్లను
కలిగి ఈ అన్ని విధానాలు
వివరించారు ఇక్కడ,
కానీ మొదటి నేను
ఒక ఉదాహరణ ద్వారా
వివరించడానికి ఉంటుంది.
కాబట్టి, మనం ఉదాహరణ
ఏమిటో చూద్దాం ఎక్స్సెప్షన్స్(exceptions)
పరిస్థితిని గురించి
మర్చిపోవడమే ఫంక్షన్
h, ఫంక్షన్ g, ఫంక్షన్
f మరియు ప్రధాన ఫంక్షన్
ఉంది. మరియు అది ఒక
సాధారణ సమూహ కాల్

Tamil: 
மற்றும் பலவற்றை
நான் அறிந்தாலன்றி
பொருளை உடனடியாக
நிறுவ முடியாது.
ஆனால் இந்த
வகைக்கு ஒரு சுட்டிக்காட்டி
என்னால் இன்னும்
வரையறுக்க முடியும்; இந்த
வகைக்கான குறிப்பை
என்னால் வரையறுக்க
முடியும். எனவே நான்
ஒரு தலைகீழ்
சரம் செயல்பாட்டை
வரையறுக்க முடியும்,
இது உண்மையில் என்னவென்று
எனக்குத் தெரியாதபோது
இந்த வகையை ஒரு குறிப்பாக
எடுத்துக்கொள்கிறது. ஆனால்
நான் ஸ்டேக் செயல்பாடுகளை
இயற்கையாகவே
பயன்படுத்த விரும்பும்
போது தலைகீழ் சரம்
செயல்பாட்டின் உடலை
செயல்படுத்த விரும்பினால்,
அந்த ஸ்டாக் வரையறை
உண்மையில் என்ன என்பதை
நான் அறிந்து கொள்ள
வேண்டும்.

Telugu: 
ప్రధానంగా కాల్స్
f, f అని పిలుస్తుంది
g, g, h, h అని పిలుస్తుంది
g, h ఏదో చేస్తుంది.
ఇవి ప్రాథమిక నిర్మాణం.
ప్రధాన కాల్స్ అది
ఒక ప్రయత్నించండి
బ్లాక్ ఎర్రర్(error)
ఉంచుతుంది మరియు
సంబంధం క్యాచ్(catch)
కలిగి ఉన్నప్పుడు
మేము చేస్తున్న తేడా
ఉంది. ఒకవేళ కాల్పులు
జరుపుకోవటానికి
ప్రయత్నిస్తే అది
బహుళ అనుబంధ క్యాచ్
బ్లాక్లను(catch block) కలిగి
ఉంటుంది. ఒకవేళ g పిక్స్
లో బ్లాక్ చేస్తే
అది బహుళ బ్లాక్
క్యాచ్ నిబంధనను
కలిగి ఉంటుంది మరియు

Hindi: 
की आवश्यकता है।
त्रुटि ऑब्जेक्ट(object)
यहां बनाया गया है,
फिर यह बताया गया
है कि मैं यहां अपवाद(exception)
चरणों के बारे में
बात कर रहा हूं, यह
एक मंच है अगर मैं
इसे स्पष्ट रूप से
आकर्षित करता हूं।
यह एक बनाएँ मंच है
जहाँ आप बनाते हैं
कि यह एक रिपोर्ट
चरण है।
और दिलचस्प बात यह
है कि हमें पता लगाने

English: 
Ellipses are three dots they are supposed
to match with anything. Whatever you have
that will match with that. So, ellipses will
match with one it will match with double,
it will match with my exception, it will match
with exception anybody, but earlier cases
when we are thrown 1 or we had throw 2.5 since
int and double catch clauses where before
this ellipses then it did not fall through
to this point. But here with my exception
these two did not match so it comes here and
matches at this point this is also known as
a catch all clause because it matches everything.
So it goes to handle that, and what is a handle
do? Handle does something very simple it says
throw which means that it is not going to

English: 
do anything but as the h function as thrown
a my exception object this will simply re
throw that object to the caller. So which
means it will re throw it will go back go
upwards to its caller it will the stack will
come down to its caller. The caller was f
caller had called g and you have thrown, what
is your exception object? Exception object
is what you had received from h, my exception
object.
So since you have come here through an exception
being thrown you will continue on the catch
clauses. So, now you have a my exception object
and you have a my exception catch clause so
it matches say my exception skip over the
other catch clauses and then you go to the

Hindi: 
के लिए कुछ विशेष
करने की आवश्यकता
नहीं है क्योंकि
जो पकड़ धारा(clause) मौजूद
है वह तुरंत पता लगा
लेगा फिर यह कोड में
इस बात का ध्यान रखता
है इसे हैंडलर कोड,
कैच हैंडलर या अपवाद(exception)
हैंडलर कहा जाता
है , इसे संभालता है
और फिर आप अगले पर
आते हैं जहां आपके
पास ठीक है। इस तरह
यह अपवाद(exception) C ++ तंत्र
के संदर्भ में नियंत्रित
हो जाएगा।
आइए हम एक अधिक विस्तृत

Tamil: 
உடனடிப்படுத்தலைப்
பொறுத்தவரை, சோம்பேறி
உடனடிப்படுத்தல்
என்பது
மிகவும் பயனுள்ளதாக
இருக்கும் என்று
உங்களுக்குத் தெரியும். எனவே,
நான் அதே தலைகீழ்
சரம் குறியீட்டை
சற்று வித்தியாசமாகக்
காண்பிக்கிறேன்,
முன்பு இந்த முழு
ஸ்டேக் வகுப்பும்
இங்கே சேர்க்கப்பட்ட
ஸ்டாக் டாட் எச்
என்ட்ஸில் வைக்கப்பட்டது,
இதனால் முழு எண்ணமும்
அங்கேயே நடக்கிறது. ஆனால்
இப்போது சில விஷயங்களை
காட்ட இங்கே நான்
இதைச் சேர்த்துள்ளேன்,
எடுத்துக்காட்டாக,
இங்கே எங்களிடம்
ஒரு முன்னோக்கி அறிவிப்பு
உள்ளது, எனவே அந்த
முன்னோக்கி அறிவிப்புடன்
தலைகீழ் சரம் செயல்பாட்டின்
கையொப்பத்தை நான்
வைத்திருக்க முடியும்,
இது இங்கே வைக்கப்பட்டுள்ள

Telugu: 
h పని చేస్తుంది, ఇది
పరిస్థితి. మేము
g, f లేదా main లలో ఏమైనా
పరిశీలిస్తే, అవి
ప్రయత్నిస్తున్న
బ్లాక్(block) ఎర్రర్(error)
పనితీరును కాల్ చేస్తున్నట్లుగా
చూస్తాం లేదా బదులుగా
ఈ ఫంక్షన్ విఫలం
కావచ్చు మరియు అది
విఫలమైతే అది ఏదో
త్రో (throw) చేస్తుంది
మరియు అది ఏది విసిరేదో
నేను విసిరేస్తాను
సంబంధం క్యాచ్ నిబంధన.
ఇప్పుడు అది ఎందుకు

English: 
remaining of the f function and continue.
So, it is not necessarily that the caller
will be able to handle the exception that
you throw, the caller might handle that, caller
might propagate it higher up to for the caller
to handle that and we say that is re throwing
an exception this is what you have done specially
here.
Let us move forward and see what if I throw
an exception of the class exception of which
my exception was a specialization. Now, what
will happen is, I come again here it goes
to this point because these two do not match
I throw, I come, I come here, match the exception
I can see the exception. Suppose I throw my
class is some other class and I throw an exception

Hindi: 
उदाहरण देखें और
इसे समझने का प्रयास
करें। मेरे पास कुछ
स्लाइड्स हैं, जहां
इन सभी तंत्रों के
बारे में बताया गया
है, लेकिन पहले मैं
इसे एक उदाहरण के
माध्यम से समझाऊंगा।
तो, आइए पहले देखें
कि उदाहरण में क्या
है, अपवाद(exception) स्थिति
के बारे में भूलकर
एक फ़ंक्शन(function) ज
है, एक फ़ंक्शन(function)
जी है, एक फ़ंक्शन(function)
एफ और मुख्य फ़ंक्शन(function)
है। और यह एक साधारण
नेस्टेड कॉल मुख्य
कॉल f, f इन टर्न कॉल

Tamil: 
சரத்தை மாற்றியமைக்கும்,
ஏனெனில் ஒரு இது
T ஆல் வார்ப்புரு
செய்யப்பட்ட ஒரு
அடுக்கைப் பயன்படுத்துகிறது
என்பதை அறிய வேண்டிய
அனைத்தையும் குறிப்பிடுங்கள்,
மேலும் வார்ப்புரு
இந்த விஷயத்தில்
கரி ஆகும்.
ஆனால் அந்த வகை என்ன,
அது எவ்வாறு செயல்படுத்தப்படுகிறது
என்று தெரியவில்லை
மற்றும் அது ஒரு
குறிப்பைப் பார்ப்பதால்
அது கவலைப்படவில்லை. நான்
இதை முக்கியமாக வைத்திருந்தால்,
இந்த செயல்பாட்டை
நான் உண்மையில் செயல்படுத்த
முடியும், ஏனென்றால்
நான் தெரிந்து கொள்ள
வேண்டியது எல்லாம்
உடல் பின்னர் வரக்கூடிய
செயல்பாட்டின் கையொப்பமாகும்,
எனவே நான் வேண்டுமென்றே
உடலை ஒரு பிந்தைய
கட்டத்தில் வைத்துள்ளேன்.
பிரதான
உடலை அறிய தேவையில்லை.
ஆனால்
நிச்சயமாக, இங்கே
ஒரு குறிப்பு அளவுருவாக
ஒரு அடுக்கின் உதாரணத்தை
நான் அனுப்ப வேண்டும். எனவே,
இந்த
அடுக்கை உடனடிப்படுத்த
முக்கிய தேவைகள். ஸ்டேக்கின்
வரையறையை அறியாமல்

Telugu: 
చాలా క్యాచ్ క్లాజ్(catch
clause) మరియు దానితో
మరియు అలా జరుగుతుంది.
నేను వాటిని అన్ని
ఇక్కడ వ్యాఖ్యానించాను
ఎందుకంటే ఖచ్చితంగా
ఒక త్రో ఫంక్షన్
లో ఉంటే ఖచ్చితంగా
పోయింది. ఇది వ్యాఖ్యానించబడదు
అని అనుకుందాం, కాబట్టి
ఏదో ఒక పని చేస్తున్నప్పుడు
ఏమి జరుగుతుందో అది
ఒక ఎర్రర్(error) వస్తుంది.
ఇది ఒకటి విసురుతాడు
ఉంటే అది అర్థం ఏమిటి?
ఏది? ప్రాథమికంగా
ఇది ఒక పూర్ణాంకానికి
వస్తువును విసిరివేస్తుంది.

Telugu: 
అది విసురుతాడు అయితే,
నియంత్రణలు వెళ్తాయి,
మేము కాల్స్ స్టాక్తో
చూస్తే, మనకు ప్రధానమైనది
ఏమిటంటే, ప్రధానంగా
F అని పిలిచారు, g, g
అని పిలిచింది, g h
అని పిలిచింది. మేము
ప్రస్తుతం ఎక్కడ
ఉన్నాము. ఇప్పుడు
మీరు త్రో (throw) చేస్తే,
అది ఏదీ ముందుకు
సాగలేదని గుర్తించింది,
కాబట్టి మీరు త్రోయడానికి
ప్రయత్నించే నియంత్రణ
ప్రవాహంతో మీకు కావలసినంత

Tamil: 
தலைகீழ் சரத்தின்
கையொப்பத்தை நீங்கள்
வரையறுக்க முடியும்
என்றாலும், நீங்கள்
முக்கிய செயல்பாட்டை
எழுத முடியாது, ஏனென்றால்
ஸ்டேக்கின் வரையறை
உங்களுக்குத் தெரியாவிட்டால்
இந்த நிகழ்வை எழுத
முடியாது. எனவே அடுக்கின்
வரையறை அடுக்கின்
உடனடி நிலைக்கு முன்னதாக
இருக்க வேண்டும். ஏனென்றால்
இப்போது உங்களிடம்
ஒரு பொருள்
நிகழ்வு இருந்தால்,
நாங்கள் கட்டமைக்க
முடியும், அதை அழிக்க
முடியும், அது எல்லா
வெவ்வேறு செயல்பாடுகளையும்
செயல்படுத்த முடியும்.
எனவே இது ஒரு வகையானது,
ஒரு
வர்க்க வார்ப்புரு
இன்ஸ்டன்டேஷனின்
விசைகளில் நீங்கள்
எல்லாவற்றையும்
ஒன்றாக உடனடியாக
நிறுவ வேண்டியது
அவசியமில்லை என்பதை
நான் முன்னிலைப்படுத்த
விரும்பினேன். நீங்கள்
வகுப்பிற்கான குறிப்பை
உடனடிப்படுத்துகிறீர்களானால்
அல்லது வார்ப்புருவுக்கு
சுட்டிக்காட்டப்பட்டிருந்தால்,
வகுப்பின் முழு வரையறையையும்
நீங்கள் தெரிந்து
கொள்ள வேண்டிய அவசியமில்லை,
வகுப்பின் அறிவிப்புடன்
நீங்கள் நிர்வகிக்க
முடியும் ஒரு முன்னோக்கி
அறிவிப்பு, இது தற்காலிகமானது
என்று கூறுகிறது
வெவ்வேறு வகைகள்
மற்றும் பலவற்றை
வகுக்கவும்.

Hindi: 
g, g इन टर्न कॉल h, h कुछ
करता है। ये बुनियादी
संरचना हैं। अंतर
जो हम कर रहे हैं,
जब मुख्य कॉल f होता
है, तो इसे एक कोशिश
ब्लॉक(block) के भीतर
रखा जाता है और एक
संबद्ध पकड़ होती
है।
जब f कॉल g इसे एक कोशिश
ब्लॉक(block) में रखता
है, में कई संबद्ध
कैच ब्लॉक(block) हैं।
जब जी कॉल एच इसे एक
कोशिश ब्लॉक(block) में
रखता है तो कई संबद्ध
कैच धारा(clause) होते
हैं और एच कार्य करता
है, यह स्थिति है।

English: 
of my class it will start looking here it
will go throw the catch clauses, finally it
matches at this point it throws again goes
through this, this none of them match my class
so it thrown again, so it comes back to the
try block in main goes to this catch clause
where it matches again and you throw and you
are saying that something unknown as happened.
This is how the exceptions will get propagated
from a deep function to the outer called function.
And there are some interesting things that
you can note for example, suppose I did not
have this catch clause. And say I have thrown
my exception then what will happen, this does
not match, this does not match. Now there
is no other catch clause left so it falls

Telugu: 
త్రో (throw) వంటిది చాలా
సులభం. కాబట్టి మీరు
బయటకు వెళ్లి g కు
తిరిగి వెళ్లాలనుకుంటున్నారా.
ఇప్పుడు మీరు g లో
తిరిగి ఎందుకు వెళ్ళాలి?
G యొక్క కాల్ ప్రయత్నించండి
బ్లాక్ ఎర్రర్(error)
కాపాడిన, కాబట్టి
ఇది తిరిగి వెళ్లదు.
మీరు నియంత్రిస్తున్నట్లుగా
మీరు నియంత్రించే
క్యాచ్(catch) నిబంధనల
జాబితాకు వెళుతుంది.
మరియు విసిరివేత
ఒకటి, ఇది ఒక పూర్ణాంకం.
ఇప్పుడు మీరు ఏమి
జరుగుతుందో అక్కడ
చాలా ఆసక్తికరమైన
విషయం ఏమిటంటే, ఈ
ఆబ్జెక్ట్ (object) చేస్తారు,
ఆబ్జెక్ట్ను ఒకదానిని
మరియు క్యాచ్ ఉప
నిబంధనల జాబితాలో
వెళ్లి మ్యాచ్ చేయడానికి
ప్రయత్నిస్తుంది.
ఒక మ్యాచ్ కనుగొంటే,
అది వెంటనే ఆపి అక్కడ
సంబంధిత హ్యాండ్లర్ను
అమలు చేస్తుంది.
ఒక మ్యాచ్ కనుగొనకపోతే
అది మరింత ముందుకు
సాగుతుంది. కాబట్టి
ఒక విసిరివేత ఉంటే
అది ఏమి జరుగుతుంది
ఒక పూర్ణాంకానికి
ఆబ్జెక్ట్ (object), కాబట్టి
క్యాచ్ అది ఒక పూర్ణాంకం
ఆశించే ఎందుకంటే
అది సరిపోతుంది ఒక
పూర్ణాంకానికి మరియు
అది ఈ Cout Int అమలు చేస్తుంది.
ఇది కేవలం ఒక హ్యాండ్లర్
ఉంటే అది ఉంటే అది
చెప్పబడుతోంది. ఇది
జరుగుతుంది ఒకసారి,
నియంత్రణ మిగిలిన
క్యాచ్ ఉపవాక్యాలు

Hindi: 
यदि हम किसी भी g, f,
या मुख्य में से देखते
हैं, तो हम देखते हैं
कि वे फ़ंक्शन(function)
को कॉल ब्लॉक(block) में
होने की उम्मीद कर
रहे हैं या यह कहते
हुए कि यह फ़ंक्शन(function)
विफल हो सकता है और
यदि यह विफल होता
है तो यह कुछ फेंक
देगा और जो भी इसे
फेंकता है, मैं उसे
पकड़ लूंगा संबंधित
पकड़ धारा(clause)।
अब देखते हैं कि यह
इतने सारे क्लॉस
क्यों हैं और इसके

Tamil: 
.
இது அடிப்படை வகுப்பு
வார்ப்புரு. அடுத்து
நாம் எதையாவது
காட்டுகிறோம், இது
உங்கள் முழுமையைப்
பற்றிய புரிதலுக்காக
மட்டுமே, நான் ஆழமாகப்
பெற மாட்டேன். இது
செயல்பாட்டு வார்ப்புருவின்
அடிப்படையில் உள்ளது
என்பதைக் காண்பிப்பதற்காகவே,
அதிகபட்ச
செயல்பாட்டில் ஒரு
வகை அளவுரு டி இருந்தால்
மற்றும் கரி நட்சத்திரத்திற்கு
நாங்கள் வேறுபட்ட
நடத்தையை விரும்பினோம்,
எனவே அவர் அதை நிபுணத்துவம்
பெற்றார் மற்றும்
டி ஐ மாற்றி கரி நட்சத்திரத்தை
வைத்து ஒரு வேறு
ஒன்று; அதற்கான செயல்பாட்டு
வரையறை. இது வகுப்பிற்கும்
சாத்தியமாகும், மேலும்
ஒன்றுக்கு மேற்பட்ட
அளவுருக்கள் இருந்தால்,
அந்த அளவுருக்களை
ஓரளவு நிபுணத்துவம்
பெற முடியும் என்பது
உண்மையில் சாத்தியம்
என்பதைக் காட்டுகிறேன்,
அதனால்தான் நான்
இங்கே விளக்க முயற்சிக்கிறேன்.
எனவே, இங்குள்ள மாணவர்
வகுப்பு T1 மற்றும்
T2 என இரண்டு வகைகளால்
வடிவமைக்கப்பட்ட
வார்ப்புரு உள்ளது. டி

English: 
here, now the default behaviour of the exception
mechanism is if a caller has received an exception
which it has not been able to handle because
there was no catch clause, it by default will
re throw it, and it will by default will re
throw the same exception. So even without
this we will get the same behaviour that it
will go back and go to that my exception.
Now, if that is a case then why do we really
have re throw, the reason we have re throw
is in many cases I may have some catch condition
and I may first want to handle something which
I am capable off, and then I may want that
my caller should also know it. So I may want

Tamil: 
1 என்பது ஒரு வகை ரோல்,
டி 2 என்பது பெயர்
வகை. எனவே ஒரு பாத்திரம்
ஒரு முழு எண்ணாக
இருக்கக்கூடும்,
அது ஒரு சரம் மற்றும்
பலவாக இருக்கலாம். பெயர்
சி
++ இல் ஒரு சரம் வகையாக
இருக்கலாம் அல்லது
அது ஒரு கரி நட்சத்திரம்,
சி சரம் வகை மற்றும்
பலவாக இருக்கலாம். இவை
நம்மிடம் இருக்கும்
இரண்டு வெவ்வேறு
வகைகள். எனவே, நீங்கள்
என்ன செய்கிறீர்கள்
என்பது அடிப்படையில்,
நான் அதிக செயல்பாடு
கொடுக்கவில்லை, நீங்கள்
ஒரு கட்டுமானத்தைச்
செய்கிறீர்கள், இந்த
இரண்டு புலங்களையும்
அச்சிடக்கூடிய ஒரு
அச்சு உள்ளது, எனவே
எடுத்துக்காட்டுக்கு.
இப்போது, ​​சுவாரஸ்யமான
விஷயம் என்னவென்றால்,
அடுத்தது என்னவென்றால்,
இதை நாம் உண்மையில்
ஓரளவு நிபுணத்துவம்
செய்கிறோம்? T1 மற்றும்
T2 ஆகிய இரண்டு அளவுருக்கள்
உள்ளன, இதை நான் ஓரளவு
நிபுணத்துவம் பெற்றிருக்கிறேன்,
T1 என்ற அளவுருவைக்
கொண்ட ஒரு வார்ப்புருவை
நான் தொடர்ந்து வைத்திருக்கிறேன்,

Hindi: 
साथ क्या होता है।
मान लीजिए कि मैंने
उन सभी के बारे में
यहाँ टिप्पणी की
है, क्योंकि निश्चित
रूप से अगर एक फंक्शन
होता है, तो चला जाता
है। मान लीजिए कि
यह टिप्पणी नहीं
की गई है, तो क्या
होता है यह कुछ कर
रहा है एक त्रुटि
भर में आता है और यह
एक फेंकता है। यदि
यह एक फेंकता है तो
इसका क्या मतलब है?
एक क्या है? मूल रूप
से यह एक तरह की वस्तु

Telugu: 
మరియు కొన్ని ఇక్కడ
జంప్ మరియు కొనసాగుతుంది.
ఇప్పుడు, g ఏది చేయాలో;
ఇప్పుడు మొత్తం విషయం
ఇప్పటికే జరిగింది,
ఎర్రర్(error) జరిగింది,
అది నివేదించబడింది,
ఇది ఇక్కడ కనుగొనబడింది,
ఇది ఇక్కడ నిర్వహించబడుతోంది,
మీరు స్వాధీనం మరియు
మీరు ఈ భాగం కొనసాగుతున్నాయి.
మాకు ప్రతి సందర్భంలో
h, g, f main లో ముఖ్యమైనది
అని స్టాక్ డ్రా
చెప్పండి ఉంటే మాకు
ఏమి చూద్దాం. ఇప్పుడు
మనము ఏదో జరిగితే
అది ఎక్కడ ఉన్నామో
చెప్పండి మరియు ఇది
ఒక పాయింట్ చేరుకుంటుంది,
అది 2.5, విసురుతాడు,
అది వేరొకదానితో

English: 
to handle some and then again throw it because
if I just handle it like I did here then the
system understands that the exception is taken
care of and it will proceed right here and
it will not go to the caller it will not throw.
But if I handle and then throw again, then
it will take that a fresh exception has happened
from the function g and we will go to its
caller f. So this is the basic mechanism of
exception that happens.
Now let me also show you what happens in terms
of the stack, say main, f, g, h, let us say
my exception has happened. Now it throws which
means that the control has to come out of

Tamil: 
ஆனால் T2 வெளிப்படையாக
கரி நட்சத்திரமாக
வைத்துள்ளது, பின்னர்
நான் பயன்படுத்தினேன். T2
ஐப் பொறுத்தவரை,
நான் அந்த கரி நட்சத்திரத்தை
வெளிப்படையாக வைத்துள்ள
கரி நட்சத்திரத்தைப்
பயன்படுத்துகிறேன். எனவே
இது வார்ப்புருவின்
பகுதி உடனடி நிறுவலாக
மாறுகிறது. முன்னதாக
மாணவர்
வகுப்பின் இந்த வார்ப்புருவுக்கு
T1 மற்றும் T2 ஐக் குறிப்பிட
இரண்டு வகைகள் தேவைப்பட்டன,
இதற்கு ஒரு வகை மட்டுமே
குறிப்பிடப்பட வேண்டும்,
இது T1, மற்றொன்று
ஏற்கனவே சிறப்பு. ஒரு
டெம்ப்ளேட் வரையறையில்,
நீங்கள் அனைத்து
வகை அளவுருக்களுக்கும்
நிபுணத்துவம் பெற்றிருக்கும்போது,
​​வார்ப்புரு முழுமையாக
சிறப்பு வாய்ந்தது
என்று நீங்கள் கூறுகிறீர்கள்,
இல்லையெனில் இது
ஓரளவு சிறப்பு வாய்ந்தது
என்று கூறுகிறீர்கள்.
இதனுடன்
சில வகுப்பு நிகழ்வுகளைப்
பார்த்தால், இது
போன்ற ஒரு நிகழ்வை
சரத்தில் உருவாக்கியுள்ளோம்
என்று வைத்துக்கொள்வோம்,
இயற்கையாகவே இது
இரண்டையும் குறிப்பிடுகிறது. எனவே
இந்த
வார்ப்புருவைப்
பற்றி T1 எண்ணாகவும்
T2 சரமாகவும் இருக்க
முயற்சிக்கிறது. வெளியீட்டிலிருந்து

Telugu: 
జరిగిందని చూపించడానికి.
ఇప్పుడు 2.5 ఏమిటి?
2.5 మాకు తెలిసిన డబుల్
సమయం ఆబ్జెక్ట్ (object).
అది విసిరినప్పుడు
నియంత్రణ g కి తిరిగి
వస్తుంది. అది ఎక్కడ
తిరిగి వస్తోంది?
ఇది తిరిగి రాదు;
ఏదో విసిరినందున
అది క్యాచ్ నిబంధన
ప్రారంభంలోకి వస్తుంది.
మరియు మీరు ఒక డబుల్
ఆబ్జెక్ట్( object) ను
సరిపోలుతుండగా అది
పూర్ణాంకానికి సరిపోలడానికి
ప్రయత్నిస్తుంది.
అది విఫలమౌతుంది,
అది సరిపోలలేవు.
క్యాచ్ నిబంధన అవ్యక్త
మార్పిడి ద్వారా
సరిపోలలేదు. మేము
ఈ మ్యాచ్ వ్యూహం
పరిశీలిస్తే ఈ ఓవర్లోడ్
సరిపోలే వంటి చాలా
చక్కని కనిపిస్తుంది.
కాబట్టి ఒక పరామితితో
ఒక పారామితితో ఒక
ఫంక్షన్ కాల్ చేస్తున్నట్లుగా
మీరు త్రోగా(throw) భావిస్తారు.
మరియు ఇక్కడ అనేక
విధులు ఉన్నాయి,

Hindi: 
फेंक रहा है। यदि
यह फेंकता है तो नियंत्रण
चला जाता है, यदि हम
कॉल स्टैक(stack) में
देखते हैं तो हमारे
पास क्या है हमारे
पास मुख्य है, मुख्य
ने एफ कहा है, एफ ने
जी कहा है, जी ने एच
कहा है। यह वह जगह
है जहां हम वर्तमान
में हैं।
अब यदि आप फेंकते
हैं, तो यह पता चला
है कि यह आगे नहीं
बढ़ सकता है, इसलिए
फेंक बहुत पसंद है
जैसे कि आप नियंत्रण

English: 
this function g, t comes out of it. So if
it comes out of that which means that the
stack frame which was associated with this
function g will have to be removed. When this
as to be removed what happens to this local
object, this local object is been created.
So, what exception does is normally what would
have happened is at the normal exist point
which is here the destructor of this function
that is a colon tilde my class would have
got invoked.
Now, you are existing from this point, now
you are coming out from this point because
you have done a throw. But even at this point
the destructor of this local object will get
called. So all this destructors of all object
which are live at this point then destructors
will get called. And only after that the stack
frame will be squashed and the control will
go back to g.

Telugu: 
ఇక్కడ మూడు విధులు
ఇది ఒక Int xa డబుల్ తీసుకుని
కొన్ని డాట్( dot)పడుతుంది
మరియు మీరు నిర్దిష్ట
ఫంక్షన్ పరిష్కరించడానికి
ప్రయత్నిస్తున్నారు,
ఇది ప్రత్యేక క్యాచ్
నిబంధన పరిష్కరించబడుతుంది
ఇది. కానీ ఓవర్లోడ్
రిజల్యూషన్( resolution)నుండి
రెండు ప్రధాన వ్యత్యాసాలు
ఉన్నాయి; ఒక ఓవర్లోడ్
స్పష్టత అవ్యక్త
మార్పిడి కోసం మిమ్మల్ని
అనుమతిస్తుంది. ఉదాహరణకు
డబుల్ తో కత్తిరించబడి
ఉంటుంది మరియు ఎర్రర్(error)
మరియు అందువలన న
సరిపోలిన ఉంటుంది.
క్యాచ్ నిబంధనపై
నిర్ణయం తీసుకోవడానికి
ఇది అనుమతి లేదు.
రెండింటిలో ఓవర్లోడ్
స్పష్టత మొత్తం విధులు
మొత్తం మీద జరుగుతుంది.
ఇక్కడ ఈ క్రమంలో
జరుగుతుంది. మరియు
మీరు ఒక మ్యాచ్ను

English: 
Now if we have thrown my exception then certainly
it does not match here, does not match here,
it matches here, and it re throws. So the
control goes back from g to f which means
that the stack frame of g will also have to
be on minded and that will be done at this
point, that will be done at this point, and
this local object of g will get destroyed.
So the basic advantage of exception base flow
is that it not only takes care of your automatically
going up in the stack based on the call sequence
and the try blocks and matches the corresponding
catch clause in the try block. Whenever it
goes out of a function because the function
has thrown it destroys all the local objects
that were present.

Hindi: 
प्रवाह के संदर्भ
में चाहते हैं जो
आप इस फ़ंक्शन(function)
से बाहर जाने की कोशिश
कर रहे हैं। इसलिए
आप बाहर जाना चाहते
हैं और जी में वापस
जाना चाहते हैं।
अब आप जी में वापस
क्यों जाते हैं? G
में h की कॉल को कोशिश
ब्लॉक(block) के भीतर
पहरा दिया जाता है,
इसलिए यह इस बिंदु
पर वापस नहीं जाता
है। इसके बजाय जब
आप नियंत्रण फेंकते
हैं तो आपके पास मौजूद
क्लॉस की सूची में
चला जाता है। और जो

Tamil: 
நீங்கள் எளிதாக உருவாக்க
முடியும், நீங்கள்
S1 புள்ளியை செய்துள்ளீர்கள்; S1
என்பது இந்த டெம்ப்ளேட்
பதிப்பிற்காக உருவாக்கப்பட்ட
ஒரு பொருளாகும்,
மேலும் S1 டாட் பிரிண்ட்
செய்கிறோம், அது
பதிப்பு ஒன்றைத்
தேர்வுசெய்கிறது.
இரண்டாவதாக, நாம்
என்ன பயன்படுத்தினோம்? இரண்டாவதாக,
நாங்கள் சுவாரஸ்யமான
ஒன்றைப் பயன்படுத்தினோம். இரண்டாவதாக
நீங்கள்
என்ன சொல்கிறீர்கள்
என்றால், இதை கவனமாக
பாருங்கள், இதில்
நாம் T1 ஐ எண்ணாக சமமாகவோ
அல்லது T2 சரத்திற்கு
சமமாகவோ குறிப்பிட்டுள்ளோம். செயல்பாடுகளின்
அடிப்படையில், மதிப்புகளின்
செயல்பாடுகளின்
இயல்புநிலை அளவுருக்களைக்
கொண்டிருக்கலாம்
என்பதை நினைவில்
கொள்ளுங்கள், 5 உடன்
துவக்கப்படுவதற்கு
சமமாக int x ஐ எழுதலாம்,
எனவே நான் அந்த அளவுருவை
அனுப்பவில்லை என்றால்
அது 5 ஆக எடுக்கப்படும்.
இதேபோல், நீங்கள்
இயல்புநிலையாக இருக்க
முடியும் வகை அளவுருக்கள். எனவே
இதை நான் குறிப்பிடவில்லை
என்றால் அது அந்த
வகையாக எடுக்கப்படும். நான்
சரம்
மாணவர் எண்ணாகச்
சொல்கிறேன் என்றால்,
நான் மாணவர் எண்ணாகச்
சொன்னால், இதை நான்
எடுத்துக்கொள்கிறேன்
என்று அர்த்தம். முன்னிருப்பாக
சரம் என்று
எடுக்கப்பட்ட T2 ஐ
நான் குறிப்பிடவில்லை. எனவே
இது முன்னிருப்பாக
சரம் ஆக எடுக்கப்படுகிறது.
என்னால்
இதைச் செய்ய முடியும்,
இது மீண்டும் இதை
குறிக்கும், இங்கு
எடுக்கப்பட்ட இயல்புநிலை
அளவுருக்கள் இரண்டும். இயல்புநிலை
T1 எண்ணாக உள்ளது,
இயல்புநிலை T2 முழு
எண்ணாக உள்ளது. நான்
ஒரு மாணவர் சரம்
செய்ய முடியும்,
பின்னர் நான் மாணவர்
சரம் செய்கிறேன்,
அதாவது நான் T1 ஐ சரமாக
இருக்கச் செய்தேன்,

English: 
At any point of time, if you have a thrown
from here it has been passed on throw this
and now you are you are working on f you know
that for g and h the two functions that have
thrown all local objects have been properly
cleaned up. The stack has been as it is called
this process of this process of removing destroying
the local objects automatic objects and removing
the stack frames as you throw objects from
one function to its parent is known as stack
unwinding the stack is collapsing and till
you get to the function where you are supposed
to continue. This is the basic exception mechanism
which is based on the try block.
Certainly, let me also mentioned another point
let say suppose this was there and let say

Hindi: 
फेंका गया है वह एक
है, जो एक इंट(int) है।
अब एक बार जब आप वहां
पहुंच जाते हैं तो
कुछ ऐसा होता है जो
बहुत ही रोचक होता
है, यह इस वस्तु को
ले जाता है, वस्तु
एक और पकड़ की इस सूची
पर चला जाता है और
मिलान करने की कोशिश
करता है। यदि यह एक
मैच पाता है तो यह
तुरंत वहीं रुक जाता

Tamil: 
T2 இயல்புநிலையாகும்,
இது சரம் ஆகும். நீங்கள்
உருவாக்கும் வெளியீட்டை
நான் காட்டியுள்ளதை
நீங்கள் காணலாம். இறுதியில்,
நாங்கள்
இங்கே என்ன செய்தோம்
என்று நான் சொன்னால்? இரண்டாவது
அளவுரு ஓரளவு
சார் நட்சத்திரத்திற்கு
சிறப்பு வாய்ந்தது
என்று நாங்கள் கூறினோம். எனவே
நான் int char star ஐ வைத்தால்,
இந்த வார்ப்புருவை
அர்த்தப்படுத்துவதில்லை,
ஏனெனில் இரண்டாவது
அளவுரு ஓரளவு சிறப்பு
பெற்றது, எனவே நான்
இதைச் சொன்னால் இந்த
வார்ப்புரு என்று
பொருள், நாங்கள்
S5 ஐ அச்சிடும்போது
S5 க்கு அச்சிடுவதை
நீங்கள் காணலாம்
பதிப்பு இரண்டு அச்சிடப்பட்டிருப்பதைக்
காணலாம், இது நீங்கள்
பகுதி சிறப்பு வார்ப்புரு
பதிப்பைப் பயன்படுத்துகிறீர்கள்
என்பதைக் காட்டுகிறது. இந்த
வகையான விஷயங்களைச்
செய்ய முடியும் என்பதைக்
காண்பிப்பதற்காகவே
நீங்கள் பல அளவுருக்களைக்
கொண்டிருக்கலாம்
மற்றும் நீங்கள்
ஒன்றிலிருந்து மற்றொன்றுக்குச்
செல்லும்போது அவற்றை
ஓரளவு நிபுணத்துவம்
செய்யலாம், மேலும்
இயல்புநிலை அளவுருக்களையும்
நீங்கள் கொண்டிருக்கலாம்.
.
இறுதியாக,
நான் முடிவுக்கு
வருவதற்கு முன்பு,
வர்க்க பரம்பரை கொண்ட
வார்ப்புருவைப்
பயன்படுத்துவதற்கான
ஒரு எடுத்துக்காட்டைக்
காண்பிக்கிறேன்,
எனவே இது ஒரு எல்லைக்குட்பட்ட
தொகுப்பு வகையான
தரவு கட்டமைப்பை
உருவாக்க முயற்சிக்கிறது. ஒரு
பட்டியல்
உள்ளது, பட்டியலைப்
பற்றி குறிப்பாக
சுவாரஸ்யமானது எதுவுமில்லை,
இது புட் எனப்படும்
கூடுதல் செயல்பாட்டைக்
கொண்ட ஒரு பட்டியல்,
ஒரு நீளச் செயல்பாட்டைக்
கொண்டுள்ளது, ஒரு
குறிப்பிட்ட உறுப்பைக்
கண்டுபிடிக்க ஒரு
கண்டுபிடிப்பு செயல்பாட்டைக்
கொண்டுள்ளது, உறுப்புகளை
வைத்திருக்க வெக்டரை
உள்நாட்டில் பயன்படுத்துகிறது. எனவே
இது ஒரு
துணை தரவு கட்டமைப்பு.
.
இந்த பட்டியலைப்
பயன்படுத்தி
ஒரு தொகுப்பை வரையறுக்கிறீர்கள். ஒரு
தொகுப்பில் ஒரு வகுப்பு
டி உருப்படிகளின்
பட்டியல் உள்ளது.
இது ஒரு மெய்நிகர்
செயல்பாட்டைக்
கொண்டுள்ளது, இது
உறுப்புகளை நீளத்தைக்
கண்டறியும். எனவே
அடிப்படையில் என்ன
செய்வீர்கள் என்றால்,
நீங்கள் ஒரு உறுப்பைச்
சேர்த்தால் அது பட்டியலுக்குச்
சென்று அது உருப்படிகளுக்குச்
சென்று ஒரு புட்
செய்யும். நீங்கள்
இதை விரும்பினால்,
நீங்கள் இங்கே ஒரு
புட் செய்வீர்கள்,
நான் நினைக்கிறேன்,
நான் எதையும் தவறவிட்டேனா? இல்லை. இது
இதைச் செய்யும்,
நீங்கள் ஒரு தொகுப்பில்
சேர்க்க
விரும்பினால்
உண்மையில் சேர்க்கவும்,
இப்போது இது ஒரு
தொகுப்பு, இது சுவாரஸ்யமானது,
இது ஒரு தொகுப்பு
எனவே ஒவ்வொரு உறுப்பு
தனித்துவமாக இருக்க
வேண்டும், தொகுப்பு
தனித்துவத்தைக்
கொண்டுள்ளது.
நான் அதைச் செய்வதற்கான
வழி என்னவென்றால்,
இந்த பட்டியலில்
உள்ள
மதிப்பை நான் முதலில்
எடுத்துக்கொள்கிறேன்,

Telugu: 
కనుగొన్న వెంటనే,
మీరు మంచి పోటీని
కలిగి ఉన్నట్లయితే,
మీరు అక్కడ కనిపించకుండా
ఉండడానికి ప్రయత్నించి,
క్యాచ్ క్లాజ్ను(catch
clause) కాల్ చేస్తారు.
కాబట్టి ఇక్కడ ఏం
జరుగుతుంది? వారు
డబుల్ ఆబ్జెక్ట్
(double object) కలిగి ఉన్నారు;
ఇది సరిపోలలేదు,
కానీ ఇది సరిపోతుంది.
ఇప్పుడు, ఇది డబుల్
ముద్రిస్తుంది మరియు
అది తిరిగి ఇక్కడ
ఒక మాదిరి విషయం
ఉంది.
దీనిపై కొనసాగుదాం
మరియు తరువాతి ఏమి
జరుగుతుందో చూద్దాం.
ప్రధాన, f, g, h, దీనిని
చెక్ చేద్దాం. ఇక్కడ
నా ఎక్స్సెప్షన్స్(exceptions)
ఏమిటంటే, ప్రామాణిక
లైబ్రరీ ఎక్స్సెప్షన్స్(exceptions)
ఉంది, ఇది C ++ లో జరిగే
అన్ని రకాల ఎక్స్సెప్షన్స్లను
(exceptions) లను జాగ్రత్త
తీసుకునే ఎక్స్సెప్షన్స్(exceptions)

Tamil: 
இந்த உறுப்பு இந்த
பட்டியலுக்கு சொந்தமானதா
என நான் கண்டறிந்தேன்,
இது ஏற்கனவே தொகுப்பில்
உள்ளது, எனவே நீங்கள்
திரும்பும் எதையும்
செய்ய வேண்டாம். நான்
சொந்தமில்லை என்றால்,
கட்டுப்பாடு இங்கே
வருகிறது, பின்னர்
நீங்கள் அதை
பட்டியலில் சேர்க்கவும்,
அதனால் இதுதான். பட்டியல்
நீளத்தின் நீளம்
வெறுமனே ஒரு ராப்பராகும்,
அதில் ஒரு ராப்பரைக்
கண்டறியவும். எந்தவொரு
உறுப்பு வகைக்கும்
இது ஒரு வகை அமைப்பை
வழங்குகிறது.
.
இப்போது, ​​நான்
ஒரு
எல்லைக்குட்பட்ட
தொகுப்பை விரும்புகிறேன்
என்று வைத்துக்கொள்வோம். இங்கே
பெயரால் கட்டுப்படுத்தப்பட்ட
தொகுப்பு,
இது இரண்டு வரம்புகளைக்
கொண்ட ஒரு தொகுப்பு; உறுப்புகள்
அந்த வரம்பிற்குள்
இருக்க வேண்டும்,
அங்கு ஒரு வரையறுக்கப்பட்ட
தொகுப்பு நிமிடம்
மற்றும் அதிகபட்ச
மதிப்புகளுக்குள்
இருக்கும் உறுப்பினர்களை
மட்டுமே கொண்டிருக்க
முடியும். எனவே இது
தொகுப்பிலிருந்து
ஒரு சிறப்பு. நீங்கள்
சிறப்பு எவ்வாறு
எழுதுகிறீர்கள்
என்பதை இது காணலாம். பிணைக்கப்பட்ட
தொகுப்பும் வார்ப்புருவாக்கம்
செய்யப்படுகிறது,
ஏனெனில் இது ஒரு
உறுப்பு வகையாக
இருக்கும் ஒரு டெம்ப்ளேட்
அளவுருவைக் கொண்டுள்ளது,
ஆனால் இது
டி தொகுப்பிலிருந்து
நிபுணத்துவம் பெற்றது.
பின்னர் பிணைக்கப்பட்ட
தொகுப்பு, அதற்கு
ஒரு கட்டமைப்பாளரைக்
கொண்டுள்ளது, அதற்கு
ஒரு சேர்க்கை உள்ளது. மேலும்,
நீங்கள் சேர்க்க
முயற்சிக்கும்போது
வெறுமனே செய்வது
என்னவென்றால், அது
ஏற்கனவே இருந்தால்,
அது திரும்பும்,
இது தொகுப்பின் நடத்தை.
ஆனால், மதிப்பு
நிமிடம் மற்றும்
அதிகபட்சமாக இருந்தால்,
அது அடிப்படை வகுப்பு
பொருளாக இருக்கும்
பெற்றோர் செட் வகுப்பு
பொருளுக்குச் சென்று
அதைச்
சேர்க்கும். ஆனால்
அது இல்லையென்றால்
அது ஒன்றும் செய்யாது,
இது இங்கே ஒரு விதிவிலக்கு
மூலம் உங்களைப் புறக்கணிக்கும்
மற்றும் வேறு சில
நடத்தைகளையும் செய்யும். ஆனால்
நான் இப்போது காட்ட
முயற்சிக்கிறேன்,
இது எனக்கு ஒரு கட்டுப்பட்ட
தொகுப்பு உள்ளது,
இது தொகுப்பின் சிறப்பு,
இது வார்ப்புரு,
இதுவும் வார்ப்புருவாக்கம்
செய்யப்பட்டுள்ளது,
மேலும் இது ஒரு பகுதியைக்
கொண்டுள்ளது, ஏனெனில்
ஒரு அங்கமாக ஒரு
பட்டியல் உள்ளது,
அதில் ஒரு பகுதியாக
உள்ளது ஒரு திசையன்
உள்ளது. இவை அனைத்தும்
தற்காலிகமாக வடிவமைக்கப்பட்டுள்ளன,
இறுதியாக இந்த வகைப்படுத்தப்பட்ட
வகுப்புகள் அனைத்தையும்
பயன்படுத்தி இந்த
வகைப்படுத்தப்பட்ட
வகுப்பில் மரபுரிமையைப்
பயன்படுத்துகின்ற
எந்தவொரு வகையிலும்
நான் ஒரு கட்டுப்படுத்தப்பட்ட
தொகுப்பைப் பெறுகிறேன். எனவே,
வார்ப்புருக்கள்
பரம்பரை அம்சத்துடன்
கலக்கப்படுவது இதுதான்.
.
இது ஒரு இறுதி பிணைப்பு
தொகுப்பு பயன்பாடாகும்,
நீங்கள் விண்ணப்பத்தை

English: 
in a function g instead of this you have just
written g. Suppose you have called a function
which is not within the try block and then
this my exception has been raised. If my exception
as been raised does not match here, does not
match here, from this re throw will happen,
so my exception happens here. After this g
may be there is some other statement.
Now what happens is if you this is not within
the try block also, then if you get an exception
in g then once the control returns because
of that exception you do not continue at the
next statement, you immediately re throw and
raise the same exception object to the parent.
These are default mechanism. This default
mechanism is important because if you forget

Telugu: 
ముందే నిర్వచించబడినది.
ఎక్స్సెప్షన్స్(exceptions)
తరగతికి ప్రత్యేకమైన
తరగతిని నేను నిర్వచించాను,
కాబట్టి నా ఎక్స్సెప్షన్స్(exceptions)
యొక్క ఒక వస్తువును
కొందరు విసిరేవారు.
మళ్ళీ ఏమి జరుగుతుంది?
నియంత్రణ g కి వచ్చినప్పుడు
అది ప్రారంభమవటానికి
పూర్తయినప్పుడు
ప్రారంభమవుతుంది,
ఇది నా ఎక్స్సెప్షన్స్(exceptions)
ఆబ్జెక్ట్ ను (object)
కలిగి ఉండదు, డబుల్
సరిపోలడంతో క్యాచ్తో
సరిపోలడానికి ప్రయత్నిస్తుంది,
అప్పుడు ఇక్కడ సరిపోలడానికి
ప్రయత్నిస్తుంది,
ఇది ఏమిటి? ఇది ఎలిప్సిస్(
ellipses) అంటారు.
Ellipses వారు ఏదైనా మ్యాచ్
కోరుకుంటున్నాము
మూడు చుక్కలు ఉన్నాయి.
మీకు ఏది సరిపోతుందో
అది సరిపోతుంది.
కాబట్టి, ఎలిప్సిస్
డబుల్ తో మ్యాచ్
ఉంటుంది, ఇది నా ఎక్స్సెప్షన్స్(exceptions)
తో సరిపోలడంతో, అది

Hindi: 
है और संबंधित हैंडलर
को निष्पादित करता
है। यदि यह एक मैच
नहीं पाता है तो यह
आगे बढ़ता है। यदि
किसी को फेंक दिया
गया है तो यह एक अंतर
ऑब्जेक्ट(object) है, तो
क्या होता है, इसलिए
कैच एक इंट(int) से उम्मीद
कर रहा है क्योंकि
यह एक इंट(int) से उम्मीद
कर रहा है कि यह मेल
खाता है और यह इस कॉट
इंट(int) को अंजाम देगा।
यह सिर्फ इतना कह

Hindi: 
रहा है कि जैसे कि
यह एक हैंडलर है।
एक बार जब यह किया
जाता है, तो नियंत्रण
शेष पकड़ खंड को कूद
जाएगा और यहां कुछ
और जारी रहेगा। अब,
जो जी को करना है;
अब पूरी बात पहले
ही हो चुकी है, त्रुटि
हो गई थी, यह सूचित
किया गया था, यह यहां
पता चला है, इसे यहां
संभाला गया है, आप
पुनर्प्राप्त कर
चुके हैं और आप इस
भाग के लिए आगे बढ़
रहे हैं।

Telugu: 
ఎక్స్సెప్షన్స్(exceptions)
తో ఎవరితోనూ సరిపోతుంది,
కాని మునుపటి సందర్భాలు
మేము 1 విసిరినప్పుడు
లేదా మేము 2.5 మరియు
Int మరియు డబుల్ క్యాచ్
ఉపోద్ఘాతాల తర్వాత
2.5 నిమిషాలు అది ఈ
కాలానికి చెందినది
కాదు. కానీ ఇక్కడ
నా ఎక్స్సెప్షన్స్(exceptions)
తో ఈ ఇద్దరూ సరిపోలలేదు,
కనుక ఇది ఇక్కడ జరుగుతుంది
మరియు ఈ సమయంలో మ్యాచ్లు
అన్నింటికీ సరిపోలడంతో
ఇది అన్ని నిబంధనలను
క్యాచ్ అంటారు.
కనుక ఇది నిర్వహించడానికి
వెళుతుంది, మరియు
ఒక హ్యాండిల్ (handle)
ఏమి ఉంది? హ్యాండిల్
అది చాలా సులభం చేస్తుంది
ఇది త్రో చెప్పారు
ఇది ఏమీ చేయబోవడం

English: 
to put try block around some functions calls
which may have some exceptions raised then
you will have a test of a difficulty of not
being able to handle the error, so by default
if you have not raised if you have not put
a function within a try block then you simply
pass it on to a parent, your parent keeps
on doing that.
Finally, if you have some exception in the
main which is not guarded by a try block or
there is a catch clause. Suppose, here I did
not have this catch clause suppose here I
had some catch clause for some other class
and so on. But I did not have a catch or clause
then it is quite possible that an exception
like thrown like my class object will not
be caught at this point because it does not
match here. In that case the main cannot certainly

Tamil: 
பூர்த்தி செய்து
சரிபார்த்து, இந்த
தொகுப்பில் நீங்கள்
சில
எண்களைச் சேர்த்துள்ளீர்கள்
என்பதை இயக்கவும்,
பின்னர் நீங்கள்
பெற எதிர்பார்க்கும்
நான்கு கண்டுபிடிக்க
முயற்சிக்கிறீர்கள். உங்கள்
பட்டியலில் 3 அல்லது
21 க்கு இடையில் இருப்பதால்,
இருக்கக்கூடாது
என்று பட்டியலில்
0 அல்லது 25 போன்ற ஏதாவது
இருக்கிறதா என்று
நீங்கள் சரிபார்க்கிறீர்கள்.
எனவே எதிர்பாராத
மதிப்பு இல்லை என்று
நீங்கள் கூறுகிறீர்கள். உங்கள்
கட்டுப்படுத்தப்பட்ட
தரவு வகை எவ்வாறு
செயல்படும் என்பதற்கான
எடுத்துக்காட்டுடன்
இது காண்பிக்கப்படுகிறது.
.
சுருக்கமாக,
நாங்கள் சி ++ இல்
வார்ப்புருக்களை
அறிமுகப்படுத்தியுள்ளோம்,
வகுப்பு வார்ப்புரு
தரவு கட்டமைப்பிற்கு
பொதுவான தீர்வைக்
கொண்டிருப்பதைப்
பற்றி விவாதித்தோம். செயல்பாட்டு
வார்ப்புருவுடன்
இணைந்து இது பொதுவான
நிரலாக்க, மெட்டா
நிரலாக்கக் குறியீட்டை
எழுத முடியும் என்பதில்
எங்களுக்கு ஒரு பெரிய
நன்மையைத் தருகிறது
மற்றும் நிலையான
வார்ப்புரு நூலகம்
அல்லது சி ++ இன் எஸ்.டி.எல்
என அழைக்கப்படும்
ஒரு அடித்தளத்தை
அளிக்கிறது.

Hindi: 
आइए देखें कि क्या
होता है अगर हम कहें
कि फिर से स्टैक(stack)
बनाएं जो हर मामले
में महत्वपूर्ण होगा
h, g, f main। अब हम कहते
हैं कि यह वह जगह है
जहां कुछ हो रहा था
और यह एक बिंदु पर
पहुंच जाता है जहां
यह 2.5 फेंकता है, बस
यह दिखाने के लिए
कि यह कुछ अलग है।
अब 2.5 क्या है? 2.5 उस
दोहरे समय की एक वस्तु
है जिसे हम जानते
हैं। जैसा कि यह फेंकता
है नियंत्रण जी पर
वापस आता है। यह वापस
कहाँ आता है? यह यहाँ
वापस नहीं आता है;
यह कैच धारा(clause) की
शुरुआत में वापस
आता है, क्योंकि कुछ
फेंक दिया गया है।
और आप मिलान करना
शुरू करते हैं इसमें
एक दोहरी वस्तु है
जो इंट(int) से मेल करने
की कोशिश करती है।
यह विफल हो जाएगा
यह मैच नहीं कर पाएगा।
कैच क्लॉज़ निहित
रूपांतरण से मेल
नहीं खाता है।
अगर हम इस मैच की रणनीति
पर गौर करें तो यह
ओवरलोड मैचिंग की
तरह ही दिखता है।
तो जैसे कि आप सोच
सकते हैं तो फेंक
दिया जाता है जैसे
कि एक फ़ंक्शन(function)
को एक एकल पैरामीटर
के साथ फ़ंक्शन(function)
कर रहा है। और कई कार्य
हैं जैसे कि यहां,
तीन फ़ंक्शन(function)
यहां जो एक इंट(int)
xa डबल लेता है और कुछ
डॉट डॉट डॉट लेता
है और आप यह निर्धारित
करने की कोशिश कर
रहे हैं कि कौन सा

English: 
throw, because it does not have a caller.
So in that case a termination handler will
get called. So, that is a basic mechanism
of exceptions that happen.
What we have done in the next couple of slides,
whatever I have discussed those are documented
here for example with some more details. For
example, a function as a whole may have a
try block. So, all that you do is instead
of putting multiple try block you say that
a function and the
of function header and this is the function
body. So, in between that you write try so
which means that the whole functions is a
part of try. Naturally the try blocks can
be nested within try block you could have
other blocks and so on, but try block must
have a catch block with that.
This is from the earlier example just highlighting
what is that.
Then catch block has a different arguments
that we have seen every catch block will have

Telugu: 
కాదు కానీ H ఫంక్షన్
ఒక నా ఎక్స్సెప్షన్స్(exceptions)
ఆబ్జెక్ట్ (object) విసిరిన
వంటి ఈ కేవలం కాలర్
ఆ ఆబ్జెక్ట్ ను
(object) త్రో చేస్తుంది.
కాబట్టి ఇది తిరిగి
కాల్ చేస్తుంది దాని
కాలర్ పైకి వెళ్తుంది
అది స్టాక్ దాని
కాలర్ డౌన్ వస్తాయి.
కాలర్ f, caller g అని మరియు
మీరు విసిరిన, మీ
అసాధారణ ఆబ్జెక్ట్
(object) ఏమిటి? ఎక్స్సెప్షన్స్(exceptions)
వస్తువు మీరు h, నా
ఎక్స్సెప్షన్స్(exceptions)
నుండి పొందింది ఏమిటిCT.
అందువల్ల మీరు ఒక
ఎక్స్సెప్షన్స్(exceptions)
ద్వారా విసిరివేయబడటం
వలన మీరు క్యాచ్
ఉపవాక్యాలు కొనసాగుతారు.
కాబట్టి, ఇప్పుడు
మీరు నా ఎక్స్సెప్షన్స్(exceptions)
ఆబ్జెక్ట్ (object) కలిగి
ఉంటారు మరియు మీరు
నా ఎక్స్సెప్షన్స్(exceptions)
క్యాచ్ నిబంధనను
కలిగి ఉంటారు, కనుక
నా ఎక్స్సెప్షన్స్(exceptions)
ఇతర క్యాచ్ నిబంధనలపై
దాటవేస్తుంది మరియు
మీరు మిగిలిన F ఫంక్షన్కు
వెళ్లి కొనసాగుతారు.
కాబట్టి, కాలర్ ఎక్స్సెప్షన్స్(exceptions)నిర్వహించగలగడం
కాదు, మీరు కాల్ చేసేవారు
కాల్ చేసే వ్యక్తిని
నిర్వహించగలడు, కాలర్
దానిని నిర్వహించటానికి
అధిక సంఖ్యలో ప్రచారం
చేయవచ్చు మరియు అది
ఒక ఎక్స్సెప్షన్స్(exceptions)
విసిరేటప్పుడు మీరు
ప్రత్యేకంగా ఇక్కడ
ఏమి చేశారు. మనం ముందుకు
వెళ్ళనివ్వండి మరియు
నా ఎక్స్సెప్షన్స్(exceptions)
స్పెషలైజేషన్ అయిన
తరగతి ఎక్స్సెప్షన్స్ను
(exceptions) మినహాయించి
ఉంటే ఏమిటో చూద్దాం.
ఇప్పుడు, ఏమి జరుగుతుందో,
నేను మళ్ళీ ఇక్కడికి
వస్తాను, ఎందుకంటే
ఈ ఇద్దరితో నేను

Telugu: 
త్రోసిపుచ్చలేను,
నేను వస్తాను, నేను
ఇక్కడకు వచ్చి, ఎక్స్సెప్షన్స్కు
(exceptions) అనుగుణంగా,
నేను ఎక్స్సెప్షన్స్ను
(exceptions)చూడగలను. నేను
త్రో( throw), నా క్లాస్స్
(class) కొన్ని ఇతర క్లాస్స్
(class) మరియు నేను నా
క్లాస్స్ (class) ఎక్స్సెప్షన్స్(exceptions)
త్రో( throw) అది ఇక్కడ
చూడటం ప్రారంభమౌతుంది
అది క్యాచ్ ఉపవాక్యాలు
విసిరే వెళ్ళి, చివరకు
అది మళ్ళీ ఈ సమయంలో
వెళుతుంది ఈ సమయంలో
పోతుంది, ఈ, ఎవరూ మ్యాచ్
నా క్లాస్స్ (class) అది
మళ్ళీ విసిరి, కాబట్టి
ఇది ప్రధాన మళ్ళీ
ప్రయత్నించండి బ్లాక్
తిరిగి వస్తుంది
ఈ క్యాచ్ క్లాజ్(catch
clause) వెళుతుంది మళ్లీ
మ్యాచ్ మరియు మీరు
త్రో మరియు మీరు
చెప్తున్నావు తెలియని
ఏదో జరిగింది. ఈ ఎక్స్సెప్షన్స్(exceptions)
బాహ్య ఫంక్షన్ నుండి
బాహ్య పిలువబడిన
ఫంక్షన్ వరకు ప్రచారం
చేయబడతాయి. మరియు
మీరు గమనించవచ్చు
కొన్ని ఆసక్తికరమైన
విషయాలు ఉన్నాయి,
ఉదాహరణకు, నేను ఈ
క్యాచ్ నిబంధన లేదు
అనుకుందాం. మరియు
నేను ఏమి జరిగిందో
అప్పుడు నా ఎక్స్సెప్షన్స్(exceptions)
విసిరినట్లు, ఇది
సరిపోలడం లేదు, ఇది
సరిపోలలేదు. ఇప్పుడు
ఇక్కడ ఏ ఇతర క్యాచ్
క్లాజ్(catch clause) మిగిలి
ఉంది, కాబట్టి ఇక్కడ
ఎక్స్సెప్షన్స్(exceptions)
మెకానిజం( mechanism) యొక్క
డిఫాల్ట్ (default)దేఫౌ
ప్రవర్తన ఉంది, ఒక
కాలర్ ఒక ఎక్స్సెప్షన్స్(exceptions)
అందుకుంది, అది క్యాచ్(catch)
చేయలేకపోయింది, ఎందుకంటే
క్యాచ్ క్లాజ్(catch
clause) లేనందున అది త్రో,
మరియు అది డిఫాల్ట్(default)

English: 
one argument and that has to be unique between
the catch blocks.
So, the arguments here have to be unique.
And there are two interesting things to note
one, is how you should pass this argument,
should you pass it as a value or as a reference.
Usually it is passed as a reference. Particularly
if it is a user defined object type the reason
you would like to pass it as a reference because
then you do not need to copy that exception
object you can just keep on propagating.
And whenever it the handler ends, whenever
the handler terminate if it has not re thrown
whenever the handler terminates it will destroy
that exception object. It is also interesting
that the exceptions object are kind of so
exception objects becomes kind of automatic
objects because they are constructed at the
point when they are thrown or before that
in the function that it is throwing them and

Hindi: 
विशेष फ़ंक्शन(function),
कौन सा विशेष पकड़
क्लॉज़ हल किया जाएगा।
लेकिन अधिभार संकल्प
से दो प्रमुख अंतर
हैं; एक अधिभार संकल्प
आप अंतर्निहित रूपांतरण
के लिए अनुमति देता
है। उदाहरण के लिए
int को डबल के साथ मैच
किया जाएगा डबल ट्रंक
और भीतर और इसी तरह
से मिलान किया जाएगा।
कैच क्लाज पर निर्णय
लेने की अनुमति नहीं
है। दूसरा है अधिभार
संकल्प एक पूरे के
रूप में कार्यों
के सेट पर होता है।
यहाँ यह इस आदेश के
अनुसार होगा। और
जैसे ही आपको एक मैच
मिला, आप यह पता लगाने
की कोशिश नहीं करेंगे
कि क्या कोई बेहतर
मैच है, आप बस वहीं
समाप्त हो जाएंगे
और उस धारा(clause) को
कॉल करेंगे। तो यहां
क्या होगा? उनके पास
एक दोहरी वस्तु है;
यह मैच नहीं होगा,
लेकिन यह मैच होगा।
अब, यह प्रिंट डबल
करेगा और फिर इसे
पुनर्प्राप्त करेगा
यहां जारी है जो कि
एक नमूना है।
आइए हम इसे जारी रखें
और आगे क्या होता
है यह देखने की कोशिश
करें। मुख्य, एफ, जी,
एच, आइए हम इसे जांचते
हैं। यहाँ मेरा अपवाद(exception)
क्या है, एक मानक पुस्तकालय
अपवाद(exception) है जिसमें
एक वर्ग अपवाद(exception)
है जिसे पूर्वनिर्धारित
कहा जाता है जो सभी
विभिन्न प्रकार के
अपवादों का ध्यान
रखता है जो C ++ में
हो सकते हैं। मैंने
एक वर्ग को परिभाषित
किया है, जो अपवाद(exception)
वर्ग की विशेषज्ञता
है, इसलिए कुछ मेरे
अपवाद(exception) की वस्तु
को फेंक रहे हैं।
फिर क्या होता है?
जैसा कि जी पर नियंत्रण
होता है, जो तब शुरू
होता है जब यह इंट(int)
के साथ मैच करने की
कोशिश करता है, मैच
मेरे अपवाद(exception) की
वस्तु नहीं है, डबल
पकड़ने के साथ मैच
करने की कोशिश करता
है मैच नहीं करता
है, फिर यहां मैच करने
की कोशिश करता है,
यह क्या है? इसे एलिप्स
के रूप में जाना जाता
है।
एलिप्स तीन डॉट्स
हैं जिन्हें वे किसी
भी चीज़ के साथ मिलाने
वाले हैं। आपके पास
जो कुछ भी है वह उसी
के साथ मेल खाएगा।
तो, दीर्घवृत्त एक
के साथ मेल खाएगा,
यह डबल के साथ मेल
खाएगा, यह मेरे अपवाद(exception)
के साथ मेल खाएगा,
यह किसी भी अपवाद(exception)
के साथ मेल खाएगा,
लेकिन पहले के मामलों
में जब हमें 1 फेंक
दिया जाता है और हमने
इंट(int) और डबल कैच
धारा(clause) के बाद 2.5
फेंक दिया था, जहां

English: 
they will get destructed in some other function
scope in the catch handler. There is kind
of a very interesting automatic object which
has a lifetime scope which is dependent on
the runtime not necessarily on the compile
time which is typical for all other automatic
objects.
And therefore, the exception objects will
always have to be created in the free store
in the stack not in the stack, but in the,
what you say as a heap. Because you cannot
it in the stack because you do not know for
how long you will need to maintain this object.
So, you do not know whether the stack frame
of a function in which you create that how
long that stack frame will exist. So you will
typically create these objects are created
in the free store.
We have talked about exception matching.
This is just detailed here is to what the
exception that you throw, how that is matched

Hindi: 
इस ईप्स से पहले तब
यह इस बिंदु पर नहीं
आया। लेकिन यहाँ
मेरे अपवाद(exception) के
साथ ये दोनों मेल
नहीं खाते थे इसलिए
यह यहाँ आता है और
इस बिंदु पर मैच होता
है, इसे कैच ऑल क्लॉज़
के रूप में भी जाना
जाता है क्योंकि
यह सब कुछ मेल खाता
है।
तो यह संभाल करने
के लिए चला जाता है,
और एक संभाल क्या
है? हैंडल कुछ बहुत
ही सरलता से कहता
है कि यह फेंक का मतलब
है कि यह कुछ भी करने
वाला नहीं है, लेकिन
जैसे कि एच फ़ंक्शन(function)
ने मेरी अपवाद(exception)
वस्तु को फेंक दिया
है, यह कॉल करने वाले
को उस वस्तु को फिर
से फेंक देगा। तो
इसका मतलब यह है कि
इसे फिर से फेंक दिया
जाएगा यह अपने कॉलर
को वापस ऊपर की ओर
जाएगा यह स्टैक(stack)
इसके कॉलर पर नीचे
आ जाएगा। कॉल करने
वाला f था, कॉलर ने
g को कॉल किया था और
आपने फेंक दिया था,
आपकी अपवाद(exception) वस्तु
क्या है? अपवाद(exception)
वस्तु वह है जो आपने
h से प्राप्त की थी,
मेरा अपवाद(exception) ऑब्जेक्ट(object)।
इसलिए जब से आप एक
अपवाद(exception) के माध्यम
से यहां आए हैं, तो
आप कैच क्लॉस पर जारी
रहेंगे। तो, अब आपके
पास मेरा अपवाद(exception)
ऑब्जेक्ट(object) है और
आपके पास मेरा अपवाद(exception)
कैच क्लॉज़ है, इसलिए
यह कहता है कि मेरा
अपवाद(exception) अन्य कैच
क्लॉज़ पर छोड़ें
और फिर आप शेष फ़ंक्शन(function)
पर जाएं और जारी रखें।
इसलिए, यह जरूरी नहीं
है कि कॉलर उस अपवाद(exception)
को संभालने में सक्षम
होगा जिसे आप फेंकते
हैं, कॉलर को संभाल
सकता है कि, कॉलर इसे
संभालने के लिए कॉल
करने के लिए उच्च
प्रचार कर सकता है
और हम कहते हैं कि
यह एक अपवाद(exception) फेंक
रहा है। आपने यहां
क्या खास किया है।
आइए हम आगे बढ़ें
और देखें कि क्या
होगा अगर मैं उस वर्ग
के अपवाद(exception) को छोड़
दूं जिसमें मेरा
अपवाद(exception) एक विशेषज्ञता
था। अब, क्या होगा,
मैं फिर से यहां आता
हूं, यह इस बिंदु पर
जाता है क्योंकि
ये दोनों मुझे फेंकने
से मेल नहीं खाते
हैं, मैं आता हूं,
मैं यहां आता हूं,
अपवाद(exception) से मेल
खाता हूं, मैं अपवाद(exception)
देख सकता हूं। मान
लीजिए कि मैं फेंकता
हूं, मेरी कक्षा कुछ
अन्य वर्ग है और मैं
अपनी कक्षा के एक
अपवाद(exception) को फेंक
देता हूं, यह यहां
देखना शुरू कर देगा,
यह कैच धारा(clause) को
फेंक देगा, अंत में
यह इस बिंदु से मेल
खाता है यह फिर से
फेंकता है, यह, उनमें
से कोई भी मैच नहीं
होता है मेरी कक्षा
इसलिए इसे फिर से
फेंक दिया गया, इसलिए
यह मुख्य रूप से इस
कैच धारा(clause) में जाता
है जहां यह फिर से
मेल खाता है और आप
फेंक देते हैं और
आप कह रहे हैं कि कुछ
अज्ञात है। यह है
कि अपवादों को एक
गहरे फ़ंक्शन(function)
से बाहरी नामक फ़ंक्शन(function)
तक प्रचारित किया
जाएगा।
और कुछ दिलचस्प चीजें
हैं जिन्हें आप नोट
कर सकते हैं, उदाहरण
के लिए, मान लें कि
मेरे पास यह कैच धारा(clause)
नहीं था। और कहते

Telugu: 
అదే ఎక్స్సెప్షన్స్(exceptions)
త్రో (throw)చేస్తుంది
రెడీ. కాబట్టి ఇది
లేకుండానే మనకు అదే
ప్రవర్తన వస్తుంది,
అది తిరిగి వెళ్లి
నా ఎక్స్సెప్షన్స్(exceptions)
వెళ్తుంది. ఇప్పుడు,
అది కేసు అయితే, ఎందుకు
మేము నిజంగా త్రో
(throw)వచ్చును, మేము
త్రో పుచ్చిన కారణంగా
అనేక సందర్భాల్లో
నేను కొన్ని క్యాచ్
షరతు కలిగి ఉండవచ్చు
మరియు నేను మొదట
సామర్ధ్యం కలిగి
ఉన్నాను, నా కాలర్
కూడా తెలుసు కావాలి.
నేను ఇక్కడ నిర్వహించాను,
అప్పుడు ఎక్స్సెప్షన్స్(exceptions)
సిస్టమ్ ఎక్స్సెప్షన్స్యించబడుతుందని
అర్థం మరియు ఇది
ఇక్కడే కొనసాగుతుంది
మరియు ఇది కాలర్
కు(caller) వెళ్లదు అని
అర్థం కావడం వలన,
నేను దానిని నిర్వహించాలనుకుంటున్నాను,
ఆపై దానిని మళ్ళీ
త్రో (throw) చేయాలనుకోవచ్చు
త్రో. కానీ నేను మళ్ళీ
నిర్వహించాను, ఆపై
మళ్లీ విసిరితే,
అది తాజా ఎక్స్సెప్షన్(exception)ఫంక్షన్
g నుండి జరిగి, దాని
కాలర్ f కి వెళ్తాము.
కాబట్టి ఇది జరిగే
ఎక్స్సెప్షన్(exception)
యొక్క ప్రాథమిక యంత్రాంగం.
ఇప్పుడు, స్టాక్
(stack)యొక్క పరంగా ఏమి
జరిగిందో కూడా చూపించాము,

Telugu: 
ప్రధానంగా చెప్పండి,
f, g, h, మనం నా ఎక్స్సెప్షన్(exception)
చెప్పాము. ఇప్పుడు
ఇది విసురుతాడు అంటే
నియంత్రణ ఈ ఫంక్షన్
నుండి బయటకు రావటానికి,
అది బయటకు వస్తుంది.
కనుక ఇది బయటకు వస్తుంది
అంటే ఈ ఫంక్షన్(function)
గ్రాతో సంబంధం ఉన్న
స్టాక్ ఫ్రేమ్ తొలగించబడాలి.
ఈ స్థానిక ఆబ్జెక్ట్
(object)కు ఏమి జరిగితే
దాన్ని తీసివేసినప్పుడు,
ఈ స్థానిక ఆబ్జెక్ట్
(object) సృష్టించబడింది.
కాబట్టి, ఏమి ఎక్స్సెప్షన్(exception)
సాధారణంగా జరిగిందో
సాధారణ ఉనికిలో ఉంది
ఇక్కడ ఇది ఈ ఫంక్షన్

Hindi: 
हैं कि मैंने अपना
अपवाद(exception) फेंक दिया
है तो क्या होगा, यह
मेल नहीं खाता, यह
मेल नहीं खाता। अब
कोई दूसरा कैच क्लॉज़
नहीं बचा है, इसलिए
यह यहाँ गिरता है,
अब अपवाद(exception) तंत्र
का डिफ़ॉल्ट व्यवहार
है यदि किसी कॉलर
को कोई अपवाद(exception)
मिला है जिसे वह हैंडल
नहीं कर पाया है, क्योंकि
कैच क्लॉज़ नहीं
था, यह डिफ़ॉल्ट रूप
से फिर से शुरू होगा
इसे फेंक दो, और यह
डिफ़ॉल्ट रूप से
उसी अपवाद(exception) को
फिर से फेंक देगा।
तो इसके बिना भी हमें
यही व्यवहार मिलेगा
कि वह वापस जाए और
मेरे अपवाद(exception) पर
जाए।
अब, अगर यह मामला है
तो हम वास्तव में
क्यों फिर से फेंक
देते हैं, जिस कारण
से हम फिर से फेंक
देते हैं, कई मामलों
में मैं कुछ कैच की
स्थिति हो सकती है
और हो सकता है कि मैं
पहले कुछ संभालना
चाहता हूं, जो मैं
सक्षम हूं, और फिर
मैं कर सकता हूं चाहते
हैं कि मेरे फोन करने
वाले को भी पता होना
चाहिए। इसलिए मैं
कुछ को संभालना चाहता
हूं और फिर इसे फिर
से फेंक सकता हूं
क्योंकि अगर मैं
इसे संभालता हूं
जैसे मैंने यहां
किया था, तो सिस्टम
समझता है कि अपवाद(exception)
का ध्यान रखा गया
है और यह यहीं आगे
बढ़ेगा और यह फोन
करने वाले के पास
नहीं जाएगा। फेंकना।
लेकिन अगर मैं संभालता
हूं और फिर से फेंक
देता हूं, तो यह लगेगा
कि फ़ंक्शन(function) जी
से एक नया अपवाद(exception)
हुआ है और हम इसके
कॉलर एफ पर जाएंगे।
तो यह अपवाद(exception) का
मूल तंत्र है जो होता
है।
अब मैं आपको यह भी
दिखाता हूं कि स्टैक(stack)
के संदर्भ में क्या
होता है, मुख्य, एफ,
जी, एच कहते हैं, आइए
हम कहें कि मेरा अपवाद(exception)
हुआ है। अब यह फेंकता
है जिसका मतलब है
कि नियंत्रण को इस
फ़ंक्शन(function) जी से
बाहर आना है, इससे
बाहर आता है। तो अगर
यह उस से बाहर आता
है जिसका मतलब है
कि स्टैक(stack) फ्रेम
जो इस फ़ंक्शन(function)
जी के साथ जुड़ा हुआ
था, उसे निकालना होगा।
जब यह हटाया जाए कि
इस स्थानीय वस्तु
का क्या होता है, तो
यह स्थानीय वस्तु
बनाई जाती है। इसलिए,
जो अपवाद(exception) होता
है वह सामान्य रूप
से होता है जो सामान्य
अस्तित्व के बिंदु
पर होता है जो यहां
इस फ़ंक्शन(function) का
विध्वंसक है जो कि
एक बृहदान्त्र टिल्ड
है जो मेरी कक्षा
को मिला होगा।
अब, आप इस बिंदु से
मौजूद हैं, अब आप इस
बिंदु से बाहर आ रहे
हैं क्योंकि आपने
एक फेंक दिया है।
लेकिन इस बिंदु पर
भी इस स्थानीय वस्तु
का विनाशकर्ता कहा
जाएगा। तो सभी ऑब्जेक्ट(object)
के सभी डिस्ट्रक्टर्स
जो इस बिंदु पर रहते
हैं तब डिस्ट्रक्टर्स
कहलाएंगे। और इसके
बाद ही स्टैक(stack) फ्रेम
को स्केच किया जाएगा
और नियंत्रण जी पर
वापस जाएगा।
अब अगर हमने अपना
अपवाद(exception) फेंक दिया
है, तो निश्चित रूप
से यह यहाँ मेल नहीं
खाता है, यहाँ मेल

English: 
here. You will have to remember that if you
have an exception and its specialization then
certainly when you write the clauses you should
first write the catch clause for the base
class and then the catch clause for the specialised
class. Because you remember the exceptions
are catch is matched is from one end to the
other. If you have a specialised class exception
thrown then it will then I saying the right
thing, I am sorry I am saying the wrong thing.
So, if I have exception here, and my exception
here, then I have two catch clauses; one for

English: 
my exception and another for the exception.
Now, what I am trying to point out is if you
have an exception of the base class then certainly
it will not match here, because this means
a down casting but it will go up and match
there. So, instead of this if you had say
it has my exception here then you will have
a problem because when you have an exception
of the derived class then it will match here
because you are doing a up cast.
So, you will have to remember that whenever
you have a hierarchy of a classes being used
for the exception then the specialised one
has to come higher earlier and the generalised
one have to come later. So that mechanism
will have to be followed.
This is all described in this point so you
can go throw that.
We have talked about raising the exception,
what happens in throw.
This is the exception showing that.

Telugu: 
యొక్క destructor ఉంది ఒక
పెద్దప్రేగు టిల్డే
నా క్లాస్(class) సూచించారు
వచ్చింది ఉండేది.
ఇప్పుడు, మీరు ఈ పాయింట్
నుండి ఉనికిలో ఉన్నారు,
ఇప్పుడు మీరు ఈ పాయింట్
నుండి బయటికి వచ్చారు
ఎందుకంటే మీరు ఒక
త్రో చేసారు. కానీ
ఈ సమయంలో కూడా ఈ స్థానిక
వస్తువు యొక్క destructor
అని పిలుస్తారు.
కాబట్టి ఈ సమయంలో
ప్రత్యక్షంగా ఉన్న
అన్ని ఆబ్జెక్ట్
(object) యొక్క అన్ని వినాశకకారులు
అప్పుడు పిలుస్తారు
అని పిలుస్తారు.
మరియు ఆ తర్వాత స్టాక్
ఫ్రేమ్ squashed చేయబడుతుంది
మరియు నియంత్రణ g
కు తిరిగి వెళ్తుంది.
ఇప్పుడు మన ఎక్స్సెప్షన్(exception)
ను విసిరినట్లయితే
అది ఖచ్చితంగా ఇక్కడ
సరిపోలడం లేదు, ఇక్కడ
సరిపోలడం లేదు, ఇది
ఇక్కడ సరిపోతుంది,
మరియు అది విసురుతుంది.
కాబట్టి నియంత్రణ
g నుండి f కి వెళుతుంది
అనగా G యొక్క స్టాక్
ఫ్రేమ్ కూడా విసిగిపోతుంది

Hindi: 
नहीं खाता है, यह यहाँ
मेल खाता है, और यह
फिर से फेंकता है।
तो नियंत्रण जी से
एफ तक वापस चला जाता
है जिसका अर्थ है
कि जी के स्टैक(stack)
फ्रेम को भी घुमावदार
होना चाहिए और इस
बिंदु पर किया जाएगा,
जो इस बिंदु पर किया
जाएगा, और जी का यह
स्थानीय ऑब्जेक्ट(object)
नष्ट हो जाएगा । इसलिए
अपवाद(exception) आधार प्रवाह
का मूल लाभ यह है कि
यह न केवल कॉल अनुक्रम
और ट्रायल ब्लॉक(block)
के आधार पर स्टैक(stack)
में आपके स्वचालित
रूप से ऊपर जाने का
ख्याल रखता है और
ट्रायल ब्लॉक(block)
में संबंधित कैच
धारा(clause) से मेल खाता
है। जब भी यह किसी
फ़ंक्शन(function) से बाहर
जाता है क्योंकि
फ़ंक्शन(function) ने इसे
फेंक दिया है, सभी
स्थानीय वस्तुओं
को नष्ट कर देता है
जो मौजूद थे।
किसी भी समय, यदि आपके
पास यहां से फेंका
गया है तो इसे फेंक
दिया गया है और अब
आप जिस पर काम कर रहे
हैं, आप जानते हैं
कि जी और एच के लिए;
सभी स्थानीय वस्तुओं
को फेंकने वाले दो
कार्यों को ठीक से
साफ किया गया है।
स्टैक(stack) किया गया
है क्योंकि इसे हटाने
की इस प्रक्रिया
को कहा जाता है, स्थानीय
वस्तुओं को स्वचालित
वस्तुओं को नष्ट
करने और स्टैक(stack)
फ्रेम को हटाने के
रूप में आप एक फ़ंक्शन(function)
से वस्तुओं को उसके
माता-पिता तक फेंकते
हैं, जिसे स्टैक(stack)
को खोलना कहा जाता
है क्योंकि स्टैक(stack)
ढह रहा है और जब तक
आप फ़ंक्शन(function) तक
नहीं पहुंच जाते।
जहां आप जारी रखने
वाले हैं। यह मूल
अपवाद(exception) तंत्र
है जो कि ट्राई ब्लॉक(block)
पर आधारित है।
निश्चित रूप से, मुझे
एक और बिंदु का भी
उल्लेख करना चाहिए।
मान लें कि यह वहाँ
था और एक फ़ंक्शन(function)
जी में कहने दें कि
इसके बजाय आपने अभी
जी लिखा है। मान लीजिए
कि आपने एक फ़ंक्शन(function)
कहा है जो कि ट्रायल
ब्लॉक(block) के भीतर
नहीं है और फिर यह
मेरा अपवाद(exception) उठाया
गया है। यदि मेरा
अपवाद(exception) जैसा उठाया
गया है, यहाँ मेल नहीं
खाता है, यहाँ से मेल
नहीं खाता है, तो यह
पुन: फेंकना होगा,
इसलिए मेरा अपवाद(exception)
यहाँ होता है। इस
जी के बाद हो सकता
है कि कुछ और बयान
हो।
अब क्या होता है, यदि
आप यह कोशिश ब्लॉक(block)
में भी नहीं करते
हैं, तो यदि आपको जी
में अपवाद(exception) मिलता
है, तो एक बार नियंत्रण
वापस आ जाने के कारण
आप अगले बयान पर जारी
नहीं रखते हैं, आप
तुरंत फेंक देते
हैं और उसी को बढ़ाते
हैं जनक को अपवाद(exception)
वस्तु। ये डिफ़ॉल्ट
तंत्र हैं। यह डिफ़ॉल्ट
तंत्र महत्वपूर्ण
है क्योंकि यदि आप
कुछ फ़ंक्शंस कॉल
के चारों ओर ट्राई
ब्लॉक(block) डालना भूल
जाते हैं, जिसमें
कुछ अपवाद(exception) हो
सकते हैं, तो आपके
पास त्रुटि को संभालने
में सक्षम नहीं होने
की कठिनाई का परीक्षण
होगा, इसलिए यदि आपने
नहीं उठाया है तो
डिफ़ॉल्ट रूप से
आपने किसी फ़ंक्शन(function)
को किसी ब्लॉक(block)

Telugu: 
మరియు ఈ సమయంలో చేయబడుతుంది,
ఈ సమయంలో చేయబడుతుంది,
మరియు g యొక్క ఈ స్థానిక
ఆబ్జెక్ట్ (object) నాశనం
అవుతుంది . సో ఎక్స్సెప్షన్(exception)
బేస్ ప్రవాహం యొక్క
ప్రాధమిక ప్రయోజనం
అది మీ స్వయంచాలకంగా
కాల్ క్రమంలో ఆధారంగా
స్టాక్ లో వెళుతుంది
మరియు బ్లాక్లను
ప్రయత్నించండి మరియు
ప్రయత్నించండి బ్లాక్(
block) లో సంబంధిత క్యాచ్
క్లాజ్తో(catch clause) సరిపోతుంది.
ఇది ఫంక్షన్ నుండి
బయటికి వెళ్లినప్పుడు,
ఫంక్షన్ విసిరినప్పటికి
అది ఉన్న అన్ని స్థానిక
వస్తువులను నాశనం
చేస్తుంది. ఏ సమయంలోనైనా,
మీరు ఇక్కడి నుండి
విసిరివేసినట్లయితే,
అది త్రో చేయబడి,
ఇప్పుడు మీరు F లో
పని చేస్తున్నారు,
మీకు g మరియు h కోసం
తెలుసు. అన్ని స్థానిక
ఆబ్జెక్ట్లను (objects)
విసిరి చేసిన రెండు
విధాలు సరిగా శుభ్రం
చేయబడ్డాయి. స్టాక్
అది తొలగించడం ఈ
ప్రక్రియ అని పిలుస్తారు
వంటి, స్థానిక ఆబ్జెక్ట్లు
(objects) ఆటోమేటిక్ ఆబ్జెక్ట్లు
(objects) దేస్త్రోయ్ destroy)
మరియు స్టాక్ ఫ్రేములు
తొలగించడం మీరు ఒక
ఫంక్షన్ నుండి దాని
తల్లితోకి ఆబ్జెక్ట్లు
(objects) లను త్రో (throw) స్టాక్
అని పిలుస్తారు స్టాక్
అంటారు మరియు మీరు
ఫంక్షన్ ను వరకు
మీరు కొనసాగించాలని
కోరుతున్నారు. ఇది
ప్రాథమిక బ్లాక్
ఎక్స్సెప్షన్(exception)
విధానం. ఖచ్చితంగా,
మరొక పాయింట్ గురించి
కూడా చెప్పండి. ఈ
అనుమానమే అని అనుకుందాం
మరియు బదులుగా ఈ
ఫంక్షన్ g లో మీరు
చెప్పేదానిని చెప్పండి.
మీరు ప్రయత్నించండి
బ్లాక్ ఎర్రర్(error)

English: 
All these we have discussed now, the re throw
what happens in terms of re throw that we
have discussed.
Finally, before we conclude you would like
to note that there are several advantages
of this try catch for mechanism. It is a destructor
savvy because it take and on mind the stack
and clean up the local object is a non obtrusive
because it separates out the whole code clutter
into separate normal flow and the exception
flow it is precise. It is native and standard,
in the sense is the part of the language not
part of a third party or stand standard library
like that.
In that process this is quite scalable and
quite fault tolerant. Scalable in it does
not matter as to how many try blocks you have,
how much of nesting you have, how much catch
clauses you have, this will work in every
case in a right manner.

Hindi: 
में नहीं रखा है, तो
आप इसे बस एक माता-पिता
के पास भेज देते हैं,
आपके माता-पिता ऐसा
करते रहते हैं।
अंत में, यदि आपके
पास मुख्य में कुछ
अपवाद(exception) हैं जो
एक कोशिश ब्लॉक(block)
द्वारा संरक्षित
नहीं हैं या एक पकड़
खंड है। मान लीजिए,
यहाँ मेरे पास यह
कैच क्लॉज़ नहीं
था, तो मान लीजिए कि
मेरे पास किसी और
क्लास के लिए कुछ
कैच क्लॉज़ थे। लेकिन
मेरे पास सभी क्लॉज़
नहीं थे, तो यह बहुत
संभव है कि मेरी क्लास
ऑब्जेक्ट(object) की तरह
फेंके गए एक अपवाद(exception)
को इस बिंदु पर नहीं
पकड़ा जाएगा क्योंकि
यह यहाँ मेल नहीं
खाता। उस स्थिति
में मुख्य निश्चित
रूप से फेंक नहीं
सकता है, क्योंकि
इसमें एक कॉलर नहीं
है। तो उस स्थिति
में एक समाप्ति हैंडलर
को बुलाया जाएगा।
तो, यह अपवादों का
एक बुनियादी तंत्र
है जो होता है।
हमने स्लाइड के अगले
दो भाग में क्या किया
है, मैंने जो कुछ भी
चर्चा की है, वे कुछ
और विवरणों के साथ
उदाहरण के लिए यहाँ
प्रलेखित हैं। उदाहरण
के लिए, एक पूरे के
रूप में एक कार्य
एक कोशिश ब्लॉक(block)
हो सकता है। तो, आप
जो कुछ भी करते हैं,
वह आपके द्वारा एक
फ़ंक्शन(function) और फ़ंक्शन(function)
हेडर के मुख्य भाग
में एकाधिक प्रयास
ब्लॉक(block) डालने के
बजाय है और यह फ़ंक्शन(function)
बॉडी है। इसलिए, इसके
बीच में आप कोशिश
लिखते हैं, जिसका
अर्थ है कि पूरे कार्य
प्रयास का एक हिस्सा
है। स्वाभाविक रूप
से कोशिश करने वाले
ब्लॉक(block) को ब्लॉक(block)
के भीतर घोंसला बनाया
जा सकता है आप अन्य
ब्लॉक(block) और इतने
पर हो सकते हैं, लेकिन
कोशिश करें कि ब्लॉक(block)
के पास एक पकड़ने
वाला ब्लॉक(block) होना
चाहिए।
यह पहले के उदाहरण
से है कि अभी क्या
है।
उसके बाद कैच ब्लॉक(block)
का एक अलग तर्क होता
है कि हमने देखा है
कि प्रत्येक कैच
ब्लॉक(block) में एक तर्क
होगा और कैच ब्लॉक(block)
के बीच अद्वितीय
होना चाहिए।
इसलिए, यहाँ के तर्कों
को अद्वितीय होना
चाहिए। और एक नोट
करने के लिए दो दिलचस्प
चीजें हैं, यह है कि
आपको इस तर्क को कैसे
पारित करना चाहिए,
क्या आपको इसे एक
मूल्य के रूप में
या एक संदर्भ के रूप
में पारित करना चाहिए।
आमतौर पर इसे एक संदर्भ
के रूप में पारित
किया जाता है। विशेष
रूप से अगर यह एक उपयोगकर्ता
द्वारा परिभाषित
ऑब्जेक्ट(object) है तो
आप इसे एक संदर्भ
के रूप में पास करना
चाहेंगे कारण टाइप
करें क्योंकि तब
आपको उस अपवाद(exception)
ऑब्जेक्ट(object) को कॉपी
करने की आवश्यकता
नहीं है जिसे आप केवल
प्रचार कर सकते हैं।
और जब भी यह हैंडलर
समाप्त होता है, जब
भी हैंडलर समाप्त
होता है अगर यह फिर
से नहीं फेंका जाता
है जब भी हैंडलर समाप्त
होता है तो यह अपवाद(exception)
ऑब्जेक्ट(object) को नष्ट
कर देगा। यह भी दिलचस्प
है कि अपवाद(exception) वस्तु
एक प्रकार की होती
है इसलिए अपवाद(exception)

Hindi: 
वस्तुएं स्वचालित
वस्तुओं की तरह बन
जाती हैं क्योंकि
वे इस बिंदु पर निर्मित
होती हैं जब उन्हें
फेंक दिया जाता है
या इससे पहले कि फ़ंक्शन(function)
में यह उन्हें फेंक
रहा है और वे किसी
अन्य फ़ंक्शन(function)
में नष्ट हो जाएंगे
पकड़ हैंडलर में
गुंजाइश। एक बहुत
ही रोचक स्वचालित
वस्तु है, जिसमें
जीवन भर की गुंजाइश
होती है, जो उस समय
पर निर्भर होती है
जो जरूरी नहीं कि
संकलन के समय पर हो
जो अन्य सभी स्वचालित
वस्तुओं के लिए विशिष्ट
हो।
और इसलिए, अपवाद(exception)
वस्तुओं को हमेशा
स्टैक(stack) में नहीं
बल्कि स्टैक(stack) में
मुफ्त स्टोर में
बनाया जाना चाहिए,
लेकिन आप एक ढेर के
रूप में क्या कहते
हैं। क्योंकि आप
इसे स्टैक(stack) में
नहीं रख सकते क्योंकि
आप नहीं जानते कि
आपको इस ऑब्जेक्ट(object)
को बनाए रखने के लिए
कितने समय की आवश्यकता
होगी। इसलिए, आप यह
नहीं जानते कि किसी
फ़ंक्शन(function) का स्टैक(stack)
फ्रेम जिसमें आप
बनाते हैं कि स्टैक(stack)
फ्रेम कितनी देर
तक मौजूद रहेगा।
तो आप आमतौर पर इन
वस्तुओं को फ्री
स्टोर में बनाएंगे।
हमने अपवाद(exception) मिलान
के बारे में बात की
है।
यह सिर्फ यहाँ विस्तृत
है कि आप जो अपवाद(exception)
फेंकते हैं, वह यहाँ
कैसे मेल खाता है।
आपको यह याद रखना
होगा कि यदि आपके
पास कोई अपवाद(exception)
और उसकी विशेषज्ञता
है तो निश्चित रूप
से जब आप क्लॉस लिखते
हैं तो आपको पहले
बेस क्लास के लिए
कैच धारा(clause) और फिर
स्पेशल क्लास के
लिए कैच धारा(clause) लिखना
चाहिए। क्योंकि आपको
याद है कि अपवाद(exception)
एक छोर से दूसरे छोर
तक कैच होते हैं।
यदि आपके पास एक विशेष
वर्ग अपवाद(exception) है,
तो यह तब मैं सही बात
कहूंगा, मुझे खेद
है कि मैं गलत बात
कह रहा हूं। इसलिए,
अगर मेरे यहाँ अपवाद(exception)
है, और यहाँ मेरा अपवाद(exception)
है, तो मेरे पास दो
कैच क्लॉस हैं; एक
मेरे अपवाद(exception) के
लिए और दूसरा अपवाद(exception)
के लिए।
अब, मैं यह बताने की
कोशिश कर रहा हूं
कि अगर आपके पास आधार
वर्ग का कोई अपवाद(exception)
है, तो निश्चित रूप
से यह यहां मेल नहीं
खाएगा, क्योंकि इसका
मतलब डाउन कास्टिंग
है लेकिन यह वहां
जाकर मैच करेगा।
तो, इसके बजाय, यदि
आपने कहा था कि यह
मेरा अपवाद(exception) है,
तो आपको एक समस्या
होगी क्योंकि जब
आपके पास व्युत्पन्न
वर्ग का एक अपवाद(exception)
होगा, तो यह यहाँ मेल
खाएगा क्योंकि आप
एक अप कास्ट कर रहे
हैं।
तो, आपको यह याद रखना
होगा कि जब भी आपके
पास अपवाद(exception) के
लिए उपयोग की जा रही
कक्षाओं की पदानुक्रम
होती है तो विशेष
को पहले उच्चतर आना
होता है और सामान्यीकृत
को बाद में आना होता
है। तो उस तंत्र का
पालन करना होगा।
यह सब इस बिंदु में
वर्णित है ताकि आप
इसे फेंक सकें।
हमने अपवाद(exception) को
बढ़ाने के बारे में

Telugu: 
ఒక ఫంక్షన్ అని పిలుస్తారు
మరియు ఈ నా ఎక్స్సెప్షన్(exception)
లేవనెత్తింది. ఇక్కడ
ఉన్న ఎక్స్సెప్షన్(exception)
ఇక్కడ సరిపోలడం లేదు,
ఇక్కడ సరిపోలడం లేదు,
ఇదే త్రో నుండి వస్తుంది,
కాబట్టి నా ఎక్స్సెప్షన్(exception)
ఇక్కడే జరుగుతుంది.
ఈ g తర్వాత కొంతమంది
మరొక ప్రకటన ఉంటుంది.
ఇప్పుడు ఏమి జరుగుతుందో,
ఆ ప్రయత్నం బ్లాక్లో
కూడా కాకపోతే, g లో
ఒక ఎక్స్సెప్షన్(exception)
లభిస్తే ఆ నియంత్రణ
ఎక్స్సెప్షన్(exception)
వలన మీరు తదుపరి
స్టేట్మెంట్ వద్ద
కొనసాగించలేరు, మీరు
వెంటనే త్రో మరియు
అదే తల్లిదండ్రులకు
ఎక్స్సెప్షన్(exception)
ఆబ్జెక్ట్ (object). ఇవి
డిఫాల్ట్ మెకానిజం.
ఈ డిఫాల్ట్ మెకానిజం(default
mechanism) ముఖ్యం ఎందుకంటే
కొన్ని ఎక్స్సెప్షన్(exception)
తీసుకునే కొన్ని
ఫంక్షన్ల కాల్స్
చుట్టూ బ్లాక్ను
ప్రయత్నించాలని
మీరు మర్చిపోతే ఉంటే,
మీరు ఎర్రర్(error) నిర్వహించలేకపోతున్నారో
లేనట్లయితే, మీరు
ప్రయత్నించండి బ్లాక్
ఎర్రర్(error) ఒక ఫంక్షన్
చాలు లేదు మీరు కేవలం
ఒక పేరెంట్ దానిని
పాస్, మీ తల్లిదండ్రుడు
ఆ చేయడం ఉంచుతుంది.
చివరగా, మీరు ప్రయత్నిస్తున్న
బ్లాక్ ద్వారా కాపాడబడని
లేదా క్యాచ్ క్లాజ్(catch
clause) ఉన్న ప్రధానంగా
కొన్ని ఎక్స్సెప్షన్(exception)
ఉంటే. అనుకుందాం,
ఇక్కడ నేను ఈ క్యాచ్
నిబంధన లేదు, ఇక్కడ
కొన్ని ఇతర క్లాస్
కోసం కొన్ని క్యాచ్
నిబంధనలను కలిగి
ఉన్నాను. కానీ నేను
అన్ని క్లాజ్ని క్యాచ్
చేయలేదు, అది నా తరగతి
ఆబ్జెక్ట్లా(object)
విసిరివేయడం వంటి
ఎక్స్సెప్షన్(exception)
ఈ సమయంలో క్యాచ్
చేయబడదు కాబట్టి
ఇక్కడ సరిపోలడం లేదు.
అది ఒక కాలర్ లేదు
ఎందుకంటే ఆ సందర్భంలో
ప్రధాన ఖచ్చితంగా
త్రో కాదు. కాబట్టి
ఆ సందర్భంలో ఒక టెర్మ్రినెషన్
హ్యాండ్లర్(termination
handler) అని పిలుస్తారు.
కాబట్టి, జరిగే ఎక్స్సెప్షన్(exception)
యొక్క ప్రాథమిక విధానం.
తరువాతి రెండు స్లయిడ్లలో
మనము చేసిన వాటిని,
నేను చర్చించిన వాటిని
మరికొంత వివరాలతో
ఉదాహరణగా డాక్యుమెంట్(document)
చేయబడ్డాయి. ఉదాహరణకు,
మొత్తంగా ఒక ఫంక్షన్
ఒక బ్లాక్ను కలిగి
ఉండవచ్చు. కాబట్టి,
మీరు చేసే అన్నింటికీ
బదులుగా మీరు ప్రయత్నిస్తున్న
బహుళ ప్రయత్నం బ్లాక్
మరియు ఫంక్షన్ శీర్షిక
యొక్క ఫంక్షన్ మరియు
ఇది ఫంక్షన్ బాడీ.
కాబట్టి, మీరు రాయడానికి
మధ్య వ్రాయడం అంటే
మొత్తం చర్యలు ఒక
భాగం అని అర్థం. సహజంగానే
ప్రయత్నించండి బ్లాక్స్
ప్రయత్నించండి బ్లాక్
ఎర్రర్(error) యున్న
ఇతర బ్లాక్స్ మరియు
అందువలన న, కానీ ప్రయత్నించండి

English: 
With this to summarise we have discussed the
exception or error handling in C++ particularly
we have try to understand the try catch throw
mechanism of C++ which takes care of all possible
ways the exceptions can happen and all possible
ways you can handle that.
Actually if you can continue to design properly
with try throw catch in C++ you would not
need any of the exception mechanism in C.
Of course you will still need to use them
because some of the system calls do use those
error mechanisms like, putting signals or
putting error number. So you will still need
to use for those cases, but for your own code
you will never need to use any of the C error handling or C standard library functions.

Telugu: 
బ్లాక్ ఆ క్యాచ్
బ్లాక్(catch block) కలిగి
ఉండాలి.
ఇది ఇంతకుముందు ఉన్న
ఉదాహరణ నుండి కేవలం
ఏమి చూపిస్తున్నది.
అప్పుడు క్యాచ్ బ్లాక్(catch
block) మేము ప్రతి క్యాచ్
బ్లాక్ చూసిన ఒక
భిన్నమైన వాదనలు
కలిగి వాదన మరియు
క్యాచ్ బ్లాక్స్
మధ్య ప్రత్యేక ఉండాలి.
కాబట్టి, ఇక్కడ వాదనలు
ప్రత్యేకంగా ఉండాలి.
మరియు ఒక గమనించదగ్గ
రెండు ఆసక్తికరమైన
విషయాలు ఉన్నాయి,
మీరు ఈ వాదన పాస్
ఎలా ఉంది, మీరు ఒక
విలువ లేదా ఒక సూచన
గా పాస్ ఉండాలి. సాధారణంగా
ఇది సూచనగా ఆమోదించబడుతుంది.
ప్రత్యేకంగా వినియోగదారు
నిర్వచించిన ఆబ్జెక్ట్
రకంగా ఉంటే, దానిని
మీరు ఒక సూచనగా ఉత్తీర్ణించుకోవాలనుకుంటున్నారంటే,
మీరు ఆ ఎక్స్సెప్షన్(exception)
ఆబ్జెక్ట్(object)ను
కాపీ చేయనవసరం లేదు,
మీరు కేవలం ప్రచారం
చేస్తూ ఉంటారు. మరియు
అది హ్యాండ్లర్ ముగుస్తుంది
చేసినప్పుడు, హ్యాండ్లర్
ఆగిపోతుంది చేసినప్పుడు
అది విసిరిన లేదు
ఉంటే హ్యాండ్లర్
రద్దు చేసినప్పుడు
అది ఆ ఎక్స్సెప్షన్(exception)
ఆబ్జెక్ట్(object) నాశనం
చేస్తుంది. ఇది ఎక్స్సెప్షన్(exception)
ఆబ్జెక్ట్ రకం కాబట్టి
ఎక్స్సెప్షన్(exception)
ఆబ్జెక్ట్లను (object)
ఆటోమేటిక్ ఆబ్జర్స్
రకంగా మారుతుండటం
కూడా చాలా ఆసక్తికరంగా
ఉంటుంది, ఎందుకంటే
అవి త్రో(throw) చేసినపుడు
లేదా వాటిని త్రో(throw)
చేస్తునపుడు లేదా
వాటికి ముందు నిర్మించబడతాయి
మరియు అవి కొన్ని
ఇతర ఫంక్షన్లో విధ్వంసం
పొందుతాయి క్యాచ్
హ్యాండ్లర్లో(catch
handler) స్కోప్(scope). అన్ని
ఇతర ఆటోమేటిక్ ఆబ్జెక్ట్(object)
విలక్షణమైన సంకలనం
సమయంలో తప్పనిసరిగా
రన్టైమ్పై ఆధారపడిన
జీవితకాల పరిధిని
కలిగి ఉన్న చాలా
ఆసక్తికరమైన ఆటోమేటిక్
ఆబ్జెక్ట్(object) రకం
ఉంది. అందువలన, ఎక్స్సెప్షన్(exception)
ఆబ్జెక్ట్లని (object)
స్టాక్లో కాకుండా
ఉచిత స్టోర్లో ఎల్లప్పుడూ
సృష్టించాలి, కానీ
మీరు ఒక నిండుగా
చెబుతారు. ఎందుకంటే
స్టాక్లో మీరు దీన్ని
చేయలేరు ఎందుకంటే
మీరు ఎంతకాలం ఈ ఆబ్జెక్ట్ను
నిర్వహించాలో మీకు
తెలియదు. కాబట్టి,
మీకు తెలిసిన ఫంక్షన్
యొక్క స్టాక్ ఫ్రేమ్
(stack frame) మీరు ఎంతసేపు
ఆ స్టాక్ ఫ్రేం ఉంటుందో
లేదో తెలియదు. కాబట్టి
మీరు సాధారణంగా ఈ
ఆబ్జెక్ట్లను (object)
ఉచిత దుకాణంలో సృష్టించుకోవచ్చు.
మేము ఎక్స్సెప్షన్(exception)
సరిపోలిక గురించి
మాట్లాడారు.
ఇక్కడ వివరించబడినది
ఏమిటంటే, ఎక్స్సెప్షన్(exception)
ఏమిటంటే, అది ఇక్కడ
ఎలా సరిపోతుంది.
మీరు ఒక ఎక్స్సెప్షన్(exception)
మరియు దాని స్పెషలైజేషన్(specialization)
ఉంటే మీరు ఖచ్చితంగా
ఉపోద్ఘాతాలను వ్రాస్తున్నప్పుడు
మీరు ప్రాథమిక తరగతికి
క్యాచ్ నిబంధనను
వ్రాయాలి మరియు ప్రత్యేక
క్లాస్ (class)కి క్యాచ్
నిబంధనను వ్రాయాలి.
మీరు గుర్తుంచుకోవడం
వలన మినహాయింపులు
క్యాచ్ ఒక ముగింపు
నుండి మరొకదానికి
సరిపోతుంది. మీరు
ఒక ప్రత్యేక క్లాస్
ఎక్స్సెప్షన్(exception)
త్రో చేసినట్లైతే
అప్పుడు నేను సరిగ్గా
చెప్పాను, నేను తప్పుగా
చెప్తున్నాను క్షమించండి.
కాబట్టి, నేను ఇక్కడ
ఎక్స్సెప్షన్(exception)
కలిగి ఉంటే, మరియు
నా ఎక్స్సెప్షన్(exception)
ఇక్కడ ఉంటే, నాకు
రెండు క్యాచ్ (catch)
నిబంధనలు ఉన్నాయి;
ఎక్స్సెప్షన్(exception)

Hindi: 
बात की है, जो कि फेंकने
में होता है।
यह अपवाद(exception) है जो
दिखा रहा है।
इन सभी पर हमने अभी
चर्चा की है, री-थ्रो
क्या होता है री-थ्रो
के संदर्भ में हमने
चर्चा की है।
अंत में, इससे पहले
कि हम यह निष्कर्ष
निकालें कि आप यह
नोट करना चाहेंगे
कि तंत्र के लिए इस
प्रयास को पकड़ने
के कई फायदे हैं।
यह एक विध्वंसक प्रेमी
है क्योंकि यह स्टैक(stack)
को ध्यान में रखता
है और स्थानीय वस्तु
को साफ करता है, यह
एक अप्रतिदेय है
क्योंकि यह पूरे
कोड अव्यवस्था को
अलग-अलग सामान्य
प्रवाह में अलग करता
है और अपवाद(exception) प्रवाह
सटीक है। यह मूल और
मानक है, इस अर्थ में
भाषा का हिस्सा तीसरे
पक्ष का हिस्सा नहीं
है या उस तरह मानक
पुस्तकालय नहीं है।
इस प्रक्रिया में
यह काफी स्केलेबल
और काफी गलत सहिष्णु
है। स्केलेबल, इसमें
कोई फर्क नहीं पड़ता
है कि आपके पास कितने
प्रयास ब्लॉक(block)
हैं, आपके पास कितने
घोंसले हैं, आपके
पास कितना पकड़ है,
यह हर मामले में एक
सही तरीके से काम
करेगा।
इसके साथ संक्षेप
में हमने C ++ में अपवाद(exception)
या त्रुटि से निपटने
पर चर्चा की है, विशेष
रूप से हमने C ++ की
कोशिश, कैच, थ्रो मैकेनिज्म
को समझने की कोशिश
की है जो सभी संभावित
तरीकों का ध्यान
रखता है और अपवाद(exception)
हो सकते हैं और सभी
संभावित तरीके जो
आप संभाल सकते हैं।
वास्तव में यदि आप
C ++ में थ्रो थ्रो के
साथ ठीक से डिज़ाइन
करना जारी रख सकते
हैं, तो आपको सी में
किसी भी अपवाद(exception)
तंत्र की आवश्यकता
नहीं होगी। बेशक
आपको अभी भी उनका
उपयोग करने की आवश्यकता
होगी, क्योंकि कुछ
सिस्टम कॉल उन त्रुटि
तंत्रों का उपयोग
करते हैं, जैसे सिग्नल
या त्रुटि संख्या
डाल रहा है। तो आपको
अभी भी उन मामलों
के लिए उपयोग करने
की आवश्यकता होगी,
लेकिन अपने स्वयं
के कोड के लिए आपको
कभी भी सी त्रुटि
हैंडलिंग(handling) या
सी लाइब्रेरी लाइब्रेरी
फ़ंक्शंस का उपयोग
करने की आवश्यकता
नहीं होगी।

Telugu: 
కోసం నా ఎక్స్సెప్షన్(exception)
మరియు మరొకటి ఒకటి.
ఇప్పుడు, బేసిక్
క్లాస్(basic class) ఎక్స్సెప్షన్(exception)కలిగి
ఉంటే, నేను ఖచ్చితంగా
ఇక్కడకు సరిపోలడం
లేదు అని చెప్పడానికి
ప్రయత్నిస్తున్నాను,
ఇది ఒక డౌన్ కాస్టింగ్
అని అర్థం, కానీ అది
అక్కడకు వెళ్లి అక్కడ
సరిపోతుంది. కాబట్టి,
దీనికి బదులుగా,
నా ఎక్స్సెప్షన్(exception)
ఉన్నట్లు మీరు చెప్పినట్లయితే
మీరు సమస్యను కలిగి
ఉంటారు ఎందుకంటే
మీరు ఉత్పన్నమైన
క్లాస్కి (class) ఎక్స్సెప్షన్(exception)
ఉన్నట్లయితే, అది
మీరు తారాగణం చేస్తున్నందున
ఇక్కడ సరిపోతుంది.
కాబట్టి, మీర ఎక్స్సెప్షన్(exception)
కోసం ఉపయోగించిన
క్లాస్సులు యొక్క
అధికారాన్ని కలిగి
ఉన్నప్పుడు, ప్రత్యేకమైనది
ముందుగా వచ్చినప్పుడు
మరియు సాధారణీకరించబడిన
తర్వాత వచ్చిన తర్వాత
గుర్తుంచుకోవాలి.
కాబట్టి ఆ మెకానిసం
(mechanism) అనుసరించాల్సి
ఉంటుంది.
ఈ అన్ని లో వివరించబడింది
ఈ కాబట్టి మీరు త్రో
వెళ్ళే.
మేము ఎక్స్సెప్షన్(exception)
పెంచడం గురించి మాట్లాడారు,
ఏమి త్రో లో జరుగుతుంది.
ఇది ఎక్స్సెప్షన్(exception)
అని చూపిస్తుంది.
ఇవన్నీ మనం చర్చించాము,
మేము మళ్ళీ చర్చించాము,
తద్వారా చర్చించాము.
చివరగా, మేము ముగుస్తుందాము
ముందే, మీరు ఈ యంత్రాంగం
కొరకు పట్టుకోడానికి
అనేక ప్రయోజనాలు
ఉన్నాయని గమనించదలిచారు.
ఇది ఒక నిర్జలకారి
అవగాహన ఎందుకంటే
స్టాక్ (stack) మరియు
మనస్సును స్టాక్
(stack) చేసి స్థానిక
ఆబ్జెక్ట్ (object)ను
శుభ్రం చేయడం అనేది
ఒక అవాంఛనీయమైనది
కాదు, ఎందుకంటే ఇది
మొత్తం సాధారణ అస్తవ్యస్తంగా
వేర్వేరు సాధారణ
ప్రవాహాన్ని వేరు
చేస్తుంది మరియు
ఎక్స్సెప్షన్(exception)
ప్రవాహం ఖచ్చితమైనది.
ఇది స్థానిక మరియు
ప్రమాణం, అర్థంలో
మూడవ భాగం యొక్క
భాషలో భాగం కాదు
లేదా అలాంటి ప్రామాణిక
లైబ్రరీని(library) నిలబెట్టుకోండి.
ఆ ప్రక్రియలో చాలా
కొలవలేని మరియు చాలా
తప్పు సహనం ఉంది.
స్కేలబుల్ (scalable), ఇది
మీరు ఎన్ని బ్లాక్స్
ప్రయత్నించండి, మీరు
ఎంత నేస్టింగ్( nesting)
కలిగి, మీరు కలిగి
ఉన్న ఉపవాక్యాలు
క్యాచ్, ఇది ప్రతి
సందర్భంలో సరైన రీతిలో
పని చేస్తుంది పట్టింపు
లేదు.
దీనితో మేము C ++ లో
ఎక్స్సెప్షన్(exception)
లేదా ఎర్రర్(error) నిర్వహణ
గురించి చర్చించాము,
ముఖ్యంగా ప్రయత్నించండి,
క్యాచ్, C ++ యొక్క మెకానిజం(mechanism)
త్రో (throw) చేసిపుచ్చడం,
ఎక్స్సెప్షన్(exception)
జరగడానికి మరియు
మీరు నిర్వహించగల
అన్ని సాధ్యమైన మార్గాలు.
మీరు C ++ లో క్యాచ్
త్రో తో సరిగ్గా
రూపకల్పన చేయటానికి
కొనసాగితే, మీరు
C లో ఉన్న ఎక్స్సెప్షన్(exception)
విధానం ఏదీ అవసరం
లేదు. అయితే మీరు
ఇప్పటికీ వాటిని
ఉపయోగించాల్సి ఉంటుంది,
ఎందుకంటే వ్యవస్థలోని
కొన్ని పిలుపులు
సిగ్నల్లను ఉంచడం,
లేదా ఎర్రర్(error) సంఖ్య
పెట్టటం. కాబట్టి
మీరు ఆ సందర్భాల్లో
ఇంకా ఉపయోగించాల్సి
ఉంటుంది, కానీ మీ
స్వంత కోడ్ కోసం
మీరు సి ఎర్రర్(error)
నిర్వహణ లేదా C లైబ్రరీ
విధులు ఏదీ ఉపయోగించాల్సిన
అవసరం లేదు.
