
Telugu: 
C + + లో ప్రోగ్రామింగ్
మాడ్యూల్ 31 కు స్వాగతం.
చివరి రెండు మాడ్యూల్స్లో
మేము డైనమిక్ బైండింగ్
(dynamic binding), పాలిమార్ఫిజం
;(polymorphism) గురించి చర్చించాము,
పాలిమార్ఫిక్ రకం
(polymorphic type) మరియు ముఖ్యంగా
మేము నేర్చుకున్న
ప్రధాన కొత్త ఫీచర్స్(features)
పాలిమార్ఫిక్ డిస్పాచ్(polymorphic
dispatch) డిస్పాత్క్ గురించి
చర్చించాము.
ఇది పాలిమార్ఫిక్
హీరార్చి(polymorphic hierarchy)
చెందిన క్లాస్ (class)

Hindi: 
C++ में प्रोग्रामिंग
के मॉड्यूल(module) 31 में
आपका स्वागत है।
डायनामिक(dynamic) बाइंडिंग(binding),
पोलीमोर्फिज्म(polymorphism)
के बारे में हमने
पिछले कुछ मॉड्यूल(module)
में चर्चा की है, हमने
चर्चा की है कि पोलीमोर्फिज्म(polymorphism)
क्या है और विशेष

Tamil: 
 
சி ++ இல் புரோகிராமிங்கின்
தொகுதி 33 க்கு வருக. சி
மற்றும் வி பிளஸ்
பிளஸில் வகை வார்ப்பு
மற்றும் குறிப்பாக
சி ++ இல் நடிகர்கள்
ஆபரேட்டர்கள் பற்றி
நாங்கள் விவாதித்து
வருகிறோம்.
எனவே,
சி மற்றும் சி ++ இல்
நடிப்பைப் புரிந்துகொள்வதற்கான

English: 
Welcome to Module 31 of Programming in C++. In the last couple of modules we have discussed
about Dynamic Binding, the Polymorphism, we have discussed what is polymorphic type and
particularly the major new future that we
have learnt is about polymorphic dispatch.
It is a mechanism through which, when I call a member function of a class belonging to

Telugu: 
యొక్క సభ్యుల చర్యను
నేను పిలుస్తున్నప్పుడు
ఇది ఒక మెకానిసం(mechanism)
. నేను ఒక పాయింటర్
(pointer)ద్వారా లేదా బేస్
క్లాస్ టైప్ (base class
type)యొక్క రిఫరెన్స్(
reference) ద్వారా కాల్
చేసినప్పుడు, వాస్తవిక
ఫంక్షన్ పాయింటర్
లేదా రిఫరెన్సు రకంపై
ఆధారపడి ఉండదు, అయితే
వాస్తవానికి ఇది
ప్రస్తుత ఆబ్జెక్ట్(
object) సూచించబడుతుందని
లేదా సూచించడం జరుగుతుంది.
ఇది రన్టైమ్ (runtime)
మీద ఆధారపడి ఉంటుంది
మరియు ఈ మెకానిసం(mechanism)
పాలిమార్ఫిజం;(polymorphism)
అని పిలుస్తారు లేదా
మేము చూసినట్లుగా
ఈ విధమైన బైండింగ్ను
డైనమిక్ బైండింగ్(dynamic
binding) అని పిలుస్తారు
మరియు C ++ లో పాలిమార్ఫిక్

English: 
a polymorphic hierarchy. When I make the call through a pointer or through the reference
of the base class type then the actual function
invoked depends not on the type of the pointer
or the reference, but it actually depends
on the current object being pointed to or
being refer to. It depends on the runtime
and this mechanism is known as Polymorphism
or this method of binding is known as Dynamic
Binding as we have seen, and this whole thing
is known as Polymorphic Dispatch in C++.
We have looked at polymorphic dispatch mechanism
and we have used it extensively in designing
a solution of staff salary processing. In
the module today, we will discuss about Virtual

Hindi: 
रूप से प्रमुख नई
विशेषता जो हमने
सीखी है वह पॉलीमोर्फिक(polymorphic)
प्रेषण के बारे में
है।
यह एक तंत्र है जिसके
माध्यम से, जब मैं
एक पॉलीमोर्फिक(polymorphic)
पदानुक्रम(hierarchy) से
संबंधित क्लास(class)
के एक सदस्य(member) फ़ंक्शन(function)
को कॉल करता हूं।
जब मैं एक पॉइंटर(pointer)
के माध्यम से या बेस
क्लास प्रकार के
संदर्भ के माध्यम

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

Hindi: 
से कॉल करता हूं, तो
वास्तविक फ़ंक्शन(function)(function)
का उपयोग पॉइंटर(pointer)
या संदर्भ के प्रकार
पर निर्भर नहीं करता
है, लेकिन यह वास्तव
में वर्तमान ऑब्जेक्ट(object)
पर निर्भर करता है
या संदर्भित होने
के लिए निर्भर करता
है। यह रनटाइम पर
निर्भर करता है और
इस तंत्र को पोलीमोर्फिज्म(polymorphism)
के रूप में जाना जाता

Telugu: 
డిస్పాచ్(polymorphic dispatch)
అని పిలువబడుతుంది.
మేము పాలిమార్ఫిక్
డిస్పాచ్ మెకానిజం(polymorphic
dispatch mechanism) చూసాము మరియు
స్టాఫ్ సాలెరి (staff
salary) ప్రాసెసింగ్(processing)
పరిష్కారం రూపకల్పనలో
దీనిని విస్తృతంగా
ఉపయోగించాము. నేడు
మాడ్యూల్ లో, మనం
వర్చ్యువల్ ఫంక్షన్
టేబుల్ ( virtual function table)
గురించి చర్చించబోతున్నాము,
ఈ పాలిమర్ను ఎలా
పంపించాలో పరంగా
అవగాహన కొంచెం అర్ధం
చేసుకోవాలనుకుంటున్నాము;
కంపైలర్ (compiler) చేత
అమలు చేయబడుతుంది.
ఎందుకంటే కంపైలర్
స్టాటిక్(compiler static)
సమయంలో పనిచేస్తున్నప్పుడు
మీరు కోడ్ ప్రాసెస్
అవుతుందని గుర్తుంచుకోండి.
ఆ సమయంలో ప్రాసెస్
జరుగుతోంది ఎటువంటి
అమలు ఉంది. కాబట్టి

English: 
Function Table that is we would like to take
a little bit of understanding in terms of
how is this polymeric dispatched; actually
implemented by the compiler. Because you will
have to recall that the compiler works at
the static time when the code is being process
the source is being processed at that time
there is no execution that is happening.
So, compiler has no way of knowing as to at
runtime given a pointer which is the type
of object that it will actually point too,
but still it has to generate a code that will
work according to the dynamic type during
the execution.
This is done through the use of virtual function
table, which is key for the polymeric dispatch.
For this we will take a quick recap of the
salary processing application have we been

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

English: 
discussing, we will introduce a new solution
in C and show how that gives us the insight
into understanding the virtual function table
for the dispatch.
.
So this was the problem, we had assume that
there are different types employees for whom
a salary needs to be processed and their salary
processing algorithms are different. And the
crux of the whole design is the fact that
the design needs to be appropriately extensible
it should be possible to extent add new classes
to the hierarchy as and when we want to do
that.
.
In C, we had taken this considerations and
you can always refer to the earlier module,
refer them have a module number also and check
up on what are design considerations.
.
Now, while we discussed the solution we had
used the mechanism of a function switch, that
is we explicitly maintained the type and at

Telugu: 
కంపైలర్ ఒక పాయింటర్
ఇచ్చిన రన్టైమ్ వద్ద
తెలుసుకోవడం ఎటువంటి
మార్గం లేదు, ఇది
వాస్తవంగా సూచించే
ఆబ్జెక్ట్ (object) యొక్కటైప్
(type), కానీ అది అమలు
సమయంలో డైనమిక్ టైప్ని(
dynamic type) బట్టి పని చేసే
ఒక కోడ్ను రూపొందించాలి.
ఇది వర్చువల్ ఫంక్షన్
టేబుల్ ( virtual function table)వాడకం
ద్వారా జరుగుతుంది,
ఇది పాలీమెరిక్ డిస్పాచ్
కి కీ(key). దీని కోసం
మేము చర్చిస్తున్న
సాలెరి ప్రాసెసింగ్(
salary processing) దరఖాస్తు
యొక్క క్విక్ రికప్(
quick recap) తీసుకుంటాము.
మేము సి లో ఒక కొత్త
పరిష్కారం ప్రవేశపెడుతుంది
మరియు ఆ మేము పంపించు
కోసం వర్చ్యువల్

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

Hindi: 
है या बाध्यकारी
की इस पद्धति को डायनामिक(dynamic)
बाइंडिंग(binding) के रूप
में जाना जाता है
जैसा कि हमने देखा
है, और इस पूरी चीज
को C ++ में पॉलीमोर्फिक(polymorphic)
डिस्पैच के रूप में
जाना जाता है।
हमने पॉलीमोर्फिक(polymorphic)
डिस्पैच मैकेनिज्म
को देखा है और हमने
इसका इस्तेमाल स्टाफ
सैलरी प्रोसेसिंग
के समाधान को तैयार
करने में बड़े पैमाने

Telugu: 
ఫంక్షన్ పట్టిక అర్థం
చేసుకోవడానికి ఇంసైట్
(insight)ఇస్తుంది ఎలా
చూపిస్తుంది.
కాబట్టి ఇది సమస్య,
వేరొక రకము ఉద్యోగులందరికీ
సాలెరి ప్రాసెస్(salary
process)చేయబడాలని మరియు
వారి వేతన ప్రాసెసింగ్
అల్గోరిథంలు( processing
algorithm) అల్గొర్భిన్నమైనవి
అని మేము అనుకున్నాము.
మరియు మొత్తం డిజైన్
యొక్క ఆయువుపట్టే
డిజైన్ తగిన విస్తృతమైన
ఉండాలి వాస్తవం.
అది చేయాలని మేము
కోరుకున్నప్పుడు,
అధికార వర్గంకు కొత్త
క్లాస్లను(class) చేర్చడం
సాధ్యమవుతుంది.
C లో, మేము ఈ పరిశీలనలను
తీసుకున్నాము మరియు
మీరు ఎల్లప్పుడూ
మాడ్యూల్ను సూచించవచ్చు,
వాటిని మాడ్యూల్
నంబర్ కూడా కలిగి
ఉంటుంది మరియు డిజైన్
పరిగణనలపై ఏమైనా
తనిఖీ చేయండి.

English: 
the time of processing the record of every
employee we checked on what is the type maintaining
that in a union and then based on the type
we call the appropriate salary processing
function. Now we would try to look at the
same solution with a little bit of different
flavor using function pointers. The main differences
that I would highlight; certainly the explicit
maintenance of types stills remains.
I am just assuming that there are three types;
engineer, manager, and director. Earlier if
you recall you may open up the earlier video
or presentation to check that the salary processing
routines, say the salary processing for the
engineer was taking a pointer to engineer.
Salary processing for manager was taking a
pointer to manager, and salary processing
to the of directive was taking a pointer to

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

Hindi: 
पर किया है। मॉड्यूल(module)
में, आज हम वर्चुअल(virtual)
फंक्शन(function) टेबल(table)
के बारे में चर्चा
करेंगे, यह है कि हम
इस पॉलीमोर्फिक(polymorphic)
प्रेषण के संदर्भ
में थोड़ी समझ लेना
चाहेंगे; वास्तव
में संकलक द्वारा
कार्यान्वित किया
गया। क्योंकि आपको
यह याद रखना होगा
कि कोड प्रक्रिया
के समय संकलक स्थिर
समय पर काम करता है;

Telugu: 
ఇప్పుడు, మనం పరిష్కారం
గురించి చర్చించినప్పుడు
మనం ఫంక్షన్ స్విచ్(function
switch) యొక్క యాంత్రిక
విధానాన్ని ఉపయోగించాము,
ఇది మేము ప్రత్యేకంగా
నిర్వహించబడుతున్న
టైప్(type)మరియు ప్రతి
ఉద్యోగి యొక్క రికార్డును
ప్రాసెస్ చేస్తున్న
సమయంలో మేము ఏ యూనియన్లో(unions)
మరియు దాని ఆధారంగా
మేము తగిన సాలెరి
ప్రాసెసింగ్ ఫంక్షన్
(salary processing function) అని పిలుస్తాము.
ఇప్పుడు మనం అదే
పరిష్కారాన్ని చూద్దాం,
వేరే రుచిని కొద్దిగా
ఫంక్షన్ పాయింటర్లను(
function pointers) ఉపయోగించి
చూస్తాము. ప్రధాన
తేడాలు, నేను హైలైట్
చేస్తుంది; ఖచ్చితంగా
రకాల స్టిల్స్ నిర్వహణ
ఇప్పటికీ ఉంది.
నేను మూడు రకాలు

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

English: 
director. Now I have changed it a little bit
all of them now take a void star pointer,
because I want all of these functions to have
the same signature.
Once we get it as void star naturally we do
not know the void star does not tell me what
type of object it is, but since I know the
salary processing for engineer has been invoked
I know that void star pointer actually points
to an engineer record so I cast it to the
engineer. Or if it is a manager function called
I cast it to manager or director function
called I cast it to director and then do the
processing. I can still manage without actually
explicitly having different parameter types
here. But in this process what a gain is all
this functions now have the same signature.
Since they have the same signature I can try
to combine them in terms of a uniform function
pointer type which I say is a ptr is a function

Hindi: 
स्रोत को उस समय संसाधित
किया जा रहा है जिसमें
कोई निष्पादन नहीं
हो रहा है।
इसलिए, संकलक के पास
रनटाइम पर दिए गए
संकेतक के रूप में
जानने का कोई तरीका
नहीं है जो कि उस वस्तु
का प्रकार है जिसे
वह वास्तव में इंगित
करेगा, लेकिन फिर
भी उसे एक कोड उत्पन्न
करना होगा जो निष्पादन

