C ++ యొక్క ప్రోగ్రామింగ్ నుండి మాడ్యూల్ 26 కు స్వాగతం.
 మేము C ++ లో ఇన్హెరిటెన్స్ స్ట్రక్చర్ చూశాము.
 సాధారణంగా పాలిమార్ఫిజం అని పిలువబడే ఆబ్జెక్ట్-ఓరియెంటెడ్ ఇంప్లిమెంటేషన్‌కు మద్దతు ఇవ్వడానికి మేము సి ++ యొక్క అత్యంత శక్తివంతమైన లక్షణాలపై దృష్టి పెడతాము.
 పాలిమార్ఫిజం యొక్క చర్చలో మనం మరింత లోతుగా వెళ్ళేముందు, క్లాస్ సోపానక్రమంలో సాధ్యమయ్యే కాస్టింగ్ పరంగా మరికొంత అవగాహనతో మనల్ని మనం సిద్ధం చేసుకోవాలి.
 మరియు స్టాటిక్ మరియు డైనమిక్ బైండింగ్ మధ్య ప్రధాన వ్యత్యాసం.
 కాబట్టి, ఈ డైనమిక్ బైండింగ్ చర్చ కొన్ని మాడ్యూళ్ళను కవర్ చేస్తుంది మరియు ఇది మొదటిది మరియు సి ++ లోని పాలిమార్ఫిజం యొక్క పూర్తి అవగాహనకు దారి తీస్తుంది.
 అందువల్ల, ఫ్రేమ్‌వర్క్ కాస్టింగ్ మరియు స్టాటిక్ మరియు డైనమిక్ బైండింగ్ మీ స్క్రీన్ యొక్క ఎడమ వైపున అందుబాటులో ఉంటుంది.
 కాబట్టి కాస్టింగ్ గురించి మాట్లాడుకుందాం.
 కాస్టింగ్ మనందరికీ తెలుసు, మీ అందరికీ తెలుసు సి.
 అందువల్ల, కాస్టింగ్ ప్రాథమికంగా ఒక రకమైన విలువను నిర్వహిస్తుందని మీకు తెలుసు, కొన్ని రకాలు ఉపయోగించబడతాయి, మరికొన్ని రకాలు మరొక రకాన్ని సూచిస్తాయి.
 కాబట్టి, ఉదాహరణకు, ఇక్కడ నేను పూర్ణాంక విలువ వేరియబుల్, d అనేది డబుల్ డబుల్ వేరియబుల్ మరియు నేను d / i వ్రాస్తున్నాను.
 అందువల్ల, నేను d అని చెబితే, నేను చెబితే / అప్పుడు దాని అర్థం / ఫ్లోటింగ్ పాయింట్ సంఖ్యల విభజన.
 కాబట్టి, ఇక్కడ అవసరం డబుల్ డబుల్) విలువ, కానీ నేను అందించినది, నేను పూర్ణాంక విలువను అందించాను.
 కాబట్టి, ఇది ఇప్పటికీ సి లో పనిచేస్తుంది. ఇది ఎలా పని చేస్తుంది? అందువల్ల ఈ పూర్ణాంక విలువను డబుల్ డబుల్ విలువగా మార్చడం మరియు తరువాత ఉపయోగించడం ద్వారా కొన్ని ప్రక్రియలు చేయాలి.
 కాబట్టి, ఈ యంత్రాంగం కాస్టింగ్ యొక్క విధానం, ఇది రెట్టింపుగా చొప్పించబడింది మరియు తరువాత ఉపయోగించబడుతుంది.
 కాబట్టి, ఇది మనం చూసిన ఒక సాధారణ and హ మరియు సి లో దీనిని మనందరికీ తెలిసిన మిశ్రమ మోడ్ ఆపరేషన్ అని సూచిస్తారు.
 ఇప్పుడు, ప్రారంభాన్ని కొంచెం ఎక్కువగా అభివృద్ధి చేద్దాం, కాస్టింగ్ ఉండవచ్చని మాకు తెలుసు లేదా అది స్పష్టంగా ఉంటుంది.
 ఉదాహరణకు, ఏ రకమైన వేరియబుల్ నేను పూర్ణాంక వేరియబుల్ అని మొదట చూడండి, d అనేది డబుల్ వేరియబుల్ మరియు p అనేది పాయింటర్ వేరియబుల్ పాయింటర్ రెట్టింపు.
 కాబట్టి, నేను i నుండి d వరకు అసైన్‌మెంట్ చేస్తే, అది రెట్టింపు మరియు అది పూర్ణాంకం.
 కాబట్టి, వాస్తవానికి అవి ఒకే రకమైన నియామకానికి సాధ్యం కాదు, కానీ స్పష్టంగా అది పూర్ణాంకాన్ని రెట్టింపు చేస్తుంది మరియు అలా చేయడానికి నన్ను అనుమతిస్తుంది.
 I కి కేటాయించబడుతున్న రివర్స్‌ను నేను రెట్టింపు చేయగలను. ఇది కూడా అనుమతించబడుతుంది, కాని సాధారణ కారణంతో ఒక మినహాయింపుతో డబుల్ చాలా పెద్ద డేటా రకం, అయితే int ఒక చిన్న డేటా రకం, కాబట్టి కొంత డేటా పోతుంది . వెళ్తుంది.
 దీనికి విరుద్ధంగా, నేను సి స్టైల్ కాస్టింగ్ అని పిలవబడేదాన్ని ఉపయోగించగలను, ఇది అందుబాటులో ఉన్న విలువకు ముందు అవసరమైన రకాన్ని ప్రసారం చేస్తుంది మరియు దానిని స్పష్టమైన కాస్టింగ్ అని పిలుస్తారు.
 ఇప్పుడు కంపైలర్ కేకలు వేయదు.
 కాబట్టి, నేను p వంటిది చేయటానికి ప్రయత్నిస్తే నేను ఒక పాయింట్ r మరియు నేను ఒక పూర్ణాంకం, నేను p ని కేటాయించాలనుకుంటే అది లోపం అని మీరు ఖచ్చితంగా చెప్పవచ్చు, మీరు ఖచ్చితంగా డబుల్ పాయింట్ తీసుకొని దానిని పూర్ణాంకంగా ఉపయోగించలేరు.
 నేను స్పష్టంగా ప్రసారం చేస్తే సి కంపైలర్ దీన్ని అనుమతిస్తుంది.
 కాస్టింగ్ యొక్క ప్రాథమిక నియమాలు ఇవి.
 ఇప్పుడు దానిని C ++ కు విస్తరించడానికి ప్రయత్నిద్దాం.
 అందువల్ల, అంతకుముందు మేము Int (పాయింటర్), డబుల్ ఎట్ సెటెరా రకాలు గురించి మాత్రమే మాట్లాడుతున్నాము.
 ఇప్పుడు, నాకు రెండు తరగతులు A మరియు B ఉన్నాయి మరియు నాకు రెండు వస్తువులు ఉన్నాయి, నాకు రెండు పాయింటర్లు ఉన్నాయి, ఒకటి రకం A మరియు ఒకటి రకం B యొక్కది, ఇది A యొక్క చిరునామాను కలిగి ఉంటుంది మరియు B యొక్క చిరునామా ఉంచుతుంది
 అసైన్‌మెంట్ ఇది కాస్టింగ్ లోపం ఎందుకంటే ఈ అసైన్‌మెంట్ ఏమి చెబుతోంది? B కి కేటాయించినది సగటు a; ఇది ఇప్పుడు ఆపరేటర్ అసైన్‌మెంట్ అని మనందరికీ తెలుసు b.
 కాబట్టి, దీని అర్థం ఈ తరగతి A, అది కలిగి ఉన్న తరగతి A కి చెందినది, దీనికి ఆపరేటర్ `= 'ఉంది, ఇది B రకం యొక్క ఒపెరాండ్ తీసుకుంటుంది, ఇది ప్రస్తుతం లేదు.
 మేము తారాగణం స్పష్టంగా ప్రసారం చేయడానికి ప్రయత్నిస్తే, అది కూడా విఫలమవుతుంది ఎందుకంటే స్పష్టమైన తారాగణం నిర్వచించబడలేదు.
 పూర్ణాంకానికి ఇష్టం లేదు, పూర్ణాంకానికి రెట్టింపుగా లేదా పూర్ణాంకానికి ఎలా మార్చాలో మీకు తెలుసు.
 అందువల్ల, మీరు వాటిని రివర్స్ మార్గంలో చేయడానికి ప్రయత్నిస్తే, అది విఫలమవుతుంది.
 మీరు B కి పాయింటర్‌లో రెండు రకాల పాయింటర్లను ఉంచడానికి ప్రయత్నిస్తే, అది విఫలమవుతుంది, ఇతర దిశ కూడా విఫలమవుతుంది.
 అందువల్ల, ఇవన్నీ వైఫల్యాలు ఎందుకంటే మీకు అలా చేయడానికి అనుమతి లేదు.
 మిమ్మల్ని బలవంతం చేయగల ఏకైక విషయం ఏమిటంటే మీరు & b, & b అని టైప్ చేసి A * కి బలవంతం చేయవచ్చు.
 అందువల్ల మీరు సంబంధం లేని తరగతుల పాయింటర్‌ను మరొకదానికి మార్చవచ్చు, కానీ బలవంతంగా.
 సహజంగానే, మీరు దీన్ని చేయలేరు p = q అనుమతించబడదు.
 ఇది B *, ఇది A *.
 మీరు అప్పగింతను సృష్టించలేరు, మీరు ఉపయోగించలేరు.
 B * A * పాయింటర్‌గా మారుతుందని మీరు బలవంతంగా చెబితే, మీరు ఈ నియామకాన్ని సృష్టించవచ్చు.
 దీని సుష్ట కూడా పని చేస్తుంది.
 కాబట్టి, ప్రాథమికంగా మనం C ++ ను ప్రారంభించినప్పుడు, తరగతుల మధ్య కాస్టింగ్ కథ ఉంది.
 ఇప్పుడు, సంబంధం లేని తరగతుల మధ్య మనం చూసినట్లుగా మేము కాస్టింగ్ చేస్తే, ఫలితాలు చాలా అనూహ్యమైనవి.
 అందువల్ల, నాకు రెండు సారూప్య తరగతులు మాత్రమే ఉన్నాయి.
 ఇప్పుడు, నేను డేటా సభ్యులను బహిరంగంగా ఉంచాను.
 నేను మీకు చూపించాలనుకుంటున్నాను.
 అందువల్ల, ఈ డేటా సభ్యులు ప్రారంభించబడ్డారు మరియు నాకు రకం P యొక్క పాయింటర్ ఉంది, అది A నుండి Q చిరునామాను కలిగి ఉన్న ఒక రకాన్ని కలిగి ఉంటుంది మరియు నేను విలువలను ముద్రించాను, వాస్తవానికి విలువలు సరిగ్గా ముద్రించబడతాయి.
 a. ; p -> i ప్రాథమికంగా a.i ఇది 5, q -> d 7.2.
 ఇప్పుడు, నేను దానిని బలవంతంగా ప్రసారం చేస్తానని అనుకుందాం.
 కాబట్టి, నేను బలవంతంగా ప్రసారం చేస్తే, నేను కోరుకున్నది ఇదే అని చెప్పాను.
 ఇది ఒక వస్తువు మరియు నేను పాయింటర్‌ను ఒక బిందువుగా వేశాను, ఆపై నేను దీన్ని చేయడానికి ప్రయత్నిస్తున్నాను.
 ఇది ప్రింట్ చేస్తుంది.
 మీరు దీన్ని ప్రయత్నిస్తే అది ప్రింట్ చేయవలసిన అవసరం లేదు.
 నా సిస్టమ్‌లో అది ప్రింట్ చేసింది, కాని ఇది ఖచ్చితంగా కొంత చెత్తను ప్రింట్ చేస్తుంది.
 ఇది ఎందుకు జరుగుతోంది? ఇది జరుగుతోంది ఎందుకంటే మీరు ఒక వస్తువును పూర్ణాంకంగా చూస్తే.
 మేము 32 బిట్ సిస్టమ్‌లో ఉన్నామని మాకు తెలియజేయండి.
 కాబట్టి, పూర్ణాంకానికి 4 బైట్లు ఉన్నాయి, దీనిలో ఈ విలువ 5 వ్రాయబడుతుంది.
 ఒక వస్తువులో, నాకు డబుల్ ఉంది, అది బహుశా 8 బైట్లు కలిగి ఉంటుంది.
 ఇప్పుడు, నేను A రకం పాయింటర్ తీసుకుంటే; దీని అర్థం, నేను p -> i అని వ్రాస్తే, కంపైలర్‌కు ఎల్లప్పుడూ 2 మరియు ఒక రకమైన వస్తువు అవసరమని తెలుసు, ఇది వరుసగా 4 బైట్లు తీసుకొని దానిని పూర్ణాంకంగా చేస్తుంది.
 ఇప్పుడు, నేను ఉల్లంఘించినది ఇదే.
 నేనేం చేశాను? నేను నిజంగా తాగాను మరియు B ని పరిష్కరించడానికి సూచించాను.
 ఇప్పుడు ఇక్కడ 8 బైట్లలో వ్రాయబడినది 7.2 అని వ్రాయబడింది, అయితే p కి ఇది A రకం అని తెలుసు.
 కాబట్టి, ఇది 4 బైట్లు చదవవలసి ఉందని తెలుసు మరియు ఇది ఒక పూర్ణాంకం అని భావిస్తుంది.
 కాబట్టి, 7.2 యొక్క ఫ్లోటింగ్ పాయింట్ పాయింట్ ప్రాతినిధ్యం మొదటి నాలుగు బైట్‌లను ఏకపక్షంగా చదివి, అది ఒక పూర్ణాంకం అని ఆలోచించడం ప్రారంభించి, పూర్ణాంకంగా ముద్రిస్తుంది.
 రివర్స్ గురించి ఆలోచించినప్పుడు నేను ఏమి చేస్తున్నాను? నాకు q టైప్ చేసే q పాయింటర్ ఉంది.
 కాబట్టి, నేను q -> d చేస్తే 8 బైట్లు డబుల్‌ను సూచిస్తాయని ఆశిస్తోంది.
 ఇప్పుడు, నేను ఈ వస్తువును సూచించాను q, అంటే ఇది వాస్తవానికి 8 బైట్లు చదువుతోంది, వీటిలో మొదటి 4 బైట్లు 5 యొక్క పూర్ణాంక ప్రాతినిధ్యం.
 తదుపరి 4 బైట్లు, అది ఏమిటో దేవునికి తెలుసు.
 ఇది జ్ఞాపకశక్తి యొక్క చెల్లని భాగం, అది అక్కడికి వెళుతుంది.ఇది విలువ వ్యాఖ్యానాన్ని తాత్కాలిక సంఖ్యగా తీసుకొని ప్రింట్ చేస్తుంది.
 కాబట్టి, కాస్టింగ్‌లో మీరు పొందగల ప్రాథమిక సమస్య ఇది.
 కాబట్టి, ప్రసారం చేయడం ప్రమాదకరమైన విషయం.
 ఇప్పుడు, మీరు సోపానక్రమంలో దీన్ని చేయడానికి ప్రయత్నిస్తే కాస్టింగ్ ఎలా ఉంటుందో చూద్దాం.
 కాబట్టి, మనకు క్లాస్ ఎ మరియు క్లాస్ బి ఉన్నాయి, ఇది ఎ యొక్క స్పెషలైజేషన్.
 అందువల్ల, నాకు రెండు తరగతి రకాల రెండు ఆధారాలు ఉన్నాయి.
 ఇప్పుడు ఇంతకుముందు సంబంధం లేని రకాలు సాధ్యం కానప్పుడు, ఒక రకమైన పాయింటర్‌ను మరొక బిందువుకు కేటాయించడం సాధ్యం కాలేదు, కానీ ఇప్పుడు నేను pb ని pa కి కేటాయించగలను మరియు ఇది అనుమతించబడుతుంది.
 నేను రివర్స్ పిబి అప్పగించడానికి పిబి చేయడానికి ప్రయత్నిస్తే అది అనుమతించబడదు.
 కారణం సులభం.
 నేను ఒక వస్తువును కలిగి ఉంటే మరియు B ఆ వస్తువు గురించి ఆలోచిస్తే, B వస్తువు ఏమి కలిగి ఉంటుంది? ఇది A యొక్క ప్రత్యేకత, కాబట్టి B వస్తువు అంతర్గతంగా ఒక వస్తువును కలిగి ఉంటుంది, ఇది మూల వస్తువు.
 కాబట్టి, నాకు టైప్ పా ఉంటే, ఇది టైప్ ఎ యొక్క పాయింటర్, అప్పుడు అది టైప్ ఎ యొక్క పాయింటర్.
 అప్పుడు, నేను దానికి పిబిని కేటాయించినప్పుడు, పిబి అంటే ఏమిటి? రకం pb B యొక్క పాయింటర్ ఉంది, ఇది ఈ వైపు పాయింటర్.
 కాబట్టి, నేను దీనిని and హించి A కి ఇచ్చినప్పుడు, అదే ప్రాంతం p a ని సూచిస్తుంది.
 కానీ, pa కి ఏమి తెలుసు, pa కి ఇది ఒక రకమైన పాయింటర్ అని తెలుసు, అంటే pa కి ఒక వస్తువు వస్తుందని తెలుసు.
 కాబట్టి, అది ఏమి చేస్తుంది? ఇది B యొక్క విస్తరించిన భాగాన్ని గ్రహించదు, కానీ అది చెల్లుబాటు అయ్యే ఒక వస్తువును పొందుతుంది, ఇది B వస్తువు యొక్క మూల భాగం మరియు మీకు ఆ వస్తువును మాత్రమే ఇస్తుంది.
 అందువల్ల, అలా చేస్తే సరిపోతుంది.
 మీరు దాని యొక్క పరిమిత వీక్షణను పొందుతారు.
 కానీ మీరు దీన్ని మరొక విధంగా చేయడానికి ప్రయత్నిస్తే, మేము పిబిని తీసుకొని దానిని వస్తువుకు సూచించడానికి ప్రయత్నిస్తే, పిబి విషయాలు ఆబ్జెక్ట్ బేస్ పార్ట్ అని తెలుసు, ఆపై మరిన్ని విషయాలు ఉన్నాయి.
 కాబట్టి, ఈ మొత్తం విషయం నిజంగా ఉనికిలో లేని B వస్తువు అని అనుకోవడానికి ప్రయత్నిస్తాము, ఒక వస్తువు మాత్రమే ఉంది.
 కాబట్టి, జ్ఞాపకశక్తిని ఉల్లంఘించి కనుగొనడం ప్రమాదకరం.
 కాబట్టి, అందుకే ఇది అనుమతించబడుతుంది.
 ఇది అనుమతించబడనప్పుడు రంగును మార్చనివ్వండి.
 మరియు మేము దీన్ని చేస్తున్నప్పుడు, నేను సోపానక్రమం రేఖాచిత్రానికి తిరిగి వెళితే, ఈ రేఖాచిత్రం B ISA A.
 నేను చేస్తున్నప్పుడు నేను B లేదా నిర్దిష్ట వస్తువు నుండి సాధారణీకరించిన వస్తువు వైపు కదులుతున్నాను కాబట్టి నేను పైకి వెళ్తున్నాను.
 కాబట్టి, ఇది అనుమతించబడే అప్‌కాస్ట్ అని మేము చెప్తాము.
 నేను క్రిందికి వెళ్ళడానికి ప్రయత్నిస్తే, నేను సాధారణీకరించిన వస్తువును తీసుకొని అది ఒక ప్రత్యేకమైనదిగా భావిస్తే, తిరస్కరించవలసిన డౌన్‌కాస్ట్ చెప్పండి.
 వాస్తవానికి, అదే ఉదాహరణలో మీకు సున్నా పాయింటర్ ఉంటే ఏమి జరుగుతుందో కూడా చూపించాను.
 వాస్తవానికి మీరు ఏ రకమైన వస్తువులను అయినా తీసుకోవచ్చు మరియు అవును ఆ చిరునామాను సున్నా పాయింటర్‌లో ఉంచండి, మీరు రకాన్ని కోల్పోతారు.
 అదేవిధంగా, మీరు రివర్స్ చేయవచ్చు.ఈ అక్షరదోషాలు ఇక్కడ అక్షర దోషం అని నేను అనుకున్నదాన్ని రివర్స్ చేయడానికి ప్రయత్నించండి. నేను 
 దీనిని తరువాత ప్రదర్శనలో సరిదిద్దుతాను.
 కాబట్టి, p కి పివి ఇస్తే లేదా పిబికి పివి ఇస్తే ఈ లోపాలన్నీ సంభవిస్తాయి ఎందుకంటే పిఎ సున్నా * పివి సున్నా * పాయింటర్.
 కాబట్టి, ఇది ఎక్కడ సూచిస్తుందో తెలియదు? ఇది ఎన్ని ప్రాంతాలను ఏ పరిమాణాన్ని సూచించాలో తెలియదు.
 కాబట్టి, మీరు దానిని తీసుకొని దానిని A గా అర్థం చేసుకోవడానికి ప్రయత్నిస్తే, అప్పుడు మీకు అన్ని రకాల ప్రమాదాలు ఉన్నాయి.
 కాబట్టి, అవి అనుమతించబడవు, కానీ మీరు నిజంగా ఏదైనా రకమైన పాయింటర్‌ను తీసుకొని శూన్య పాయింటర్‌లో ఉంచితే చాలా మంచిది.
 వాస్తవానికి, C ++ లో మనం దాని కోసం ఏదైనా ఉపయోగం చెడుగా జరుగుతుందని చూస్తాము.
 ఇప్పుడు, మేము అప్‌కాస్టింగ్‌ను పరిశీలిస్తే, మేము డేటా సభ్యులతో మాత్రమే ఒక తరగతిని విస్తరించగలము మరియు ఒక వస్తువు కోసం విలువ 2 ను ఉంచినట్లయితే, ఆ డేటా భాగం ఒక వస్తువు. ఎవరి విలువ 3 మరియు 5.
 కాబట్టి, ఇది 2 అనే వస్తువు.
 ఇది 3, ఒక భాగం మరియు 5 లో ఉన్న బి ఆబ్జెక్ట్.
 ఆపై మేము వారి చిరునామాలను తీసుకొని ఫీల్డ్లను ప్రింట్ చేయడానికి ప్రయత్నిస్తే.
 మనకు 2 మరియు 3, 5 లభిస్తాయి.
 ఇది ఒక వస్తువును ముద్రిస్తుంది, ఇది b వస్తువును ముద్రిస్తుంది.
 ఇప్పుడు, మేము అప్కాస్ట్ చేసాము.
 ఇది నేను బిని గుర్తించి, ఎ.
 కాబట్టి, pa ఏమి చూడటానికి వస్తుంది? పా ఇక్కడ ఎత్తి చూపుతున్నాడు, కాని అతనికి ఒక జ్ఞానం మాత్రమే ఉంది.
 కాబట్టి, ఈ భాగాన్ని చూడటం మాత్రమే జరుగుతుంది.
 కాబట్టి, నేను pa -> dataA_ ను ప్రింట్ చేయడానికి ప్రయత్నిస్తే ఏమి జరుగుతుంది, అది ప్రింట్ చేస్తుంది మరియు మీరు expected హించిన విధంగా 3 పొందుతారు, కానీ మీరు ఈ pa-> డేటా B_ చేయడానికి ప్రయత్నిస్తే, మీరు దానిని ప్రింట్ చేయడానికి ప్రయత్నిస్తే, కంపైలర్ మీకు ఇస్తుంది లోపం ఎందుకంటే కంపైలర్‌కు pa అనేది ఒక డేటాబేస్_ సభ్యుడు లేని ఒక రకమైన పాయింటర్ (పాయింటర్) అని తెలుసు కాబట్టి, అది అనుమతించబడదు.
 అందువల్ల, ఉద్వేగభరితంగా ఉంటే, మీరు లోపం ఉన్న స్థితికి చేరుకునే పరిస్థితి లేదు, ఎందుకంటే మీరు తరగతి యొక్క మూల భాగాన్ని చేరుకుంటారు, ఇది పరిమిత ప్రాప్యతను మాత్రమే చేస్తుంది, ఇది మంచిది లేదా మీరు మరియు కంపైలర్. వాస్తవానికి ఉనికిలో లేని నిర్దిష్ట తరగతిలోని ఏదైనా భాగాన్ని యాక్సెస్ చేయడం.
 కాబట్టి, అప్‌కాస్టింగ్ సురక్షితం.
 డౌన్కాస్ట్ డౌన్కాస్టింగ్ ప్రమాదకరమని మీరు చాలా సులభంగా వాదించవచ్చు.
 నేను స్టాటిక్ మరియు డైనమిక్ బైండింగ్ యొక్క ప్రాథమిక భావనను పరిచయం చేస్తున్నాను మరియు నేను కాస్టింగ్ ప్రారంభించటానికి ముందు ఎందుకు చర్చించాను అనేది క్రమంగా స్పష్టమవుతుంది. అందువల్ల, నాకు చాలా సులభమైన పరిస్థితి ఉంది.
 నన్ను రెడ్ బ్యాక్ చేద్దాం
 కాబట్టి, చాలా సరళమైన పరిస్థితి బేస్ క్లాస్ మరియు ప్రత్యేకమైన డెరైవ్ క్లాస్ బి, క్లాస్ డి.
 మేము ఇంతకు ముందు చూశాము.
 కాబట్టి, బేస్ క్లాస్ f () పద్ధతిలో ఒక ఫంక్షన్ f () వారసత్వంగా పొందిన తరగతి నుండి తీసుకోబడింది మరియు తరువాత ఈ పద్ధతి భర్తీ చేయబడుతుంది.
 అతని గురించి ప్రత్యేకంగా ఏమీ లేదు.
 బేస్ క్లాస్‌కు మరొక ఫంక్షన్ (ఫంక్షన్) జి () ఉంది మరియు ఉత్పన్నమైన క్లాస్ (క్లాస్) కూడా ఆ ఫంక్షన్‌ను భర్తీ చేస్తుంది.
 దీనిలోని విభిన్న విషయం ఏమిటంటే, ఫంక్షన్ G విషయంలో, మేము మరొక అదనపు పద కీవర్డ్ వర్చువల్ వ్రాసాము మరియు ప్రవర్తన ఎలా మారుతుందో చూద్దాం.
 కాబట్టి, ఎల్లప్పుడూ ఈ రేఖాచిత్రాన్ని గుర్తుంచుకోండి.
 కాబట్టి, నాకు రెండు ఉదాహరణలు నిర్మించబడ్డాయి మరియు మనకు పిబి మరియు పిడి రెండూ రెండు పాయింటర్లు ఉన్నాయి, ఇవి స్థిర తరగతి రకానికి చెందినవి.
 కాబట్టి, నేను పిబి పాయింటర్ (పాయింటర్) లో ఒక బి చిరునామాను ఉంచాను మరియు ఇది పి క్లాస్ లో డి యొక్క చిరునామాను ఉంచాను, ఇది బి క్లాస్ రకానికి చెందిన పాయింటర్, అంటే నేను అప్‌కాస్ట్ చేస్తున్నాను.
 A అనేది ఒక వస్తువు. వాస్తవానికి ఇక్కడ పాయింటర్ ఈ రకమైనది.
 అందువల్ల, నేను ఇక్కడ ప్రాతినిధ్య పని చేస్తున్నాను.
 అందువల్ల, నేను అప్‌కాస్ట్ చేసాను.
 అదేవిధంగా, సందర్భం ప్రకారం నేను వ్రాసినది అదే.
 ఈ rb సూచన ఆబ్జెక్ట్ b కు సూచన, rd d అనేది వస్తువుకు సూచన, కానీ rd మాత్రమే B రకాన్ని సూచిస్తుంది.
 కాబట్టి, ఇది RD ను ప్రసారం చేస్తుంది మరియు D ను B రకం యొక్క వస్తువుగా భావిస్తుంది.
 ఇది ఈ సెట్టింగ్‌ను కలిగి ఉంది మరియు దీనిలో మేము అన్ని రకాల ఫంక్షన్‌లను పిలవడానికి ప్రయత్నిస్తున్నాము.
 కాబట్టి, మేము రెండు అంశాలను b మరియు d అని పిలుస్తున్నాము.
 మేము రెండు ఫంక్షన్లను పిలుస్తాము.
 కాబట్టి, నాలుగు కలయికలు మరియు మేము వాటిని మూడు రకాలుగా చెబుతాము.
 మొదట, మేము వస్తువును ఉపయోగించి ఒక ఫంక్షన్ అని పిలుస్తాము.
 కాబట్టి, బి. f (), బి. g (), డి. ఎఫ్ డి. g ().
 ఏ ఫంక్షన్ b .f () అని పిలువబడుతుందో మాకు తెలుసు. ఈ ఫంక్షన్‌ను బి అంటారు. g () అని పిలుస్తారు, ఈ ఫంక్షన్ (ఫంక్షన్) ను b .d () అని పిలుస్తారు, అయితే ఈ ఫంక్షన్ (ఫంక్షన్) అంటారు.
 ఆ తరగతికి సంబంధించిన పని అంటారు.
 కాబట్టి, ఇది ఆశ్చర్యం కలిగించదు.
 ఇప్పుడు, పాయింటర్ ద్వారా ఆ ఫంక్షన్ కాల్ చేయడానికి ప్రయత్నిస్తాము.
 కాబట్టి, pb b అనేది వస్తువు యొక్క పాయింటర్, p d అనేది వస్తువు యొక్క పాయింటర్, కానీ రెండూ B రకం.
 కాబట్టి, అవి B రకం కాబట్టి, నేను pb -> f () ను ఇన్వోక్ చేస్తే, B క్లాస్ (క్లాస్) యొక్క ఫంక్షన్ అమలు అవుతుందని నేను ఆశిస్తున్నాను.
 కాబట్టి, pb -> f () ఈ ఫంక్షన్‌ను B :: f () ను ప్రారంభించాలి.
 అదేవిధంగా, తదుపరి pb -> g () g ఫంక్షన్‌ను ప్రారంభించాలి; pd -> f () pd కూడా ఒక రకమైన బేస్ క్లాస్.
 కాబట్టి, పిడికి కూడా ఈ రెండు ఫంక్షన్ల గురించి మాత్రమే తెలుసు.
 కాబట్టి, నేను పిడి -> ఎఫ్ () చేస్తే, అది మళ్ళీ బి క్లాస్ యొక్క ఎఫ్ ఫంక్షన్‌ను ప్రారంభిస్తుంది.
 మీరు PD -> G () చేసినప్పుడు పూర్తిగా ఆశ్చర్యపోతారు.
 మైండ్ యు పిడి ఈ రకమైన పాయింటర్.
 ఇది వాస్తవానికి ఈ రకమైన వస్తువును సూచిస్తుంది.
 కాబట్టి, ఇక్కడ పిడి రకం.
 ఆ వస్తువు వాస్తవానికి ఇక్కడ ఉంది, కానీ నేను పద్ధతిని ప్రారంభించినప్పుడు, అది వాస్తవానికి ప్రకటన వస్తువును కలిగి ఉందని గుర్తించగలదు మరియు ఈ ఫంక్షన్ (ఫంక్షన్) ను అమలు చేయడానికి బదులుగా ఇది వాస్తవానికి ఈ ఫంక్షన్‌ను అందిస్తుంది. (ఫంక్షన్).
 మరియు డైనమిక్ బైండింగ్ అంటారు.
 కాబట్టి, డైనమిక్ బైండింగ్ అంటే ఏమిటి? బైండింగ్ అనేది ఏ ఫంక్షన్ అని పిలవబడుతుందో మీరు నిర్ణయించుకునే సందర్భంలో ఒక వ్యక్తీకరణ.
 అందువల్ల, ఓవర్‌లోడింగ్ పరంగా కూడా మేము బైండింగ్ రిఫరెన్స్ చేసాము, బహుళ టాస్క్‌లు ఓవర్‌లోడ్ ఉంటే ఏ పని కట్టుబడి ఉంటుంది.
 కాబట్టి, ఇది ఇలాంటి భావన.
 కాబట్టి, ఇది పి పాయింట్ (పి) లేదా పిబి -> ఎఫ్ () లేదా పిడి -> జి () ప్రశ్న, ఈ కాల్‌తో ముడిపడి ఉన్న నిర్దిష్ట ఫంక్షన్‌ను మనం అడగాలనుకుంటున్నాము.
 ఇప్పుడు, మనం చూసేది ఫంక్షన్ విషయంలో f బైండింగ్ స్థిరంగా ఉంటుంది అంటే బైండింగ్ బైండింగ్ ద్వారా పరిష్కరించబడింది. దీన్ని మళ్ళీ స్పష్టం చేద్దాం.
 కాబట్టి, ఇక్కడ ఫంక్షన్ f విషయంలో మరియు బైండింగ్ ఇక్కడ స్థిరంగా ఉంటుంది అంటే ఇది ఏ ఫంక్షన్ (ఫంక్షన్) అని పిలుస్తుందో అది పాయింటర్ రకాన్ని బట్టి ఉంటుంది.
 అంటే కంపైల్ టైమ్ కంపైలర్‌లో ఎప్పుడూ తెలిసిన, స్థిరంగా తెలిసిన ఏదో, పాయింటర్ రకం ఏమిటో తెలుసు, కాని వాస్తవం ఏమిటంటే ఈ పాయింటర్ (పాయింట్ ఎర్) ఇన్ బి ఆబ్జెక్ట్ బి ఆబ్జెక్ట్‌ను సూచిస్తుంది, పాయింటర్ అయితే D వస్తువుకు గురిపెట్టి.
 స్టాటిక్ బైండింగ్ విషయంలో, ఇది పరిగణించబడదు, ఇది B రకం పాయింటర్, ఇది కూడా B రకం పాయింటర్.
 కాబట్టి, నేను f ను ఇన్వోక్ చేస్తే, ఇది B :: f () బేస్ క్లాస్ యొక్క పద్ధతి.
 ఇది బేస్ క్లాస్ యొక్క ఎఫ్ పద్ధతిని కూడా ప్రారంభిస్తుంది.
 రెండవ సందర్భంలో, దృష్టాంతంలో మార్పు, ఇక్కడ మీరు వీటిని తిరిగి సందర్శిస్తే మేము డైనమిక్‌ను కట్టిపడేస్తున్నామని మేము చెప్తాము, అప్పుడు ఇవి రెండూ బేస్ టైప్ సిగ్నల్స్.
 మరియు ఈ బి వస్తువును సూచిస్తుంది, ఇది ప్రకటన వస్తువును సూచిస్తుంది.
 ఇప్పుడు, ఈ పాయింటర్ b ఆబ్జెక్ట్‌కు గురిపెట్టినప్పుడు, B :: g () ఇక్కడ ఈ ఫంక్షన్ (ఫంక్షన్) ప్రారంభించబడుతుందని మేము కనుగొన్నాము.
 పాయింటర్ ఇప్పటికీ B * రకానికి చెందిన ప్రత్యేక సజాతీయ వ్యక్తీకరణగా, కానీ అది g () ను ప్రారంభించినప్పుడు అది వాస్తవానికి సూచించే వస్తువు ప్రకటన రకం అని ఇవ్వబడుతుంది. వస్తువు D: g (), ఇది ఉత్పన్న తరగతిలో పిలువబడే ఓవర్రైడ్ ఫంక్షన్.
 కాబట్టి, ఇది పాయింటర్ రకంపై ఆధారపడి ఉండదు.
 అందువల్ల, కంపైలర్‌కు pb -> g () లేదా pd -> g () గా నిర్ణయించడానికి మార్గం లేదు, ఇది పాయింటర్ (పాయింటర్) రకం ద్వారా పరిష్కరించబడనందున దీనిని పిలుస్తుంది, కానీ దానిని నిర్ణయించడం వాస్తవానికి రన్ టైమ్‌లో ఉంది .
 వస్తువు యొక్క రకం ఏమిటి లేదా అది దేనిని సూచిస్తుంది.
 కాబట్టి, pd -> g మరియు ఫంక్షన్ల మధ్య B: g () లేదా D :: g (), ఈ బైండింగ్ యొక్క వ్యక్తీకరణ దానిని ఇక్కడ బంధిస్తుంది లేదా అది ఇక్కడ బంధిస్తుంది, ఈ పాయింటర్ ఆధారపడి ఉండదు.
 ఇది పాయింటి వస్తువుపై ఆధారపడి ఉంటుంది.
 ఇది పిడిపై ఆధారపడదు.ఇది పాయింటెడ్ ఆబ్జెక్ట్ రకాన్ని బట్టి ఉంటుంది.
 సూచించిన వస్తువు రకం ఇక్కడ రకం b గా ఉన్నట్లయితే, అప్పుడు బేస్ క్లాస్ యొక్క g పద్ధతి అమలు చేయబడుతుంది.
 ఇది d రకం అయితే, అప్పుడు ఉత్పన్నమైన తరగతి యొక్క G పద్ధతి వర్తించబడుతుంది.
 అందువల్ల, దీనిని స్టాటిక్ బైండింగ్‌కు విరుద్ధంగా డైనమిక్ బైండింగ్ అంటారు.
 ఇంకేముంది? ఈ కీ పదం ఫంక్షన్ ముందు వేరు చేయబడుతుంది.
 కాబట్టి, రెండు ఫంక్షన్ల కొరకు, దీనిని వర్చువల్ ఫంక్షన్ అంటారు, ఇక్కడ నేను ముందు భాగంలో వర్చువల్ వ్రాసాను మరియు దానిని వర్చువల్ కాని ఫంక్షన్ అంటారు.
 నేను ఇంతకు ముందు కలిగి ఉన్న నాన్-వర్చువల్ ఫంక్షన్ కలిగి ఉంటే.
 నేను స్టాటిక్ బైండింగ్ కలిగి ఉంటాను మరియు నాకు వర్చువల్ ఫంక్షన్ ఉంటే నేను డైనమిక్ బైండింగ్ కలిగి ఉంటాను, అక్కడ నేను ఆ ఫంక్షన్‌ను పాయింటర్ ద్వారా పిలిస్తే అది పాయింటర్ రకంపై ఆధారపడి ఉండదు, బదులుగా అది పాయింటర్ యొక్క నిజమైన ఆబ్జెక్ట్ రకంపై ఆధారపడి ఉంటుంది. పాయింటర్ రన్ సమయానికి సూచిస్తుంది.
 కాబట్టి, ఇది ఖచ్చితంగా స్టాటిక్ మరియు డైనమిక్ బైండింగ్ మధ్య ప్రాథమిక వ్యత్యాసం, నేను మీకు సెమాంటిక్స్ పరిచయం చేయడానికి ప్రయత్నిస్తున్నాను.
 మేము దీన్ని ఎందుకు చేస్తున్నామో అర్థం చేసుకోవడానికి ఇంకా చిన్న మార్గం ఉంది.
 మోడలింగ్ విషయంలో ఇది వాస్తవానికి ఎలా సహాయపడుతుంది, కానీ వర్చువల్ ఫంక్షన్ మరియు డైనమిక్ బైండింగ్ యొక్క ఈ ప్రాథమిక భావన మేము ఇక్కడ నుండి అర్థం చేసుకోవాలనుకుంటున్నాము.
 మరియు మనం సందర్భం ఉపయోగించే చివరి విభాగంలో సరిగ్గా అదే ప్రవర్తనను చూడవచ్చు.
 ఈ రెండు ఇక్కడ ఉన్నాయి సూచనలు BB వస్తువును సూచిస్తుంది; rd అనేది d వస్తువును సూచిస్తుంది.
 ఫంక్షన్ (ఎఫ్) ఎఫ్ కోసం నేను సందర్భం ద్వారా చేస్తే నాకు స్టాటిక్ బైండింగ్ ఉంది, అయితే నేను ఆర్బి మరియు ఆర్డి కోసం జి ఫంక్షన్ (ఫంక్షన్) గ్రా పద్ధతిని ప్రారంభిస్తే నేను ఎందుకంటే ఆర్డి డి ప్రకటన వస్తువును సూచిస్తుంది మరియు ఎందుకంటే RB ఒక వస్తువు వస్తువును సూచిస్తుంది.
 ఈ సందర్భంలో డైనమిక్ బైండింగ్ ప్రకారం, నేను పొందిన విలోమం యొక్క g ఫంక్షన్లను పొందుతాను.
 ఈ సందర్భంలో, నేను బేస్ క్లాస్ యొక్క g ఫంక్షన్‌ను ప్రారంభించాను.
 అందువల్ల, నేను ఫంక్షన్‌ను ఒక వస్తువుగా యాక్సెస్ చేస్తే అవి ఎల్లప్పుడూ స్థిరంగా ఉంటాయి.
 అవి ఎల్లప్పుడూ ఆ వస్తువు రకం మీద ఆధారపడి ఉంటాయి.
 నేను ఒక ఫంక్షన్ ద్వారా లేదా రిఫరెన్స్ ద్వారా పద్ధతులను ప్రారంభిస్తే, నేను స్టాటిక్ లేదా డైనమిక్ బైండింగ్ కలిగి ఉంటాను, అది నేను ఏ సభ్యునిపై ఆధారపడి ఉంటుంది. నేను చేస్తున్న ఫంక్షన్ ఒక వర్చువల్ కానిది, ఇక్కడ స్టాటిక్ బైండింగ్ ఉంటుంది లేదా సభ్యుల ఫంక్షన్ ఉన్నప్పుడు డైనమిక్ బైండింగ్ ఉన్న వర్చువల్ ఒకటి.
 కాబట్టి, మరింత నిర్మించబడే బైండింగ్ యొక్క ప్రాథమిక భావనను ప్రవేశపెట్టడం మాత్రమే.
 అందువల్ల, మొత్తంగా, మేము కాస్టింగ్ భావనను ప్రవేశపెట్టాము మరియు పైకి క్రిందికి ఉన్న ప్రాథమిక భావనను చర్చించాము మరియు అప్ కాస్ట్ సురక్షితం మరియు డౌన్ కాస్ట్ ప్రమాదకరమని గమనించాము.
 మేము దీన్ని చేసాము, ఎందుకంటే తరువాతి మాడ్యూల్‌లో, కాస్టింగ్ యొక్క ఈ భావనను బైండింగ్ సందర్భంలో ఉపయోగించాల్సి ఉంటుంది.
 ఆ తరువాత మేము స్టాటిక్ కాస్టింగ్ మరియు డైనమిక్ కాస్టింగ్ లేదా వర్చువల్ ఫంక్షన్ యొక్క ప్రాథమిక నిర్వచనాన్ని ప్రవేశపెట్టాము, ఇది కొత్త రకం సభ్యుల ఫంక్షన్, ఇది మేము మరిన్ని తరగతులలో ప్రదర్శిస్తున్నాము. 
 మేము తదుపరి మాడ్యూల్‌లో డైనమిక్ బైండింగ్ గురించి చర్చించడం కొనసాగిస్తాము.