English: 
pointer which takes a void star and does not
written anything. Note this is a function
pointer so this basically is a function pointer
type this is not a function itself. We will
define function.
So, any of this functions for engineer for
manager or for the director will actually
match with this function pointer type. Rest
of the design remain same the different structure
types to define different types of objects
and with this let us see how do we actually
combine the whole thing into the application.
In terms of the application what we do is,
we now maintain a record where on one it say it is basically a doublet this is where
I keep the type which would be something like Er or Mgr and so on. The other is a pointer

Telugu: 
ఉన్నాయి అని ఊహిస్తున్నాను;
ఇంజనీర్, మేనేజర్,
మరియు దర్శకుడు.
మీరు గనక గుర్తు
చేసుకుంటే అంతకుముందు
వీడియో లేదా ప్రదర్శనను
సాలెరి ప్రాసెసింగ్
(salary processing)నిరంతరాయంగా
తెరిచేందుకు, ఇంజనీర్కు
సాలెరి ప్రాసెసింగ్
(salary processing)ఇంజనీర్కు
పాయింటర్ తీసుకుంటున్నారని
చెప్పండి. నిర్వాహకుడికి
వేతన ప్రాసెసింగ్
నిర్వాహకుడికి ఒక
పాయింటర్ తీసుకొని,
డైరెక్టర్ కి సాలెరి
ప్రాసెసింగ్ దర్శకుడికి
ఒక పాయింటర్(pointer) తీసుకుంటున్నారు.
ఇప్పుడు నేను వాటిని
మార్చాను ఇప్పుడు
వాటిని అన్ని ఇప్పుడు
ఒక శూన్య స్టార్
పాయింటర్(star pointer) తీసుకోండి,
ఎందుకంటే నేను ఈ
విధులు అన్ని ఒకే
సంతకం కలిగి ఉండాలనుకుంటున్నాను.
ఒకసారి మేము సహజంగా
శూన్యమైన నక్షత్రం
గా పొందండి, శూన్యమైన

Hindi: 
के दौरान डायनामिक(dynamic)
प्रकार के अनुसार
काम करेगा।
यह वर्चुअल(virtual) फंक्शन(function)
टेबल(table) के उपयोग
के माध्यम से किया
जाता है, जो कि पॉलिमरइक
प्रेषण के लिए महत्वपूर्ण
है। इसके लिए हम चर्चा
कर रहे वेतन प्रसंस्करण
आवेदन का एक त्वरित
पुनरावर्तन लेंगे।
हम सी में एक नया समाधान
पेश करेंगे और यह

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

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

English: 
of void star that is this is a pointer of
some kind. Now what we do? We populate an
array of function pointer. So this is an array
of function pointer. I have already defined
a function pointer type. So this is an array
of function pointers 0 1 and 2, and in each
one of these we actually assign three different
functions that we have written for the three
different structure types.
These have three different function pointers
actually deciding in the array. Then you populate
the collection of objects, so collection of
objects is the object type and the object
instance. It is a pointer to the object instance
so in place of void star this will now have.
If I look into this array this is like doublet,

Telugu: 
నక్షత్రం నాకు ఏ
విధమైన ఆబ్జెక్ట్
లేదు అని నాకు తెలియదు,
కానీ నేను ఇంజనీర్కు
సాలెరి ప్రాసెసింగ్(salary
processing)చేయబడిందని
నాకు తెలుసు ఎందుకంటే
శూన్య స్టార్ పాయింటర్(star
pointer) వాస్తవానికి
ఒక ఇంజనీర్ రికార్డును
సూచిస్తుంది, కనుక
దానిని ఇంజనీర్కు
తారాగణం. లేదా మేనేజర్
ఫంక్షన్(manager function) అని
నేను మేనేజర్ లేదా
డైరెక్టర్ ఫంక్షన్కు
పిలుస్తాను, దర్శకుడికి
దానిని తారాగణం చేసి
ప్రాసెసింగ్ చేస్తాను.
నేను ఇప్పటికీ స్పష్టంగా
లేకుండా వివిధ పరామితి
రకాలను కలిగి లేకుండా
నిర్వహించవచ్చు.
కానీ ఈ ప్రక్రియలో
ఏమి లాభం ఉంది; ఈ విధులు
ఇప్పుడు ఒకే సంతకం
కలిగివున్నాయి.
ఒకే సంతకం ఉన్నందున

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

Telugu: 
నేను ఒక ఏకరీతి ఫంక్షన్
పాయింటర్(function pointer)
టైప్లో( type) వాటిని
మిళితం చేసేందుకు
ప్రయత్నించవచ్చు,
ఇది ఒక Ptr అనేది ఒక
ఫంక్షన్ పాయింటర్(function
pointer) అని మరియు ఇది
ఒక శూన్య నక్షత్రం
పడుతుంది మరియు ఏదైనా
రాయలేదు. ఇది ఫంక్షన్
పాయింటర్ కాబట్టి
గమనించండి, ఇది ప్రాథమికంగా
ఫంక్షన్ పాయింటర్
టైప్(function pointer type). ఇది
ఒక ఫంక్షన్ కాదు.
మేము ఫంక్షన్ను నిర్వచిస్తాము.
కాబట్టి, మేనేజర్
కోసం లేదా దర్శకుడి
కోసం ఇంజనీర్ కోసం
ఈ ఫంక్షన్లు వాస్తవానికి
ఈ ఫంక్షన్ పాయింటర్
రకంతో సరిపోతాయి.
డిజైన్ యొక్క మిగిలినవి
ఒకే రకంగా ఉంటాయి,
వేర్వేరు రకాల ఆబ్జెక్ట్లని

English: 
so I have Er then an Er object, I have Mgr,
I have a manager object and so on. So we will
have in this way there are six different of
them. This stuff is my total collection.
Now, when I want to process that I will go
over a loop and this is what is critical is
I will use this function pointer array and
using the type of i-th staff. Say if i is
0 when the type is Er. I will pick up from
this function pointer array that is this array,
I will index it by this type which is Er that
means 0 and then we will call that function.
So, this p s array if I just use a different
color, say this particular one is a function

Hindi: 
को उचित रूप से एक्स्टेंसिबल
होना चाहिए। जब हम
ऐसा करना चाहते हैं,
तो नए वर्गों को पदानुक्रम(hierarchy)
में जोड़ना संभव
होना चाहिए।
सी में, हमने इस पर
विचार किया था और
आप हमेशा पहले वाले
मॉड्यूल(module) का उल्लेख
कर सकते हैं, उन्हें
संदर्भित कर सकते
हैं कि उनके पास मॉड्यूल(module)
संख्या भी है और डिज़ाइन

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

Hindi: 
के विचार क्या हैं।
अब, जब हमने उस समाधान
पर चर्चा की, जिसमें
हमने एक फंक्शन(function)
स्विच के तंत्र का
उपयोग किया था, तो
क्या हम स्पष्ट रूप
से उस प्रकार को बनाए
रखते हैं और हर कर्मचारी
के रिकॉर्ड को संसाधित
करते समय हमने यह
जांचा है कि एक संघ

Telugu: 
(object) నిర్వచించేందుకు
వివిధ రకాల నిర్మాణాలు
ఉంటాయి మరియు దీనితో
మనం ఎలా పూర్తిగా
అప్లికేషన్ మొత్తంలోకి
కంబైన్ (combine) చేయాలో
చూద్దాం.
అప్లికేషన్ యొక్క
పరంగా మేము ఏమి చేస్తున్నామో,
ఇప్పుడు మనము ఒక
రికార్డును కొనసాగించాము,
అది ఎర్రటి లేదా
Mgr లాంటిదిగా ఉంటున్న
టైప్( type) ఉంచుతూ, ఇది
ప్రాథమికంగా ఒక డబుల్.
మరొకటి ఇది శూన్యమైన
స్టార్ యొక్క పాయింటర్,
ఇది ఒక రకమైన పాయింటర్.
ఇప్పుడు మేము ఏమి
చేస్తాము? మేము ఫంక్షన్
పాయింటర్(function pointer)
యొక్క ఆర్రే (array) జనసాంద్రత
చేస్తాము. కాబట్టి
ఇది ఫంక్షన్ పాయింటర్

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

English: 
pointer, because p s array is this array.
I have index it with the stuff i dot type
which is Er in this case, the first one is
an engineer. So what I get is a function pointer
which is a function of this is the type of
function, it takes a void star and the function
is called. And what it passes is the second
parameter here which is staff i dot p the
pointer to the object.
When I call it with Er here, so I have got
this function that is process salary engineer
this will get called by the engineer record,
that is this will get called with the in it
engineer that have done with the Rohit. When

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

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

Telugu: 
యొక్క ఆర్రే(array). నేను
ఇప్పటికే ఫంక్షన్
పాయింటర్ టైప్న్ని(pointer
type) నిర్వచించాను.
కాబట్టి ఇది 0, 1 మరియు
2 యొక్క ఫంక్షన్ పాయింటర్ల
ఆర్రే (array), వీటిలో
ప్రతి ఒక్కటి మనకు
మూడు వేర్వేరు విధులను
కేటాయించాము.
వీటికి మూడు వేర్వేరు
ఫంక్షన్ పాయింటర్లు
వాస్తవానికి అర్రేలో
నిర్ణయించబడతాయి.
అప్పుడు మీరు ఆబ్జెక్ట్
(object)సేకరణను జనసాంద్రత
చేస్తారు, కాబట్టి
ఆబ్జెక్ట్స objects సేకరణ
ఆబ్జెక్ట్ రకం మరియు
వస్తువు ఉదాహరణ.
ఇది ఇప్పుడు కలిగి
ఉంటుంది శూన్య స్టార్
స్థానంలో కాబట్టి
ఆబ్జెక్ట్ ఉదాహరణకు
ఒక పాయింటర్ ఉంది.
నేను ఈ ఆర్రేని చూస్తే

English: 
i becomes 1 I get the second record where
I have the type as Mgr and which is 1, so
I get the second function pointer and I invoke
it with the pointer to the corresponding employee
which is the manager record. In this way one
after the other all of this functions will
get called with the appropriate type with
the appropriate employee record and once we
are inside the record we have already seen
that if the engineer function has been invoked
and I have got a to the pointer to the engineer
record here then I will cast and execute that.
This is the basic style of doing this. The
change that we have made is we have made this

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

English: 
whole thing into array of function pointers
here and we are invoking them through a simple
code. And we do not any more need the switch
conditional switch that we had been doing
all that is taken care of by the indexing
in this function pointer array. This could
be another solution in C which is a smart
solution in C which will be very useful.
.
If we just quickly compare it with the polymeric
C++ solution this was basic approach to the
solution and this was a solution.
If you look at then you will see that we have
all the same things the destructor, the constructor,
the different overridden process salary functions
and so on.
.
And with that

Hindi: 
मैं सिर्फ यह मान
रहा हूं कि तीन प्रकार
हैं; इंजीनियर(engineer),
प्रबंधक(manager) और निदेशक(director)।
इससे पहले कि आप याद
करते हैं कि आप वेतन
प्रसंस्करण दिनचर्या
को जांचने के लिए
पहले वाला वीडियो
या प्रस्तुति खोल
सकते हैं, कहते हैं
कि इंजीनियर(engineer)
के लिए वेतन प्रसंस्करण
इंजीनियर(engineer) के
लिए एक संकेतक ले
रहा था। प्रबंधक(manager)

Telugu: 
ఇది ద్వంద్వ లాగా
ఉంటుంది, కనుక ఎర్
అప్పుడు ఒక ఎర్ ఆబ్జెక్ట్
ఉంటుంది, నేను Mgr ను
కలిగి ఉన్నాను, నేను
మేనేజర్ ఆబ్జెక్ట్
కలిగి ఉన్నాను. కాబట్టి
మేము ఈ విధంగా ఉంటుంది,
వీటిలో ఆరు విభిన్న
అంశాలు ఉన్నాయి.
ఈ విషయం నా మొత్తం
సేకరణ.
ఇప్పుడు, నేను ప్రాసెస్
చేయాలనుకుంటున్నాను
నేను లూప్(loop) మీద
వెళ్తాను మరియు ఇది
క్లిష్టమైనది ఏమిటంటే
నేను ఈ ఫంక్షన్ పాయింటర్
ఆర్రేని(array) ఉపయోగిస్తాను
మరియు i- వ సిబ్బంది
యొక్క టైప్న్ని (type)
ఉపయోగిస్తాను. రకం
Er అయితే నేను 0 అయితే
చెప్పండి. నేను ఈ

English: 
if we look at our code is simply for loop
with this call being made. Where this each
and every one of this is a pointer to the
engineer type and depending upon the polymeric
dispatch it will call the appropriate salary
process function.
If we compare this to side by side this is
just comparing the design features.
But if we just compare this to solution side
by side you will see that this is the C solution
this is the corresponding C++ class. So, you
have the in it engineer, you have the constructor
here, you have this particular processing
function, you have the over load member function
which is a polymorphic in nature. Similarly,
I have for the next type the director type
and these are three classes that we have.

Hindi: 
के लिए वेतन प्रसंस्करण
प्रबंधक(manager) के लिए
एक संकेतक ले रहा
था, और निदेशक(director)
को वेतन प्रसंस्करण
निदेशक(director) के लिए
एक संकेतक ले रहा
था। अब मैंने इसे
थोड़ा बदल दिया है,
अब सभी एक वोईद(void)
स्टार पॉइंटर(pointer)
लेते हैं, क्योंकि
मैं चाहता हूं कि
इन सभी कार्यों में
एक ही हस्ताक्षर
हो।

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

Telugu: 
ఫంక్షన్ పాయింటర్
అర్రే నుండి ఎంచుకుంటాను
ఈ శ్రేణి, నేను ఈ రకమైన
ఇండెక్స్(index) చేస్తాను
అది 0 అని అర్ధం మరియు
ఆ ఫంక్షన్ అని పిలుస్తాము.
సో, ఈ psArray నేను వేరే
రంగు ఉపయోగిస్తే,
ఈ ప్రత్యేక ఒక ఫంక్షన్
పాయింటర్ చెప్పటానికి,
ఎందుకంటే psArray ఈ ఆర్రే.
నేను ఈ విషయంలో ఎర్టిగా
ఉన్న విషయం i dot రకంతో
ఇండెక్స్( index) చేశాను,
మొదటిది ఒక ఇంజనీర్.
నేను ఏమి ఒక ఫంక్షన్
పాయింటర్ ఇది ఫంక్షన్
యొక్క రకం ఇది ఫంక్షన్
రకం, అది ఒక వోయిడ్
స్టార్( void star) పడుతుంది

Hindi: 
एक बार जब हम इसे स्वाभाविक
रूप से वोईद(void) तारा
के रूप में प्राप्त
करते हैं, तो वोईद(void)
तारा मुझे यह नहीं
बताता है कि यह किस
प्रकार की वस्तु
है, लेकिन जब से मुझे
पता है कि इंजीनियर(engineer)
के लिए वेतन प्रसंस्करण
का आह्वान किया गया
है, मुझे पता है कि
वोईद(void) सितारा सूचक
वास्तव में एक इंजीनियर(engineer)

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

Telugu: 
మరియు ఫంక్షన్ అంటారు.
మరియు ఇది పాస్ అయిన
రెండవ పరామితి, ఇది
సిబ్బంది [i] .p; ఆబ్జెక్ట్
పాయింటర్.
నేను ఇక్కడ Er తో పిలుస్తాను,
కాబట్టి ఈ పనిని
పొందాను ప్రక్రియ
సాలెరి ఇంజనీర్ ఈ
ఇంజనీర్ రికార్డు
చేత పిలువబడుతుంది,
ఇది రోహిత్తో చేసిన
ఇంజనీర్తో ఈ విధంగా
పిలువబడుతుంది. నేను
1 గా మారినప్పుడు,
నేను రెండో రికార్డును
కలిగి ఉంటాను, అక్కడ
నేను Mgr మరియు ఇది
1 గా ఉంటుంది, కాబట్టి
నేను రెండవ ఫంక్షన్
పాయింటర్ ను పొందండి
మరియు మేనేజర్ రికార్డు
అయిన సంబంధిత ఉద్యోగికి
పాయింటర్తో నేను
దాన్ని పిలుస్తాను.
ఈ విధముగా, ఈ విధులు

English: 
Now, if we look at the processing part see
how similar this two processing look like.
So here I take the pointer to that object
and based on the dynamic type I dispatch to
any one of this functions depending on its
corresponding type. Here we do the same thing
using the array p s array which is the array
of the function pointers that can be used.
The only difference is I need to explicitly
maintain the type and the relationship between
the type and the particular object that I
am using.
So based on the type I pick up the function
and then for that particularly the second
part tells me what is the object pointer and
we pass the object pointer. So, here I do
not need to do that because as we know all
that we need is to basically pick up the right

Telugu: 
అన్ని తరువాత తగిన
ఉద్యోగి రికార్డుతో
సరైన రకముతో పిలువబడతాయి
మరియు ఒకసారి మనము
రికార్డు లోపల ఉన్నాము,
ఇంజనీర్ ఫంక్షన్
ప్రారంభించబడినట్లయితే
నేను పాయింటర్(pointer)
ఇంజనీర్ రికార్డుకు
ఇక్కడ నేను తారాగణం
మరియు అమలు చేస్తాను.
ఈ చేయడం యొక్క ప్రాథమిక
శైలి. మేము చేసిన
మార్పు; మేము ఈ మొత్తం
పనిని ఇక్కడ ఫంక్షన్
పాయింటర్ల ఆర్రేలోకి
(array) తీసుకున్నాము
మరియు మేము వాటిని
ఒక సాధారణ కోడ్ ద్వారా
ప్రేరేపించాము. మరియు
మనం స్విచ్(switch) అవసరం
లేదు; నియమబద్ధమైన
స్విచ్ మేము చేస్తున్న
అన్ని చర్యలను చేస్తున్నది
ఈ ఫంక్షన్ పాయింటర్
ఆర్రేలో array ఇండెక్సింగ్

Hindi: 
रिकॉर्ड को इंगित
करता है, इसलिए मैं
इसे इंजीनियर(engineer)
को दिया। या अगर यह
एक प्रबंधक(manager) फ़ंक्शन(function)
है, जिसे मैंने इसे
प्रबंधक(manager) या निर्देशक
फ़ंक्शन(function) को कॉल
किया है, जिसे मैंने
इसे निर्देशक को
दिया है और फिर प्रसंस्करण
करना है। मैं अभी
भी स्पष्ट रूप से
अलग-अलग पैरामीटर
प्रकारों के बिना
यहां प्रबंधन कर

English: 
type, the object pointer implicit as this
pointer and that will work. The reason I show
you this example or show you this way doing
it in using function pointer in C is a fact
that this is how actually in reality the C++
compiler takes care of the virtual functions
or the polymorphic function.
.
So to bring it to the actual details, suppose
I have a base class B, so I have for this
base class I have two functions; one is function
f and this function g. Which are one is of
polymeric type g is polymorphic type, f is
a non polymorphic type, it is a non-virtual
function. And based on the this base class

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

English: 
I have a derived class here which over writes
the non-polymorphic function as well as the
polymorphic function.
Now, what you do in this case is? For a non-polymorphic
function let us say if we just talk about
the function f which is non-polymorphic in
nature, so how will the invocations look like?
Suppose if I do sample b dot f which is directly
accessing it with object. So, how will the
compiler call it? Compiler will knows from
the fact that b is a class B type of object
the compiler knows that there is a function
f so that is been called. So, it calls b colon-colon
f which is this function, and what is required?
It requires this pointer which is the address
of b, so it puts the address of b and it puts
the parameter. So, it puts the address of
b here and the parameter and this will get
called. This is a static binding; this is
a simple static binding.

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

Hindi: 
सकता हूं। लेकिन
इस प्रक्रिया में
एक लाभ क्या है; इस
सभी कार्यों में
अब एक ही हस्ताक्षर
है।
चूंकि उनके पास एक
ही हस्ताक्षर है
मैं उन्हें एक समान
फ़ंक्शन(function) पॉइंटर(pointer)
प्रकार के संदर्भ
में संयोजित करने
का प्रयास कर सकता
हूं जो मैं कहता हूं
कि एक ptr एक फ़ंक्शन(function)
पॉइंटर(pointer) है जो

Telugu: 
చేత తీసుకోబడింది.
ఈ సి లో ఒక పరిష్కారం
మరొక పరిష్కారం కావచ్చు,
ఇది చాలా ఉపయోగకరంగా
ఉంటుంది.
మేము త్వరగా పాలిమర్
సి ++ పరిష్కారంతో
దాన్ని పోల్చి ఉంటే,
ఇది పరిష్కారంకు
ప్రాథమిక పద్ధతి.
మీరు చూస్తే అప్పుడు
మేము అన్నింటిని
కలిగి ఉన్న డిస్ట్రాక్టర్
(destructor), కన్స్ట్రాక్టర్
(constructor), విభిన్న భర్తీ
ప్రక్రియ సాలెరి
ఫంక్షన్స్ (salary functions)
మరియు మొదలైనవి ఉన్నాయని
మీరు చూస్తారు.
మరియు ఆ తో మేము చూడండి
ఉంటే, మా కోడ్ కేవలం
లూప్ కోసం ఉంది ఈ
కాల్ చేస్తున్నారు.
వీటిలో ప్రతి ఒక్కటి
ఇంజనీర్ టైప్కి పాయింటర్
మరియు పాలిమెరిక్
డిస్పాచ్పై(polymorphic
dispatch) ఆధారపడి, తగిన
ప్రక్రియ కాల్ చేస్తుంది.
మనము దీనిని పక్కపక్కనే

Hindi: 
एक वोईद(void) तारा लेता
है और कुछ भी नहीं
लिखा है। ध्यान दें
कि यह एक फ़ंक्शन(function)
पॉइंटर(pointer) है, इसलिए
यह मूल रूप से एक फ़ंक्शन(function)
पॉइंटर(pointer) प्रकार
है। यह एक कार्य नहीं
है। हम फ़ंक्शन(function)
को परिभाषित करेंगे।
तो, प्रबंधक(manager) के
लिए या निर्देशक
के लिए इंजीनियर(engineer)
के लिए यह कोई भी कार्य

English: 
If I do that using a pointer I get the same
thing doing it with a pointer. So, if I am
calling this then from the type of the pointer
which is of b type it knows that it has to
look in the b class we have seen this before
and in the b class it has f function which
is non-virtual, so it will directly have to
call that function. So, it is statically puts
b colon-colon f passes the pointer value and
the parameter. These are the static ways this
is absolutely fine.
Now, let us look at a third invocation also
where I am using the object and calling the
non-virtual function g. Again the compiler
does the same thing. We know that if we call
it with the object it is the function of that
class which will get called, so b colon-colon
g is what we called. Address of b is passed
here and the parameter is passed here. So,
up to this point for these three all of these

Telugu: 
పోల్చినట్లయితే
ఇది కేవలం డిసైన్
ఫీచర్స్(design features) పోల్చి
చూస్తుంది.
కానీ మనము దీనిని
పరిష్కారం వైపున
పోల్చినట్లయితే,
మీరు ఈ C సి ++ క్లాస్
అని తెలుసుకుంటారు.
కాబట్టి, మీరు దానిని
ఇంజనీర్లో కలిగి
ఉన్నారు, మీరు ఇక్కడ
కన్స్ట్రక్టర్ను(constructor)
కలిగి ఉన్నారు, మీరు
ఈ ప్రత్యేక ప్రాసెసింగ్
ఫంక్షన్ కలిగి ఉన్నారు,
మీరు లోడర్ సభ్యుల
ఫంక్షన్ కలిగివున్నారు,
ఇది స్వభావంలో పాలిమార్ఫిక్
అవుతుంది. అదేవిధంగా,
నేను తరువాతి టైప్
డైరెక్టర్ (type director)రకం
కోసం కలిగి మరియు
ఈ మేము కలిగి మూడు
క్లాస్సెస్ (classes )ఉన్నాయి.
ఇప్పుడు, మేము ప్రాసెసింగ్
పార్ట్ ను చూస్తే,
ఈ రెండు ప్రాసెసింగ్
లాగా ఎలా ఉంటుందో
చూడండి. ఇక్కడ నేను

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

Hindi: 
वास्तव में इस फ़ंक्शन(function)
पॉइंटर(pointer) प्रकार
के साथ मेल खाएगा।
बाकी डिज़ाइन समान
हैं, विभिन्न संरचनाएं
विभिन्न प्रकार की
वस्तुओं को परिभाषित
करने के लिए हैं और
इसके साथ ही देखते
हैं कि हम वास्तव
में पूरी चीज़ को
किस तरह से अनुप्रयोग
में मिलाते हैं।
आवेदन के संदर्भ

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

English: 
are basically static binding. So, if I instead
of b if I have a derive class object d and
I try to do this for the derive class object
I will have similar static binding code here,
where in each one of these the compiler knows
that the type is d and whether it is directly
by the object or it is through a pointer,
but the function is a non virtual one so it
will put the static calls.
The issue arrives when I want to actually
look at calling something like p pointer g,
that is I am a calling virtual function and
I am using a pointer so this is where I need
the dynamic binding. I am calling p pointer

Telugu: 
ఆ ఆబ్జెక్ట్కు పాయింటర్ను(object
pointer) తీసుకొని డైనమిక్
టైప్న్ని బట్టి నేను
ఈ విధమైన వాటికి
దాని సంబంధిత రకాన్ని
బట్టి పంపించాను.
ఇక్కడ మేము ఆర్రేకి
array psArray ను ఉపయోగించి
ఇదే పని చేస్తాము,
ఇది ఫంక్షన్ పాయింటర్
యొక్క ఆర్రే (array). మాత్రమే
తేడా నేను టైప్ మరియు
నేను ఉపయోగించే నేను
ప్రత్యేక ఆబ్జెక్ట్
(object) మధ్య సంబంధం మరియు
సంబంధం నిర్వహించడానికి
అవసరం ఉంది. కాబట్టి
నేను ఆధారంగా ఫంక్షన్
ఎంచుకొని ఆపై ముఖ్యంగా
రెండవ భాగం నాకు
చెబుతుంది ఆబ్జెక్ట్
పాయింటర్( object pointer)
మరియు మేము ఆబ్జెక్ట్
పాయింటర్ పాస్. కాబట్టి,

English: 
g, I am using a pointer and I am using a virtual
function. In this case the p is a pointer
to a b object, in the case on right hand side
b is pointer to the d object. So, what I will
need here? I will need here that p this call
will actually resolve to this function.
Whereas I will need that in this case this
call will resolve to this function. Even though
both of this calls at the call site looks
same. How do I do that? how do I make that
change? So what I do is something very very
simple. Think about the layout of the object,
the object has a data member i, so I have
a data member i this was constructed with
hundred. So, I have a data member i b colon-colon
i which is the field here.
Similarly, if I look at the derive class object,
it has added a data member j so it will have

Telugu: 
ఇక్కడ నేను అలా చేయవలసిన
అవసరం లేదు ఎందుకంటే
మనకు అవసరమైనది ప్రాథమికంగా
సరైన రకాన్ని ఎంచుకుంటుంది,
ఈ పాయింటర్ వలె ఆబ్జెక్ట్
పాయింటర్ అవ్యక్తంగా
పని చేస్తుంది. నేను
మీకు ఈ ఉదాహరణను
చూపించాను లేదా C
లో ఫంక్షన్ పాయింటర్ను(
function pointer) ఉపయోగించడంలో
దీనిని మీకు చూపించడానికి
కారణం వాస్తవానికి
C ++ కంపైలర్ (compiler)వర్చువల్
ఫంక్షన్లను(virtual function)
లేదా పాలిమార్ఫిక్
ఫంక్షన్(polymorphic function)
యొక్క జాగ్రత్తను
తీసుకుంటుంది.
కాబట్టి అసలు వివరాలను
తీసుకురావాలంటే,
నాకు ప్రాథమిక క్లాస్
(class)B ఉందని అనుకుందాం,
ఈ బేస్ క్లాస్ కోసం

Hindi: 
में, हम क्या करते
हैं, हम अब एक रिकॉर्ड
बनाए रखते हैं, जहां
एक पर, यह कहता है,
यह मूल रूप से एक संदेह
है कि यह वह जगह है
जहां मैं उस प्रकार
को रखता हूं, जो Er या
Mgr और ऐसा ही कुछ होगा।
दूसरा वोईद(void) तारा
का सूचक है जो कि किसी
प्रकार का सूचक है।

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

Hindi: 
अब हम क्या करें? हम
फ़ंक्शन(function) पॉइंटर(pointer)
की एक सरणी पॉप्युलेट
करते हैं। तो यह एक
प्रकार का फ़ंक्शन(function)
पॉइंटर(pointer) है। मैंने
पहले से ही एक फ़ंक्शन(function)
पॉइंटर(pointer) प्रकार
को परिभाषित किया
है। तो यह फ़ंक्शन(function)
पॉइंटस 0, 1 और 2 का एक
सरणी है, और इनमें
से प्रत्येक में
हम वास्तव में तीन

Telugu: 
నేను రెండు ఫంక్షన్స్
కలిగి ఉన్నాను; ఒకటి
ఫంక్షన్ f మరియు ఈ
ఫంక్షన్ g. ఏవేవి;
పాలీమెరిక్ టైప్
(type) g అనేది పాలిమార్ఫిక్
రకం, f అనేది నాన్-పాలిమార్ఫిక్
టైప్ను( non polymorphic type),
ఇది వర్చ్యువల్ కాని
ఫంక్షన్. మరియు ఈ
బేస్ క్లాస్ ఆధారంగా
నేను ఇక్కడ ఉత్పన్నమైన
క్లాస్ని కలిగి ఉన్నాను,
ఇది పాలిమార్ఫిక్
ఫంక్షన్ అలాగే పాలిమార్ఫిక్
ఫంక్షన్ను వ్రాస్తుంది.
ఇప్పుడు, మీరు ఈ విషయంలో
ఏమి చేస్తారు? ఒక
non-polymorphic ఫంక్షన్ కోసం
మేము కేవలం ప్రకృతిలో
కాని పాలిమార్ఫిక్
ఇది ఫంక్షన్ f గురించి
మాట్లాడటానికి ఉంటే
మాకు తెలియజేయండి,

English: 
one base class part which is 200 and the additional
data member that has added which is 500. So
these are point. Now what we do is we add
one more field, this is invisible field we
add one more filed to the object.
This field is a pointer filed and what does
it point to, it points to a table of function
pointers and this table is known as the VFT
or the Virtual Function Table. So what it
does is, when say I am in class b and I am
trying to look at the codes, I have a virtual
function pointer and I have one virtual function.
So I put that virtual function in this table
that is I put this pointer in this table.

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

Telugu: 
కాబట్టి ఎలాఓక్ వంటివా?
నేను నమూనా b చేస్తే
అనుకుందాం. f()ఆబ్జెక్ట్
తో (object) నేరుగా యాక్సెస్
చేస్తున్నది. కాబట్టి,
కంపైలర్( compiler) ఎలా
పిలవాలి? కంపైలర్
B అనేది ఒక క్లాస్
B టైప్ ఆబ్జెక్ట్
అని తెలుసుకుంటుంది,
కంపైలర్ ఒక ఫంక్షన్
f అని పిలవబడుతుందని
తెలుసు. కాబట్టి,
ఈ ఫంక్షన్ ఇది బి
కోలన్-కోలన్ f పిలుస్తుంది,
మరియు ఏది అవసరం?
ఇది b యొక్క చిరునామా
ఇది ఈ పాయింటర్ అవసరం,
కాబట్టి ఇది బి యొక్క
చిరునామా ఉంచుతుంది
మరియు అది పారామితి
ఉంచుతుంది. కాబట్టి,
ఇది ఇక్కడ b మరియు
పరామితి యొక్క చిరునామాను
ఉంచుతుంది మరియు
ఇది అంటారు. ఇది స్టాటిక్

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

English: 
And whenever I will get a call for this function
g this virtual function g through a pointer
I will not generate a code like this, I will
not generate this static code rather I will
generate a code like this. Do not get confused
with this syntax, what is being said? P is
a pointer. So p is a pointer, so p points
here.
What is p pointer VFT? P pointer VFT is a
pointed to this table. And if p pointer VFT
is pointed to this table p pointer VFT 0 is
a 0th entry of this table, and what is that
entry? That entry is a function pointer. So,
p pointer VFT 0 is

Hindi: 
अलग-अलग फ़ंक्शन(function)
असाइन करते हैं जो
हमने तीन अलग-अलग
संरचना प्रकारों
के लिए लिखे हैं।
ये वास्तव में सरणी
में निर्णय लेने
वाले तीन अलग-अलग
फ़ंक्शन(function) पॉइंटर्स(pointers)
हैं। फिर आप ऑब्जेक्ट्स(objects)
के संग्रह को पॉप्युलेट
करते हैं, इसलिए ऑब्जेक्ट्स
का संग्रह ऑब्जेक्ट(object)
प्रकार और ऑब्जेक्ट(object)
इंस्टेंस है। यह
ऑब्जेक्ट(object) उदाहरण
के लिए एक संकेतक
है ताकि वोईद(void) तारा

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

English: 
this 0th function pointer in the table. So,
I say that whenever you get p pointer g you
actually call whatever function exists in
this location. So you pick up this function
and call it with the parameters, with parameters
up to with this pointer which is p and the
actual parameter value which is 45.
The compiler knowing that this is a virtual
function and knowing that this is been called through a pointer does not generate the static
time code like, hard codes the function, but
it puts the call as if through the virtual
function table. How does that help? The way
it helps is now you have one level of in direction.
So what happens is, when you have specialize
this class b into class d and you construct

Telugu: 
బైండింగ్( static binding);
ఇది సాధారణ స్టాటిక్
బైండింగ్.
నేను ఒక పాయింటర్
ఉపయోగించి ఉంటే నేను
ఒక పాయింటర్(pointer) తో
చేయడం ఇదే పొందండి.
కాబట్టి, నేను దీనిని
కాల్ చేస్తున్నట్లయితే,
ఇది బి రకం అని సూచిస్తుంది,
అది బి క్లాస్లో
కనిపించవలసి ఉందని
మనకు ముందుగానే చూసినట్లు
మరియు బి క్లాస్లో
ఇది వర్చువల్ కాని
వర్గంగా ఉంటుంది,
కాబట్టి అది నేరుగా
ఆ ఫంక్షన్ కాల్ ఉంటుంది.
కాబట్టి, ఇది స్థిరంగా
B :: f()పాయింటర్ వాల్యూ(pointer
value) మరియు పరామితిని
పంపుతుంది. ఈ ఖచ్చితంగా
జరిమానా స్టాటిక్
మార్గాలు.
ఇప్పుడు, మూడ ఆబ్జెక్ట్న(
object) చూద్దాం, నేను
ఆబ్జెక్ట్ వాడుతున్నాను
మరియు వర్చువల్ ఫంక్షన్

Hindi: 
के स्थान पर यह अब
होगा। अगर मैं इस
सरणी को देखता हूं
तो यह दोगुना है, इसलिए
मेरे पास Er है तो एक
Er ऑब्जेक्ट(object), मेरे
पास Mgr है, मेरे पास
एक मैनेजर ऑब्जेक्ट(object)
है और इसी तरह। तो
हमारे पास इस तरह
से होंगे, उनमें से
छह अलग-अलग हैं। यह

English: 
a object for that that object also has a virtual
function table pointer. That point to virtual
function table this table is now of class
d, this table was of class b. Now what I have
done in class d? In the class d this function
virtual function g has been overridden a new
definition has been given so that is now become
d colon-colon g.
So, while we specialize following the specialization
we remove this function from the virtual function
table of b and through the overriding we put
the function that we have written new that
is a function for d, d colon-colon g in the
virtual function table.
And for this call, the compiler generates
the same indirected code. Now what will happen?
Now think off. This was the call and this
is what the function is generated the compiler

Telugu: 
(virtual function) గ్రానికే
కాల్ చేస్తాను. మళ్ళీ
కంపైలర్ (compiler)అదే
విషయం చేస్తుంది.
మేము ఆ ఆబ్జెక్ట్తోతో
కాల్ (object call)చేస్తే
అది పిలవబడే క్లాస్
ఫంక్షన్ అని మనకు
తెలుసు, కాబట్టి
b :: g()అని పిలుస్తాము.
B యొక్క చిరునామా
ఇక్కడ ముగిసింది
మరియు పరామితి ఇక్కడ
ముగిసింది. కాబట్టి,
ఈ మూడింటికి ఈ సమయానికి
అన్ని ప్రాథమికంగా
స్థిర బైండింగ్.
కాబట్టి, నేను ఒకవేళ
బి యొక్క బదులు ఉంటే,
నేను వస్తువు వర్గ
ఆబ్జెక్ట్(object)ను
తీసుకున్నాను మరియు
నేను ఈ క్లాస్ ఆబ్జెక్ట్ను(class
object) ఉత్పన్నం చేయటానికి
ప్రయత్నిస్తాను,
ఇక్కడ ఒకే విధమైన
స్టాటిక్ బైండింగ్
కోడ్ (static binding code)ఉంటుంది,

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

Hindi: 
सामान मेरा कुल संग्रह
है।
अब, जब मैं यह प्रोसेस
करना चाहता हूं कि
मैं एक लूप से ऊपर
जाऊंगा और यह महत्वपूर्ण
है कि मैं इस फ़ंक्शन(function)
पॉइंटर(pointer) ऐरे का
उपयोग करूंगा और
आई-वें स्टाफ के प्रकार
का उपयोग करूंगा।
कहो अगर i 0 है जब प्रकार
Er है। मैं इस फ़ंक्शन(function)
पॉइंटर(pointer) सरणी से

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

Telugu: 
ఇక్కడ ప్రతి కంపైలర్లో
రకం d మరియు ఇది ఆబ్జెక్ట్
(object) ద్వారా నేరుగా
లేదా ఒక పాయింటర్
(pointer) ద్వారా అయినా,
కానీ ఫంక్షన్ ఒక
కాని వర్చువల్ (virtual)
ఒకటి కాబట్టి ఇది
స్టాటిక్ కాల్స్
(static calls) ఉంచుతుంది.
నేను నిజంగా పి పాయింటర్
G వంటి ఏదో కాల్ చేయాలనుకుంటున్నప్పుడు
సమస్య తలెత్తుతుంది,
అది నేను ఒక కాల్
వర్చువల్ ఫంక్షన్
మరియు నేను ఒక పాయింటర్
వాడుతున్నాను, అందువల్ల
నేను డైనమిక్ బైండింగ్
అవసరం. నేను పి పాయింటర్
g కాల్ చేస్తున్నాను,
నేను పాయింటర్ వాడుతున్నాను
మరియు నేను వర్చువల్
ఫంక్షన్ను ఉపయోగిస్తున్నాను.
ఈ సందర్భంలో p ఆబ్జెక్ట్
కు పాయింటర్, కుడి
చేతి వైపు b లో d ఆబ్జెక్ట్కు

English: 
has generated these are call what has being generated this is what is been generating the static time.
Now what happens, the two
scenarios are that p is actually pointing
to a b object. If it points to a b object
it has the virtual function table pointer
it goes to this virtual function table of
b this is what it has got, it picks of function
0 the 0th function and calls that, so it is
calling b colon-colon g.
But if p is pointing to a d object here then
it has a different function pointer, virtual
function table pointer. When it traverses
at that pointer v p pointer VFT it actually
gets the virtual function table of d. It picks
up the 0th function which is this function,
which happens to be now d colon-colon g because
it actually points to a d object so this table

Hindi: 
उठाऊंगा जो कि यह
सरणी है, मैं इसे इस
प्रकार से अनुक्रमित
करूंगा जो कि Er है
जिसका अर्थ है 0 और
फिर हम उस फ़ंक्शन(function)
को कॉल करेंगे। तो,
यह psArray अगर मैं सिर्फ
एक अलग रंग का उपयोग
करता हूं, तो यह कहें
कि यह विशेष रूप से
एक फ़ंक्शन(function) पॉइंटर(pointer)
है, क्योंकि psArray यह
सरणी है। मैंने इसे

Telugu: 
పాయింటర్ (object pointer)అవుతుంది.
సో, నేను ఇక్కడ అవసరం
ఏమిటి? నేను ఇక్కడ
ఈ పి కాల్ ఈ ఫంక్షన్కు
పరిష్కరించడానికి
అవసరమవుతుంది.
నేను ఈ సందర్భంలో
ఈ కాల్ ఈ ఫంక్షన్కు
పరిష్కరిస్తాను.
కాల్ సైట్లో ఈ కాల్స్
రెండూ కూడా కనిపిస్తాయి.
నేను ఎలా చేస్తాను?
నేను ఆ మార్పును
ఎలా చేస్తాను? సో
నేను ఏమి చాలా సులభం
ఉంది. ఆబ్జెక్ట్
(object)యొక్క లేఅవుట్
(layout) గురించి ఆలోచించండి,
ఆబ్జెక్ట్ (object) ఒక
డేటా మెంబర్ని (data
member) కలిగి ఉంటుంది,
కనుక నేను వందతో
నిర్మించబడిన డేటా
మెంబర్ని(data member) కలిగి
ఉంది. కాబట్టి, నేను
ఇక్కడ ఒక డేటా సభ్యుడిని
కలిగివున్నాను, ఇక్కడ
ఇక్కడ field: b: i.
అదేవిధంగా, నేను
క్లాస్ ఆబ్జెక్ట్ను(class
object) ఉత్పన్నం చేస్తే,
అది ఒక డేటా మెంబర్(data

Hindi: 
i डॉट प्रकार के सामान
के साथ अनुक्रमित
किया है जो इस मामले
में Er है, पहले वाला
एक इंजीनियर(engineer)
है। तो मुझे जो मिलता
है वह एक फ़ंक्शन(function)
पॉइंटर(pointer) है जो
कि एक फ़ंक्शन(function)
है यह फ़ंक्शन(function)
का प्रकार है, यह एक
वोईद(void) तारा लेता
है और फ़ंक्शन(function)
को कहा जाता है। और
यह जो पास करता है
वह दूसरा पैरामीटर
है जो यहां स्टाफ[i]
.p है; वस्तु का सूचक।

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

English: 
is different. Then it passes the parameters
and call that naturally d colon-colon g will
get a called.
With this, simple mechanism of table of function
pointer, so what we will learn from this,
is if a class is polymorphic if a type is
polymorphic that if it has at least one a
virtual function then for that class there
will be a virtual function table, which will
have all the virtual functions listed one
after the other in the table in the order
in which they have been defined. Here we have
only one entry because we have only one virtual
function. If there are more then there will
be more entries and as the class is specialized
the compiler checks does the class redefine
the virtual function if it does then it changes
the corresponding entry in its own virtual

Telugu: 
member) j ను జతచేసింది,
కనుక ఇది ఒక బేస్
క్లాస్ భాగం 200 మరియు
అదనపు డేటా మెంబర్(data
member) 500 ను కలిగి ఉంటుంది.
అందువల్ల ఇది మంచిది.
ఇప్పుడు మనం ఏమి
చేస్తున్నామో మనం
ఇంకా ఒక క్షేత్రాన్ని
చేర్చాము, ఇది అదృశ్య
క్షేత్రం.
ఈ ఫీల్డ్ పాయింటర్
దాఖలు మరియు అది
ఏమి సూచిస్తుంది,
అది ఫంక్షన్ పాయింటర్ల
టేబుల్ సూచిస్తుంది
మరియు ఈ పట్టికను
VFT లేదా వర్చువల్
ఫంక్షన్ టేబుల్ అని
పిలుస్తారు. కాబట్టి
అది ఏమిటంటే, నేను
క్లాస్ (class) బి లో ఉన్నాను
మరియు నేను సంకేతాలను
చూస్తాను, నేను ఒక
వర్చువల్ ఫంక్షన్
పాయింటర్(virtual function
pointer) కలిగి మరియు నేను
ఒక వర్చువల్ ఫంక్షన్

English: 
function table and replaces with the version
that has override.
And then with always makes a call instead
of making a direct hard coded call like this
a static type call like this where it clearly
says what the function, it says that I do
not know the about the function at the runtime
go to the virtual function table pick up the
0th function and whatever function pointer
is your function.
So, depending on the type of the object the
virtual function table will be different,
but by the same mechanism the current entry
the runtime entry in the 0th location for
this function will appropriately a point to
either the function in the base class or the
function in the derive class depending on
which kind of object I have and therefore
which kind of virtual function table I am
pointing to. The basic virtual function I

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

Hindi: 
जब मैं इसे Er के साथ
यहां बुलाता हूं,
तो मुझे यह फ़ंक्शन(function)
मिला है जो प्रक्रिया
वेतन इंजीनियर(engineer)
है इसे इंजीनियर(engineer)
रिकॉर्ड द्वारा बुलाया
जाएगा, यही है कि इसमें
उस इंजीनियर(engineer)
के साथ कॉल किया जाएगा
जो रोहित के साथ किया
है। जब i 1 हो जाता है,
तो मुझे दूसरा रिकॉर्ड
मिलता है जहां मेरे
पास Mgr के रूप में टाइप
होता है और जो 1 है,
इसलिए मुझे दूसरा
फ़ंक्शन(function) पॉइंटर(pointer)
मिलता है और मैं इसे
पॉइंटर(pointer) के साथ
संबंधित कर्मचारी
को भेजता हूं जो प्रबंधक(manager)
रिकॉर्ड है। इस तरह
से एक के बाद एक इस
सभी कार्यों को उपयुक्त
कर्मचारी रिकॉर्ड
के साथ उपयुक्त प्रकार
के साथ बुलाया जाएगा
और एक बार जब हम रिकॉर्ड
के अंदर होंगे तो
हम पहले ही देख चुके
हैं कि अगर इंजीनियर(engineer)
फ़ंक्शन(function) को आमंत्रित
किया गया है और मुझे
पॉइंटर(pointer) मिला है
यहाँ इंजीनियर(engineer)
रिकॉर्ड करने के
लिए तो मैं कास्ट
और निष्पादित करेंगे।
यह ऐसा करने की मूल
शैली है। हमने जो
परिवर्तन किया है,
वह है; हमने इस पूरी
बात को फंक्शन(function)

Hindi: 
पॉइंटर्स(pointers) के
एरे में बनाया है
और हम उन्हें एक साधारण
कोड के माध्यम से
आमंत्रित कर रहे
हैं। और हमें किसी
भी स्विच की आवश्यकता
नहीं है; सशर्त स्विच
जो हम कर रहे थे वह
सब इस फ़ंक्शन(function)
पॉइंटर(pointer) सरणी में
अनुक्रमण द्वारा
ध्यान रखा गया है।
यह C में एक और समाधान
हो सकता है जो C में
एक स्मार्ट समाधान
है जो बहुत उपयोगी
होगा।
यदि हम जल्दी से इसे
पॉलिमरिक C ++ समाधान
के साथ तुलना करते
हैं तो यह समाधान
के लिए मूल दृष्टिकोण
था।
अगर आप गौर करेंगे
तो आप देखेंगे कि
हमारे पास विध्वंसक,
निर्माणकर्ता, अलग-अलग
ओवरराइड प्रक्रिया
वेतन कार्यों और
इसी तरह की सभी चीजें
हैं।
और इसके साथ ही अगर
हम देखें, तो हमारा
कोड केवल इस कॉल के
साथ लूप के लिए है।
जहां यह प्रत्येक
और हर एक इंजीनियर(engineer)
प्रकार के लिए एक
संकेतक है और बहुलक
प्रेषण के आधार पर
यह उचित processSalary फ़ंक्शन(function)
प्रक्रिया को कॉल
करेगा।
यदि हम इसे साइड बाइ
साइड से तुलना करते
हैं तो यह केवल डिज़ाइन
सुविधाओं की तुलना
कर रहा है।
लेकिन अगर हम इसकी
तुलना समाधान के
साथ-साथ करते हैं
तो आप देखेंगे कि
यह C समाधान है, जो
इसी C ++ क्लास(class) का
है। तो, आपके पास इसमें
इंजीनियर(engineer) है,
आपके पास यहां कंस्ट्रक्टर
है, आपके पास यह विशेष
प्रसंस्करण फ़ंक्शन(function)(function)
है, आपके पास ओवर लोड
सदस्य(member) फ़ंक्शन(function)(function)
है जो प्रकृति में
एक पॉलीमोर्फिक(polymorphic)

English: 
am pointer table mechanism by which we can
do things.
As I said whenever a class defines a virtual
function a hidden member variable is added
to the class which points here. And at the
runtime the invocation is indirectly through
this and this carries what is known as RTTI.
We will talk about RTTI more that is Run-Time
Type Information of the whole polymorphic
system.
.
This is one more example, the example that
we had solved as a binding exercise so you
can see here this is just for your further
illustration. This is primarily for your own
working out, but we have a class A and specialized
from that we have class B, specialized from
that we have class C. And class A has a polymorphic
function it has a virtual function so naturally
the whole hierarchy is polymorphic and therefore,

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

Telugu: 
కలిగి ఉంటాను. నేను
ఈ పట్టికలో వర్చువల్
ఫంక్షన్ ఉంచాను నేను
ఈ పట్టికలో ఈ పాయింటర్
ఉంచాను. మరియు నేను
ఒక ఫంక్షన్ గ్రా
ఈ ఫంక్షన్ కోసం ఒక
కాల్ పొందుతారు చేసినప్పుడు
ఒక పాయింటర్ ద్వారా
ఈ వర్చువల్ ఫంక్షన్
గ్రా, నేను ఈ వంటి
ఒక కోడ్ ఉత్పత్తి
కాదు, నేను ఈ స్టాటిక్
కోడ్(static code) ఉత్పత్తి
కాదు నేను ఈ వంటి
కోడ్ ఉత్పత్తి చేస్తుంది.
ఈ సింటాక్స్(syntax) అయోమయం
పొందవద్దు, ఏమి చెప్పబడుతోంది?
పి ఒక పాయింటర్. కాబట్టి
p ఒక పాయింటర్, కాబట్టి
p పాయింట్లు ఇక్కడ.
P పాయింటర్ VFT అంటే
ఏమిటి? P పాయింటర్
VFT ఈ పట్టికకు సూచించబడుతుంది.

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

Telugu: 
మరియు p పాయింటర్
VFT సూచించబడినట్లయితే
ఈ పట్టిక p పాయింటర్
VFT 0 ఈ పట్టిక యొక్క
0 వ ప్రవేశం, మరియు
ఆ ఎంట్రీ ఏమిటి? ఆ
ప్రవేశం ఒక ఫంక్షన్
పాయింటర్. కాబట్టి,
p పాయింటర్ VFT 0 ఈ పట్టికలో
0 వ ఫంక్షన్ పాయింటర్(
function pointer). కాబట్టి,
నేను మీకు p పాయింటర్
g వచ్చినప్పుడల్లా
మీరు ఈ ఫంక్షన్లో
ఏ ఫంక్షన్ అయినా
కాల్ చేస్తారు. కాబట్టి
మీరు ఈ ఫంక్షన్ ను
ఎంచుకొని, పారామిటర్లతో
కాల్ చేస్తే, ఈ పాయింటర్తో
p మరియు ఇది 45 పారామితి
విలువను కలిగి ఉంది.
కంపైలర్(compiler) ఇది
ఒక వర్చువల్ ఫంక్షన్(virtual
function) అని తెలుసుకోవడం
మరియు ఇది ఒక పాయింటర్
స్థిరమైన సమయ కోడ్ను
ఉత్పత్తి చేయదు,
హార్డ్ కోడ్ ఫంక్షన్
వంటిది, కానీ అది
వర్చువల్ ఫంక్షన్
టేబుల్ ( virtual function table)ద్వారా
ఉంటే కాల్ని ఉంచుతుంది.
ఎలా సహాయం చేస్తుంది?
అది మీకు సహాయపడే
రీతిలో ఇప్పుడు మీకు
దిశలో ఒక స్థాయి
ఉంది. కాబట్టి ఏమి
జరుగుతుందో, మీరు
ఈ క్లాస్ని class) క్లాస్
d లోకి ప్రత్యేకంగా
చేస్తే, ఆ క్లాస్కు
(class)ఒక ఆబ్జెక్ట్
ను కూడా ఒక వాస్తవిక
ఫంక్షన్ టేబుల్ పాయింటర్
కలిగి ఉంటుంది. వర్చ్యువల్
ఫంక్షన్ టేబుల్ కు
ఈ బిందువు, ఈ పట్టిక
ఇప్పుడు క్లాస్ d

English: 
the all objects on any of this classes on
this hierarchy will have a virtual function
table pointer.
So if I have the object A, say object A here
then it will have data members those are not
interesting so we have not listed those, but
it will have a virtual function table pointer
which will point to VFT of class A. And how
many entries will be there? There is one virtual
function f and one virtual function g. So
there is a virtual function f there is a virtual
function g.
But when it specializes to B you have made
h also a virtual function. So what will happen?
A third function will get added in the location
two. And what will happen to 0 and 1? F was
defined in A and there is over head name B.
So, the 0th entry that was for f gets over

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

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

English: 
hidden. Now, in place of a colon-colon f you
have b colon-colon f. G was also defined as
a virtual function in a it resides in location
one, but class b has not overridden g. So,
when you inherit you actually get the same
a colon-colon g as function number one. And
h you have made it a virtual function a fresh
so the virtual function table gets added with
an additional function pointer.
As you come to C object what you have done
you have overridden g. So, what you get, you
have not done anything with f, so f is simply
inherited. So you got b colon-colon f in the
0th entry continuous to be b colon-colon f.
But this entry number one was a colon-colon
g, but now you have over written that, so
that gets over written with c colon-colon
g.

Telugu: 
యొక్క, ఈ పట్టిక క్లాస్
b. ఇప్పుడు నేను క్లాస్
d లో ఏమి చేశాను? క్లాస్
d లో ఈ ఫంక్షన్ వర్చువల్
ఫంక్షన్ g ఒక కొత్త
నిర్వచనం ఇవ్వడం
జరిగింది కాబట్టి
ఇప్పుడు ఇది d :: g అవుతుంది.
కాబట్టి, స్పెషలైజేషన్(specialization)
ను అనుసరించి మేము
ప్రత్యేకంగా చేస్తున్నప్పుడు
ఈ చర్యను b యొక్క వర్చువల్
ఫంక్షన్ టేబుల్ నుంచి
తొలగించి, మనం భర్తీ
చేసిన ఫంక్షన్ ను
కొత్తగా వ్రాసిన
ఫంక్షన్ ను డి, డి
కోలన్-కోలన్ గ్రాని
వర్చువల్ ఫంక్షన్
టేబుల్లో వాడాలి.
మరియు ఈ కాల్ కోసం,
కంపైలర్ అదే ఇండైరెక్టెడ్
కోడ్ను(indirected code) ఉత్పత్తి
చేస్తుంది. ఇప్పుడు
ఏమి జరుగుతుంది?
ఇప్పుడు ఆలోచించండి.
ఇది కాల్ మరియు ఈ
ఫంక్షన్ సృష్టించబడినది
కంపైలర్ ఈ ఉత్పత్తిని
సృష్టించింది ఏమిటంటే
ఇది ఉత్పత్తి చేయబడిన
స్థిరమైన సమయాన్ని
ఉత్పత్తి చేస్తుంది.
ఇప్పుడు ఏమి జరుగుతుందో,
రెండు సందర్భాలు
p వాస్తవానికి AB ఆబ్జెక్ట్కు
గురిపెట్టివుంటాయి.
అది ab ఆబ్జెక్ట్కు
సూచించినట్లయితే
అది వర్చువల్ ఫంక్షన్
టేబుల్ పాయింటర్ను(table
pointer) కలిగి ఉంటుంది,
అది b యొక్క ఈ వర్చువల్
ఫంక్షన్ టేబుల్కు
వెళుతుంది అది అది
కలిగి ఉన్నది, ఇది
0 వ ఫంక్షన్ మరియు
కాల్స్ యొక్క పిక్స్
పిక్స్: కాబట్టి
దీనిని b :: g గా పిలుస్తాము.
కానీ p ఇక్కడ ఆబ్జెక్ట్కు
గురిపెట్టి ఉంటే
వేరే ఫంక్షన్ పాయింటర్,
వర్చువల్ ఫంక్షన్
టేబుల్ పాయింటర్
ఉంది. అది ఆ పాయింటర్
VP పాయింటర్ VFT వద్ద
ట్రావర్స్ చేస్తే
అది వాస్తవానికి
d యొక్క వర్చువల్
ఫంక్షన్ పట్టికను
పొందుతుంది. ఈ ఫంక్షన్

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

English: 
Entry number two was b colon-colon h. The
h function in class b that have been over
written here so you get c colon-colon h, this
is how the virtual function table will keep
on growing and that basically will tell you
why we said that once of function becomes
virtual on this hierarchy it will have to
remain virtual because once it that the compiler
as a decision to make and here I have shown
what will be the compile version of this codes
are.
So you can say this goes to virtual function
table entry 0, g goes to table entry 1, but
where as if I do p a pointer h then I have
static binding, the explicit function calls
because this function was non-virtual. Whereas
when I do it with p b, that is a pointed to
the class b type then they have brought out
it through the virtual function table because here in class b h has become a virtual function.

Hindi: 
कि हमें मूल रूप से
सही प्रकार चुनना
है, ऑब्जेक्ट(object) पॉइंटर(pointer)
इस सूचक के रूप में
निहित है और यह काम
करेगा। इसका कारण
मैं आपको यह उदाहरण
दिखाता हूं या इस
तरह से आपको C में
फ़ंक्शन(function) पॉइंटर(pointer)
का उपयोग करते हुए
दिखाता हूं, यह एक
तथ्य है कि यह वास्तव
में वास्तव में C ++
कंपाइलर वर्चुअल(virtual)
फ़ंक्शन(function) या पॉलीमॉर्फिक(polymorphic)
फ़ंक्शन(function) का ख्याल
रखता है।
इसलिए इसे वास्तविक
विवरण में लाने के
लिए, मान लीजिए कि
मेरे पास एक बेस क्लास
बी है, इसलिए इस बेस
क्लास के लिए मेरे
पास दो कार्य हैं;
एक फ़ंक्शन(function) f है
और यह फ़ंक्शन(function)
जी। कौन से; एक पॉलिमरिक
प्रकार का है, जी पॉलीमॉर्फिक
प्रकार है, एफ एक गैर-पॉलीमॉर्फिक
प्रकार है, यह एक गैर-वर्चुअल(virtual)
कार्य है। और इस आधार
क्लास(class) के आधार
पर मेरे पास एक व्युत्पन्न
क्लास(class) है जो गैर-पॉलीमोर्फिक(polymorphic)
फ़ंक्शन(function) के साथ-साथ
पॉलीमोर्फिक(polymorphic)
फ़ंक्शन(function) भी लिखता
है।
अब, आप इस मामले में
क्या करते हैं; एक
गैर-पॉलीमोर्फिक(polymorphic)
समारोह के लिए हमें
यह कहना चाहिए कि
यदि हम केवल उस कार्य
f के बारे में बात
करते हैं जो प्रकृति
में गैर-पॉलीमोर्फिक(polymorphic)
है, तो आह्वान कैसा
दिखेगा? मान लीजिए
अगर मैं नमूना बी.f
() करता हूं जो सीधे
ऑब्जेक्ट(object) के साथ
इसे एक्सेस कर रहा
है। तो, कंपाइलर इसे
कैसे कहेंगे? कंपाइलर
को इस तथ्य से पता
चलेगा कि बी एक क्लास(class)
बी प्रकार की वस्तु
है जिसे कंपाइलर
जानता है कि एक फ़ंक्शन(function)(function)
एफ है जिससे इसे कहा
जाता है। तो, यह बी
कॉलन-कोलोन एफ कहता
है जो कि यह कार्य
है, और क्या आवश्यक
है? इसके लिए इस सूचक
की आवश्यकता होती

Telugu: 
ఇది 0 వ ఫంక్షన్ కైవసం
చేసుకుంది, ఇది ఇప్పుడు
d :: g గా ఉంటుంది, ఎందుకంటే
ఇది వాస్తవానికి
ఆబ్జెక్ట్కు సూచిస్తుంది
ఎందుకంటే ఈ పట్టిక
భిన్నంగా ఉంటుంది.
అప్పుడు అది పారామితులను
పంపుతుంది మరియు
సహజంగా d :: g అని పిలవబడుతుంది.
దీనితో, ఫంక్షన్
పాయింటర్ యొక్క పట్టిక
యొక్క సరళమైన విధానం,
అందుచేత మనము ఈ నుండి
నేర్చుకుందాం, ఒక
వర్గం పాలిమార్ఫిక్
ఉంటే అది ఒక వర్చువల్
ఫంక్షన్ కలిగి ఉంటే
ఆ క్లాస్కి (class) ఒక
వర్చువల్ ఫంక్షన్
ఉంటుంది టేబుల్,
అన్ని వర్చువల్ విధులు
వారు నిర్వచించిన
క్రమంలో పట్టికలో
ఇతర తర్వాత ఒక జాబితా
ఉంటుంది. ఇక్కడ మనము
ఒకే ఎంట్రీని కలిగిఉన్నాము
ఎందుకంటే మనము ఒక
వర్చువల్ ఫంక్షన్
మాత్రమే. మరింత ఉంటే
మరింత ఎంట్రీలు మరియు
క్లాస్సెస్ నైపుణ్యం
వంటి కంపైలర్ తనిఖీలు
క్లాస్ వర్చువల్
ఫంక్షన్ పునర్నిర్వచించటానికి
చేస్తుంది అప్పుడు
అది దాని స్వంత వర్చువల్
ఫంక్షన్ పట్టికలో
సంబంధిత ఎంట్రీని
మార్చడానికి మరియు
భర్తీ చేసింది వెర్షన్
భర్తీ చేస్తుంది.
మరియు తర్వాత ఒక
కాల్ చేస్తుంది బదులుగా
ఒక ప్రత్యక్ష హార్డ్
కోడెడ్ కాల్ మేకింగ్
ఈ వంటి ఒక స్టాటిక్
టైప్(static type) కాల్ ఇది
స్పష్టంగా ఫంక్షన్,
నేను రన్టైమ్ ఫంక్షన్(runtime
function) గురించి తెలియదు
చెప్పారు ఈ వంటి
వర్చువల్ ఫంక్షన్
వెళ్ళండి పట్టిక
0 వ ఫంక్షన్ మరియు
సంసార ఫంక్షన్ పాయింటర్
మీ ఫంక్షన్ ఉంది.
కాబట్టి, ఆబ్జెక్ట్
యొక్క టైప్న్ని బట్టి
వర్చువల్ ఫంక్షన్
టేబుల్ భిన్నంగా
ఉంటుంది, కానీ అదే
విధానం ద్వారా ప్రస్తుత
ఎంట్రీ ఈ ఫంక్షన్
కోసం 0 ప్రదేశంలో
రన్టైమ్ ప్రవేశం
బేస్ క్లాస్ (base class)
లేదా ఫంక్షన్లో ఫంక్షన్కు
సరిగ్గా ఒక పాయింట్
అవుతుంది నేను ఏ
రకమైన ఆబ్జెక్ట్లపై
ఆధారపడుతున్నాను
మరియు అందుచే వర్చువల్
ఫంక్షన్ టేబుల్ యొక్క
ఏ రకంగా నేను గురిపెడుతున్నాను
అనేదానిని వర్గీకరించండి.
ప్రాథమిక వర్చువల్
ఫంక్షన్ నేను పాయింటర్
టేబుల్ మెకానిజం(
pointer table mechanism)చేస్తాను,
దీని ద్వారా మనం
పనులు చేయవచ్చు.
ఒక క్లాస్ వర్చువల్
ఫంక్షన్ను నిర్వచిస్తున్నప్పుడు,
దానికి అనుగుణంగా
ఉన్న మెంబర్ (member)కి
దాచిన మెంబర్ వేరియబుల్
(member variable) జోడించబడిందని
నేను చెప్పినట్లుగా.
మరియు రన్టైమ్లో
ఈ ప్రవేశం ద్వారా
ఇండైరెక్ట్లీ (indirectly)
పిలుస్తారు మరియు
ఇది RTTI గా పిలవబడుతుంది.
మేము పటిమోర్ఫిక్
సిస్టమ్ యొక్క రన్-టైం
టైప్ ఇన్ఫర్మేషన్
అనే RTTI గురించి మరింత
మాట్లాడుకుంటాం.
ఇది మరొక ఉదాహరణ,
మేము ఒక బైండింగ్
వ్యాయామం వలె పరిష్కరించిన

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

Telugu: 
ఉదాహరణ, ఇక్కడ మీరు
ఇక్కడ చూడవచ్చు,
ఇది మీ మరింత దృష్టాంతంగా
ఉంటుంది. ఇది మీ స్వంత
పని కోసం ప్రధానంగా
ఉంటుంది, కానీ మేము
క్లాస్ B ను కలిగి
ఉన్న క్లాస్ల మరియు
ప్రత్యేకమైన క్లాస్
B ను కలిగి ఉన్న ప్రత్యేకమైనది,
మనకు క్లాస్ C. మరియు
క్లాస్ A అనే ఒక పాలిమార్ఫిక్
ఫంక్షన్ ఉంది, అది
ఒక వర్చువల్ ఫంక్షన్
ఉంది కాబట్టి సహజంగా
మొత్తం సోపానక్రమం
పాలిమార్ఫిక్ మరియు
అందువలన, ఈ శ్రేణిలో
ఈ క్లాస్ల్లో అన్ని
ఆబ్జెక్ట్స ఒక వర్చువల్
ఫంక్షన్ టేబుల్ పాయింటర్
ఉంటుంది. నేను ఆబ్జెక్ట్
A కలిగి ఉంటే, ఆబ్జెక్ట్
A అని చెప్పండి, అప్పుడు
మనము ఆ జాబితాలో
చేర్చబడలేదు కాబట్టి
డేటా మెంబర్స్ కలిగి
ఉండదు, కాని ఇది వర్చువల్
ఫంక్షన్ టేబుల్ పాయింటర్
కలిగి ఉంటుంది, ఇది
క్లాస్ A యొక్క VFT కు
మరియు ఎన్ని ఎంట్రీలు
అక్కడ ఉందా? ఒక వర్చువల్
ఫంక్షన్ f మరియు ఒక
వర్చువల్ ఫంక్షన్
g ఉంది. కాబట్టి వర్చువల్
ఫంక్షన్ f ఉంది. కానీ
అది B కు ప్రత్యేకంగా
ఉన్నప్పుడు మీరు
కూడా ఒక వాస్తవిక
ఫంక్షన్ కూడా చేసాము.
కాబట్టి ఏం జరుగుతుందో?
మూడవ విధి నగరంలో
రెండు జోడించబడతాయి.
మరియు 0 మరియు 1 కు
ఏమి జరుగుతుంది?
F లో A లో నిర్వచించబడింది
మరియు తల పేరు B. పైగా
ఉంది, F కోసం ఉన్న
0 వ ఎంట్రీ దాచిపెడుతుంది.
ఇప్పుడు, ఒక కోలన్-కోలన్
f స్థానంలో మీరు b
:: f. G అనేది ఒక వర్చువల్
ఫంక్షన్గా కూడా పేర్కొనబడింది,
ఇది స్థానానికి చెందినదిగా
ఉంది, కానీ క్లాస్
b g ఓవర్గ్రేడ్ చేయబడలేదు.
కాబట్టి, మీరు ఇన్హేరిటాన్స్
(inheritance)వచ్చినప్పుడు,
వాస్తవానికి అదే
:: g గా పనిచేయవచ్చు.
మరియు h మీరు ఒక వాస్తవిక
ఫంక్షన్ ఒక తాజా
చేసిన కాబట్టి వర్చ్యువల్
ఫంక్షన్ పట్టిక అదనపు
ఫంక్షన్ పాయింటర్
జత అవుతుంది. మీరు
C కు వచ్చినప్పుడు
మీరు చేసిన పని ఏమిటంటే
g మీరు భర్తీ చేసారు.
కాబట్టి, మీరు ఏమి
చేస్తే, మీరు f తో
ఏదైనా చేయలేరు, కాబట్టి
f అనేది కేవలం ఇన్హేరిటాన్స్గా(inheritance)
ఉంటుంది. కాబట్టి
మీరు b: f నిరంతర 0 వ
ఎంట్రీలో B colon-colon f గా
ఉండాలి. కానీ ఈ ఎంట్రీ
నంబర్ ఒకటి: g, కానీ
ఇప్పుడు మీరు రాయితీ
అని, కాబట్టి ఆ వ్రాసిన
పైగా సి కోలన్-కోలన్
గ్రా తో వ్రాసిన.
ఎంట్రీ సంఖ్య రెండు
b :: క్లాస్ బి లో h ఫంక్షన్
ఇక్కడ వ్రాయబడి ఉంది
కాబట్టి మీరు c :: h
ను అందుకుంటూ, వర్చువల్
ఫంక్షన్ టేబుల్ ఎలా
పెరుగుతుంది మరియు
ఇది ప్రాథమికంగా
మీరు చెప్పేదేమిటంటే
ఫంక్షన్ యొక్క ఈ
ఆర్రేలో వర్చువల్
అవుతుంది ఇది ఒక
నిర్ణయం గా కంపైలర్
మరియు ఇక్కడ నేను
ఈ సంకేతాలు కంపైల్
వెర్షన్ ఉంటుంది
ఏమి చూపించారు ఒకసారి
ఎందుకంటే వాస్తవిక
ఉండటానికి ఉంటుంది.
కాబట్టి మీరు ఈ వర్చువల్
ఫంక్షన్ టేబుల్ ఎంట్రీ
0 కి వెళుతుంది, g టేబుల్
ఎంట్రీ 1 కి వెళుతుంది,
కానీ నేను pa పాయింటర్
h చేస్తే, నేను స్టాటిక్
బైండింగ్ చేస్తే,
స్పష్టమైన ఫంక్షన్
కాల్స్ ఎందుకంటే
ఈ ఫంక్షన్ నాన్ వర్చ్యువల్
(non virtual) కాదు. నేను pb
తో చేస్తున్నప్పుడు,
అది క్లాస బి టైప్కి
ఒక పాయింటుగా ఉంది,
అప్పుడు వారు వర్చువల్
ఫంక్షన్ టేబుల్ ద్వారా
దాన్ని తీసుకువచ్చారు
ఎందుకంటే ఇక్కడ క్లాస్bh

English: 
So please work this out, please try to understand this construction very carefully and work
through this source expression and against
the compile expression of where you have static
binding and where you have dynamic binding
so that you will be able to understand this
as well.
To summarize it leveraging and innovative
solution to the staff salary application which
uses function pointers in C we have laid the
foundation for explaining how virtual functions
are implemented using the virtual function
pointer table. Please try to understand this
more clearly so that any confusion about dynamic
dispatch would be clear in your mind.

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

Hindi: 
है जो b का पता होता
है, इसलिए यह b का पता
डालता है और यह पैरामीटर
डालता है। तो, यह यहाँ
और पैरामीटर के ख
का पता डालता है और
यह कहा जाता है। यह
एक स्थिर बंधन है;
यह एक साधारण स्थैतिक
बंधन है।
अगर मैं एक पॉइंटर(pointer)
का उपयोग कर रहा हूं
तो मुझे एक पॉइंटर(pointer)
के साथ ऐसा ही काम
करना है। इसलिए, अगर
मैं इसे कॉल कर रहा
हूं, तो पॉइंटर(pointer)
के प्रकार से जो कि
बी टाइप का है, यह
जानता है कि इसे उस
बी क्लास में देखना
है जिसे हमने पहले
देखा है और बी क्लास
में इसका फ़ंक्शन(function)
f है जो कि गैर-वर्चुअल(virtual)
है, तो यह सीधे उस
फ़ंक्शन(function) को कॉल
करना होगा। तो, यह
सांख्यिकीय रूप से
b :: f() सूचक मान और पैरामीटर
को पास करता है। ये
स्थिर तरीके हैं
यह बिल्कुल ठीक है।
अब, हम एक तीसरे आह्वान
पर भी गौर करते हैं
जहां मैं ऑब्जेक्ट(object)
का उपयोग कर रहा हूं
और गैर-वर्चुअल(virtual)
फ़ंक्शन(function) जी को
बुला रहा हूं। फिर
से कंपाइलर वही काम
करता है। हम जानते
हैं कि यदि हम इसे
वस्तु के साथ कहते
हैं तो यह उस क्लास(class)
का कार्य है जिसे
कहा जाएगा, इसलिए
b :: g () जिसे हम कहते
हैं। बी का पता यहां
से दिया गया है और
पैरामीटर यहां से
पारित किया गया है।
तो, इन तीनों के लिए
इस बिंदु तक ये सभी
मूल रूप से स्थिर
बंधन हैं। इसलिए,
यदि मैं b के बजाय
यदि मेरे पास एक व्युत्पन्न
क्लास(class) वस्तु है
d और मैं व्युत्पन्न
क्लास(class) वस्तु के
लिए ऐसा करने की कोशिश
करता हूं तो मेरे
पास समान स्थिर बाध्यकारी
कोड होगा, जहां इनमें
से प्रत्येक में
संकलक जानता है कि
प्रकार d है और चाहे
वह ऑब्जेक्ट(object) द्वारा
सीधे हो या यह एक पॉइंटर(pointer)
के माध्यम से हो, लेकिन
फ़ंक्शन(function) एक गैर
वर्चुअल(virtual) है इसलिए
यह स्थिर कॉल लगाएगा।
समस्या तब उत्पन्न
होती है जब मैं वास्तव
में पी पॉइंटर(pointer)
जी जैसी किसी चीज़
को कॉल करना चाहता
हूं, अर्थात मैं एक
कॉलिंग वर्चुअल(virtual)
फ़ंक्शन(function) हूं
और मैं एक पॉइंटर(pointer)
का उपयोग कर रहा हूं,
इसलिए यह वह जगह है
जहां मुझे डायनेमिक
बाइंडिंग(binding) की आवश्यकता
है। मैं पी पॉइंटर(pointer)
जी कह रहा हूं, मैं
एक पॉइंटर(pointer) का
उपयोग कर रहा हूं
और मैं एक वर्चुअल(virtual)
फ़ंक्शन(function) का उपयोग
कर रहा हूं। इस मामले
में p ऑब्जेक्ट(object)
को एबट करने के लिए
एक पॉइंटर(pointer) है,
इस मामले में राइट
हैंड साइड बी, डी ऑब्जेक्ट(object)
के लिए पॉइंटर(pointer)
है। तो, मुझे यहाँ
क्या चाहिए? मुझे
यहाँ इस बात की आवश्यकता
होगी कि p यह कॉल वास्तव
में इस फ़ंक्शन(function)
को हल करेगा।
जबकि मुझे इसकी आवश्यकता
होगी कि इस मामले
में यह कॉल इस फ़ंक्शन(function)
को हल करेगा। भले
ही कॉल साइट पर यह
दोनों कॉल एक जैसे
दिखते हों। मैं उसको
कैसे करू? मैं वह परिवर्तन
कैसे करूँ? इसलिए
मैं जो कुछ करता हूं
वह बहुत सरल है। ऑब्जेक्ट(object)
के लेआउट के बारे
में सोचें, ऑब्जेक्ट(object)
में डेटा सदस्य(member)

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

Hindi: 
i है, इसलिए मेरे पास
एक डेटा सदस्य(member)
है I इसे सौ के साथ
बनाया गया था। इसलिए,
मेरे पास एक डेटा
मेंबर I, b :: i है जो कि
यहां का क्षेत्र
है।
इसी तरह, यदि मैं व्युत्पन्न
क्लास(class) ऑब्जेक्ट(object)
को देखता हूं, तो इसमें
एक डेटा सदस्य(member)
j जोड़ा गया है, इसलिए
इसमें एक बेस क्लास
हिस्सा होगा जो 200
है और अतिरिक्त डेटा
सदस्य(member) जो 500 जोड़ा
गया है। इसलिए ये
ठीक हैं। अब हम क्या
करते हैं हम एक और
क्षेत्र जोड़ते हैं,
यह अदृश्य क्षेत्र
है जो हम ऑब्जेक्ट(object)
में दायर एक और जोड़ते
हैं।
यह फ़ील्ड एक पॉइंटर(pointer)
है और यह किस ओर इशारा
करता है, यह फ़ंक्शन(function)
पॉइंटर्स(pointers) की
तालिका की ओर इशारा
करता है और इस तालिका
को वीएफटी या वर्चुअल(virtual)
फंक्शन(function) टेबल(table)
के रूप में जाना जाता
है। तो यह क्या करता
है, जब कहते हैं, मैं
कक्षा बी में हूं
और मैं कोड को देखने
की कोशिश कर रहा हूं,
मेरे पास एक वर्चुअल(virtual)
फ़ंक्शन(function) पॉइंटर(pointer)
है और मेरे पास एक
वर्चुअल(virtual) फ़ंक्शन(function)
है। तो मैंने इस तालिका
में उस वर्चुअल(virtual)
फ़ंक्शन(function) को रखा
है जो मैंने इस सूचक
को इस तालिका में
रखा है। और जब भी मुझे
इस फ़ंक्शन(function) के
लिए कॉल आएगा इस वर्चुअल(virtual)
फंक्शन(function) जी को
एक पॉइंटर(pointer) के
माध्यम से, मैं इस
तरह एक कोड उत्पन्न
नहीं करूंगा, मैं
इस स्थिर कोड को उत्पन्न
नहीं करूंगा बल्कि
मैं इस तरह से एक कोड
उत्पन्न करूंगा।
इस वाक्य-विन्यास
से भ्रमित न हों, क्या
कहा जा रहा है? P एक
पॉइंटर(pointer) है। तो
p एक पॉइंटर(pointer) है,
इसलिए p यहाँ पॉइंट
करता है।
P पॉइंटर(pointer) VFT क्या
है? P पॉइंटर(pointer) VFT
इस तालिका के लिए
बताया गया है। और
यदि p पॉइंटर(pointer) VFT
को इस टेबल(table) की ओर
इशारा किया जाए तो
P पॉइंटर(pointer) VFT 0 इस
तालिका की 0 वीं प्रविष्टि
है, और वह प्रविष्टि
क्या है? वह प्रविष्टि
एक फ़ंक्शन(function) पॉइंटर(pointer)
है। तो, p पॉइंटर(pointer)
VFT 0 तालिका में यह
0 वां फ़ंक्शन(function)
पॉइंटर(pointer) है। तो,
मैं कहता हूं कि जब
भी आपको p पॉइंटर(pointer)
g मिलता है, तो आप वास्तव
में इस स्थान पर जो
भी फ़ंक्शन(function) होता
है, उसे कॉल करते हैं।
तो आप इस फ़ंक्शन(function)
को चुनें और मापदंडों
के साथ कॉल करें, इस
पॉइंटर(pointer) के मापदंडों
के साथ जो कि पी और
वास्तविक पैरामीटर
मान है जो 45 है।
संकलक यह जानते हुए
कि यह एक वर्चुअल(virtual)
फ़ंक्शन(function) है और
यह जानते हुए कि यह
एक के माध्यम से बुलाया
गया है पॉइंटर(pointer)
स्टैटिक टाइम कोड
को उत्पन्न नहीं
करता है, जैसे कि फ़ंक्शन(function)
को हार्ड कोड करता
है, लेकिन यह कॉल को
वर्चुअल(virtual) फ़ंक्शन(function)
तालिका के माध्यम
से रखता है। वह कैसे
मदद करता है? जिस तरह
से यह मदद करता है
अब आपके पास दिशा
में एक स्तर है। तो
क्या होता है, जब आपने
इस क्लास(class) बी को
कक्षा डी में विशेषज्ञ
किया है और आप उस वस्तु
के लिए एक वस्तु का
निर्माण करते हैं

Telugu: 
వాస్తవిక ఫంక్షన్గా
మారింది. దయచేసి
ఈ పనిని దయచేసి, ఈ
నిర్మాణాన్ని చాలా
జాగ్రత్తగా జాగ్రత్తగా
అర్థం చేసుకుని,
ఈ సోర్స్ ఎక్స్ప్రెషన్
ద్వారా మరియు మీకు
స్టాటిక్ బైండింగ్
ఉన్న మరియు మీరు
డైనమిక్ బైండింగ్
ఉన్న కంపైల్ వ్యక్తీకరణకు
వ్యతిరేకంగా పనిచేయడానికి
ప్రయత్నించండి, తద్వారా
మీరు దీన్ని అర్థం
చేసుకోగలుగుతారు.
ఇది పనితీరు పాయింటర్లను
ఉపయోగిస్తున్న స్టాఫ్
సాలెరి (staff salary) విక్రయించే
మరియు వినూత్న పరిష్కారాన్ని
క్లుప్తీకరించడానికి
మేము వర్చువల్ ఫంక్షన్
పాయింటర్ పట్టికను
ఉపయోగించి వర్చువల్
ఫంక్షన్లను ఎలా అమలు
చేస్తున్నామో వివరిస్తున్నందుకు
పునాదిని ఉంచాము.
మరింత స్పష్టంగా
అర్థం చేసుకోవడానికి
ప్రయత్నించండి, తద్వారా
డైనమిక్ డిస్పాచ్(
dynamic dispatch) గురించి ఏదైనా
గందరగోళం మీ మనసులో
స్పష్టంగా ఉంటుంది.

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

Hindi: 
जिसमें एक वर्चुअल(virtual)
फ़ंक्शन(function) तालिका
सूचक भी होता है।
वर्चुअल(virtual) फ़ंक्शन(function)
तालिका की ओर इशारा
करते हुए, यह तालिका
अब कक्षा d की है, यह
तालिका क्लास(class)
b की थी। अब मैंने
कक्षा d में क्या किया
है? क्लास d में इस
फंक्शन(function) वर्चुअल(virtual)
फंक्शन(function) g को ओवरराइड
किया गया है एक नई
परिभाषा दी गई है
जिससे अब d :: g हो गया
है।
इसलिए, जब हम विशेषज्ञता
का पालन करते हैं,
तो हम इस फ़ंक्शन(function)
को b की वर्चुअल(virtual)
फ़ंक्शन(function) तालिका
से हटा देते हैं और
ओवरराइडिंग के माध्यम
से हम उस फ़ंक्शन(function)
को डालते हैं जो हमने
लिखा है कि वर्चुअल(virtual)
फ़ंक्शन(function) तालिका
में डी, डी-कोलोन-कोलोन
जी के लिए एक फ़ंक्शन(function)
है।
और इस कॉल के लिए,
कंपाइलर एक ही अप्रत्यक्ष
कोड उत्पन्न करता
है। अब क्या होगा?
अब सोचना बंद। यह
कॉल था और यही वह फंक्शन(function)
है जिससे कंपाइलर
जेनरेट होता है।
इनसे कॉल होती है
जो उत्पन्न हो रही
है यही वह है जो स्टैटिक
टाइम पैदा कर रहा
है। अब क्या होता
है, दो परिदृश्य हैं
कि पी वास्तव में
एब ऑब्जेक्ट(object) की
ओर इशारा करता है।
अगर यह एब ऑब्जेक्ट(object)
को इंगित करता है
तो इसमें वर्चुअल(virtual)
फंक्शन(function) टेबल(table)
पॉइंटर(pointer) है जो
इसे b के इस वर्चुअल(virtual)
फंक्शन(function) टेबल(table)
पर जाता है जो इसे
मिला है। यह फंक्शन(function)
0 के 0 वें फंक्शन(function)
को चुनता है और कॉल
करता है, इसलिए इसे
b :: g कहते हैं।
लेकिन यदि p यहाँ पर
ad object की ओर इशारा कर
रहा है तो इसमें एक
अलग फंक्शन(function) पॉइंटर(pointer),
वर्चुअल(virtual) फंक्शन(function)
टेबल(table) पॉइंटर(pointer)
है। जब यह उस पॉइंटर(pointer)
वीपी पॉइंटर(pointer) VFT
पर ट्रेस होता है
तो यह वास्तव में
d का वर्चुअल(virtual) फंक्शन(function)
टेबल(table) प्राप्त
करता है। यह 0 वें
फंक्शन(function) को चुनता
है जो कि यह फंक्शन(function)
है, जो अब d :: g के साथ
होता है क्योंकि
यह वास्तव में एड
ऑब्जेक्ट(object) को पॉइंट
करता है इसलिए यह
टेबल(table) अलग है। फिर
यह मापदंडों को पास
करता है और कॉल करता
है कि स्वाभाविक
रूप से डी :: जी को एक
कहा जाएगा।
इसके साथ, फ़ंक्शन(function)
पॉइंटर(pointer) की तालिका
का सरल तंत्र, इसलिए
हम इस से क्या सीखेंगे,
यदि कोई क्लास(class)
पॉलीमोर्फिक(polymorphic)
है यदि एक प्रकार
पॉलीमोर्फिक(polymorphic)
है यदि इसमें कम से
कम एक वर्चुअल(virtual)
फ़ंक्शन(function) है तो
उस क्लास(class) के लिए
एक वर्चुअल(virtual) फ़ंक्शन(function)
होगा तालिका, जिसमें
वे सभी वर्चुअल(virtual)
फ़ंक्शंस होंगे,
जिन्हें तालिका में
एक के बाद एक उस क्रम
में सूचीबद्ध किया
गया है, जिसमें उन्हें
परिभाषित किया गया
है। यहां हमारे पास
केवल एक प्रविष्टि
है क्योंकि हमारे
पास केवल एक वर्चुअल(virtual)
फ़ंक्शन(function) है।
यदि वहाँ अधिक हैं
तो अधिक प्रविष्टियाँ
होंगी और जैसे ही
क्लास(class) विशेष होता
है कंपाइलर चेक वर्चुअल(virtual)
फ़ंक्शन(function) को क्लास(class)
को फिर से परिभाषित

Hindi: 
करता है यदि वह ऐसा
करता है तो वह अपनी
वर्चुअल(virtual) फ़ंक्शन(function)
तालिका में संबंधित
प्रविष्टि को बदल
देता है और उस संस्करण
के साथ बदल देता है
जिसमें ओवरराइड होता
है।
और फिर हमेशा सीधा
कॉल करने के बजाय
एक कॉल करता है जैसे
कि यह एक स्टैटिक
टाइप कॉल है जैसे
यह जहां यह स्पष्ट
रूप से कहता है कि
फ़ंक्शन(function) क्या
है, यह कहता है कि
मुझे रनटाइम में
फ़ंक्शन(function) के बारे
में पता नहीं है तालिका
0 वां फ़ंक्शन(function)
और जो भी फ़ंक्शन(function)
पॉइंटर(pointer) है, वह
आपका फ़ंक्शन(function)
है।
इसलिए, वर्चुअल(virtual)
फ़ंक्शन(function) तालिका
ऑब्जेक्ट(object) के प्रकार
के आधार पर अलग-अलग
होगी, लेकिन उसी तंत्र
द्वारा इस फ़ंक्शन(function)(function)
के लिए 0 वें स्थान
में रनटाइम प्रविष्टि
को उचित रूप से आधार
क्लास(class) या फ़ंक्शन(function)
में या तो फ़ंक्शन(function)
के लिए एक बिंदु कहा
जाएगा। व्युत्पन्न
क्लास(class) में इस बात
पर निर्भर करता है
कि मेरे पास किस प्रकार
की वस्तु है और इसलिए
मैं किस प्रकार के
वर्चुअल(virtual) फंक्शन(function)
टेबल(table) की ओर इशारा
कर रहा हूं। मूल वर्चुअल(virtual)
फ़ंक्शन(function) मैं
पॉइंटर(pointer) टेबल(table)
तंत्र है जिसके द्वारा
हम चीजें कर सकते
हैं।
जैसा कि मैंने कहा
कि जब भी कोई क्लास(class)
वर्चुअल(virtual) फ़ंक्शन(function)(function)
को परिभाषित करता
है तो एक छिपा हुआ
सदस्य(member) चर क्लास(class)
में जोड़ा जाता है
जो यहाँ इंगित करता
है। और रनटाइम के
दौरान इनवोकेशन अप्रत्यक्ष
रूप से इसके माध्यम
से होता है और यह आरटीटीआई(RTTI)
के नाम से जाना जाता
है। हम RTTI के बारे
में अधिक बात करेंगे
जो पूरे पॉलीमॉर्फिक(polymorphic)
सिस्टम की रन-टाइम
टाइप सूचना है।
यह एक और उदाहरण है,
उदाहरण जिसे हमने
एक बाध्यकारी अभ्यास
के रूप में हल किया
था ताकि आप यहां देख
सकें कि यह आपके आगे
के चित्रण के लिए
है। यह मुख्य रूप
से आपके अपने काम
करने के लिए है, लेकिन
हमारे पास एक क्लास(class)
ए है और उससे विशिष्ट
है कि हमारे पास क्लास(class)
बी है, उससे विशिष्ट
है कि हमारे पास क्लास(class)
सी है। और कक्षा ए
में एक पॉलीमोर्फिक(polymorphic)
फ़ंक्शन(function) है, जिसमें
एक वर्चुअल(virtual) कार्य
होता है इसलिए स्वाभाविक
रूप से पूरे पदानुक्रम(hierarchy)
है पॉलीमोर्फिक(polymorphic)
और इसलिए, इस पदानुक्रम(hierarchy)
पर किसी भी क्लास(class)
की सभी वस्तुओं पर
एक वर्चुअल(virtual) फ़ंक्शन(function)
टेबल(table) पॉइंटर(pointer)
होगा।
इसलिए यदि मेरे पास
ऑब्जेक्ट(object) ए है,
तो ऑब्जेक्ट(object) ए
कहें, तो इसमें डेटा
सदस्य(member) होंगे जो
दिलचस्प नहीं हैं
इसलिए हमने उन्हें
सूचीबद्ध नहीं किया
है, लेकिन इसमें एक
वर्चुअल(virtual) फ़ंक्शन(function)(function)
टेबल(table) पॉइंटर(pointer)
होगा जो कक्षा ए के
वीएफटी(VFT) को इंगित
करेगा और कितने प्रविष्टियाँ
होंगी? एक वर्चुअल(virtual)
फंक्शन(function) f और एक
वर्चुअल(virtual) फंक्शन(function)
g है। तो वहाँ एक वर्चुअल(virtual)
समारोह है वहाँ एक
वर्चुअल(virtual) समारोह
जी है।
लेकिन जब यह बी करने

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

Hindi: 
में माहिर है तो आपने
एच को भी एक वर्चुअल(virtual)
कार्य किया है। तो
क्या होगा? स्थान
दो में एक तीसरा फ़ंक्शन(function)(function)
जुड़ जाएगा। और 0 और
1 का क्या होगा? F को
A में परिभाषित किया
गया था और B के ऊपर
सिर का नाम है। इसलिए,
f के लिए 0 वीं प्रविष्टि
छिपी हुई है। अब, एक
कोलन-कोलोन f के स्थान
पर आपके पास b :: f है।
जी को एक वर्चुअल(virtual)
फ़ंक्शन(function) के रूप
में भी परिभाषित
किया गया था क्योंकि
यह स्थान एक में रहता
है, लेकिन क्लास(class)
बी ने जी को अधिलेखित
नहीं किया है। इसलिए,
जब आप विरासत में
लेते हैं, तो आप वास्तव
में फ़ंक्शन(function)
नंबर एक के रूप में
समान a :: g प्राप्त
करते हैं। और h आपने
इसे एक वर्चुअल(virtual)
फंक्शन(function) बना दिया
है इसलिए वर्चुअल(virtual)
फंक्शन(function) टेबल(table)
एक अतिरिक्त फंक्शन(function)
पॉइंटर(pointer) के साथ
जुड़ जाता है।
जैसा कि आप सी वस्तु
पर आते हैं कि आपने
क्या किया है आपने
जी को ओवरराइड किया
है। तो, जो आपको मिलता
है, आपने एफ के साथ
कुछ भी नहीं किया
है, इसलिए एफ बस विरासत
में मिला है। तो आपको
0 वीं प्रविष्टि में
b :: f मिला है, जो कि
b- कोलोन-कोलोन f है।
लेकिन यह एंट्री
नंबर a :: g था, लेकिन
अब आपके पास लिखा
हुआ है, इसलिए यह c-colon-colon
g के साथ लिखा जाता
है।
प्रवेश संख्या दो
बी:: थी। क्लास बी
में एच फ़ंक्शन(function)
जो यहाँ पर लिखा गया
है, इसलिए आपको सी
:: एच मिलता है, यह है
कि वर्चुअल(virtual) फ़ंक्शन(function)
टेबल(table) कैसे बढ़ती
रहेगी और यह मूल रूप
से आपको बताएगा कि
क्यों हमने कहा कि
एक बार इस पदानुक्रम(hierarchy)
पर वर्चुअल(virtual) हो
जाता है वर्चुअल(virtual)
बने रहना होगा क्योंकि
एक बार यह कि संकलक
बनाने के निर्णय
के रूप में और यहाँ
मैंने दिखाया है
कि इस कोड के संकलन
संस्करण क्या होंगे।
तो आप यह कह सकते हैं
कि यह वर्चुअल(virtual)
फंक्शन(function) टेबल(table)
एंट्री 0 पर जाता है,
जी टेबल(table) एंट्री
1 में जाता है, लेकिन
जहां मैं अगर पॉइंटर(pointer)
एच करता हूं तो मेरे
पास स्टैटिक बाइंडिंग(binding)
है, स्पष्ट फ़ंक्शन(function)(function)
कॉल करता है क्योंकि
यह फ़ंक्शन(function)(function)
गैर-वर्चुअल(virtual) था।
जबकि जब मैं इसे pb
के साथ करता हूं, तो
यह क्लास b टाइप की
ओर इशारा होता है,
तब वे इसे वर्चुअल(virtual)
फंक्शन(function) टेबल(table)
के माध्यम से बाहर
लाते हैं क्योंकि
यहां क्लास b में वर्चुअल(virtual)
फंक्शन(function) हो गया
है।
तो कृपया इस पर काम
करें, कृपया इस निर्माण
को बहुत ध्यान से
समझने की कोशिश करें
और इस स्रोत अभिव्यक्ति
के माध्यम से काम
करें और जहाँ आप स्थैतिक
बाध्यकारी हैं और
जहाँ आपके पास डायनामिक(dynamic)
बंधन है, की संकलित
अभिव्यक्ति के विरुद्ध,
ताकि आप इसे भी समझ
पाएँगे।
कर्मचारियों के वेतन
आवेदन के लिए इसका
लाभ और अभिनव समाधान
को संक्षेप में प्रस्तुत
करने के लिए जो सी
में फ़ंक्शन(function)
पॉइंटर्स(pointers) का
उपयोग करता है हमने
यह बताने के लिए नींव

Hindi: 
रखी है कि वर्चुअल(virtual)
फ़ंक्शन(function) पॉइंटर(pointer)
टेबल(table) का उपयोग
करके वर्चुअल(virtual)
फ़ंक्शन(function) कैसे
कार्यान्वित किए
जाते हैं। कृपया
इसे और अधिक स्पष्ट
रूप से समझने की कोशिश
करें ताकि डायनामिक(dynamic)
प्रेषण के बारे में
कोई भ्रम आपके दिमाग
में स्पष्ट हो।
