మాడ్యూల్ 7 కు ప్రోగ్రామింగ్ లో C ++ లో స్వాగతం.
మేము ప్రాథమిక రెఫెరెన్స్ ను ( reference) చర్చించాము మరియు సూచన ద్వారా కాల్ యొక్క రెఫెరెన్స్ ను ( reference) పరిచయం చేశాము.
మరియు, మేము ఇచ్చిపుచ్చుకోవడం వంటి కొన్ని విధులు C ++ లో సూచన పద్ధతిలో కాల్ని ఉపయోగించడం ద్వారా మరింత మెరుగైన రీతిలో రాయబడతాయి.
ఒక ఫంక్షన్ కోసం రిఫరెన్స్ పరామిటర్( reference parameter) సాధారణ ఇన్పుట్ / అవుట్పుట్ పారామిటర్గా ఉండవచ్చు అని కూడా మేము చర్చించాము.
కాబట్టి, ఫంక్షన్ మామూలు పరామితిని మార్చడానికి మరియు అసలు పరామితికి పరిణామాత్మక మార్పులను మార్చాలనుకుంటే, మేము ఒక పారామితిగా నిర్వచించే ఎంపికను కూడా కలిగి ఉంటుంది, దీని ద్వారా అసలు పరామితి ద్వారా మాత్రమే ప్రారంభించబడుతుంది .
కానీ, దీనికి చేసిన మార్పులను కంపైలర్ అనుమతించదు.
మేము ఇప్పుడు కొనసాగి, ఫంక్షన్ యాంత్రికాల యొక్క ఇతర వైపు గురించి మాట్లాడతాము.
C లో, ఫంక్షన్ నుండి వెనక్కి తిరిగి వచ్చేలా మనము విధానాన్ని ఉపయోగిస్తాము; విలువ విధానం ద్వారా తిరిగి పిలుస్తారు.
పారామితులు వాస్తవమైన నుండి వాస్తవమైనవిగా కాపీ చేయబడినందున, రిటర్న్ విలువ( return value)ఎక్స్ప్రెషన్ (expression) నుండి కూడా కాపీ చేయబడుతుంది, మేము రిటర్న్ స్టేట్మెంట్లో (return statements) తిరిగి వ్రాసే చోట మేము ఆ ఫంక్షన్ విలువను ఎక్కడున్నాము.
కాబట్టి, C + + లో విరుద్ధంగా సూచన ద్వారా ఒక విలువను తిరిగి పొందడం సాధ్యమవుతుంది.
మనం ఏమి చెప్తుందో చూద్దాం.
కాబట్టి, మొదట మాకు రెండు వైపులా దృష్టి సారించండి.
ఎడమవైపు, మేము విలువ ద్వారా రిటర్న్ వచ్చాము; కుడి వైపున, మేము సూచన ద్వారా రిటర్న్ వచ్చాము.
కాబట్టి, ఎడమవైపున మేము ఒక ఫంక్షన్ C ++ లో ఒక సాధారణ C రిటర్న్ రూపం.
ఇది సూచన ద్వారా మాత్రమే కాల్ని ఉపయోగిస్తుంది.
మరియు కుడివైపున, దయచేసి రిటర్న్ టైప్ చేసిన తర్వాత మేము సూచన చిహ్నాన్ని కలిగి ఉన్నాము.
కాబట్టి, మనము రిటర్న్ వచ్చే భావం యొక్క సూచనను తిరిగి చెపుతున్నామని చెప్తే.
ఆపై, ఉపయోగం పోలి ఉంటుంది.
ఇక్కడ, మేము ఈ ఫంక్షన్ను ప్రార్థిస్తున్నాము; ఇక్కడ మనము మళ్ళీ ఈ ఫంక్షన్ ను ఇన్వోక్( invoke) చేద్దాము.
మరియు ఫంక్షన్ ఫలితంగా ఉంచడానికి, మరియు ఈ ప్రధానంగా మీరు ప్రభావం ఇల్యూస్ట్రేటింగ్ ప్రయోజనం కోసం.
నేను మరొక సూచన వేరియబుల్ బి( variable) ఉపయోగించారు.
కాబట్టి, బి తిరిగి ఇవ్వబడిన విలువకు సూచనను ఉంచుతుంది.
మీరు ఈ వైపున ఉన్న విలువ భాగాన్ని రిటర్న్ చూడాలని చూస్తే, ఈ రిఫరెన్స్ b స్థిరంగా ఉండాలని మీరు అర్థం చేసుకోవాలి.
ఎందుకు ఈ స్థిరంగా ఉండాలి? ఎందుకంటే మీరు సూచనల యొక్క బలహీనతలను గుర్తుకు తెస్తే, నేను ఒక వ్యక్తీకరణ j + k ను కలిగి ఉంటే, నేను ఒక సూచనను సృష్టించలేను ఎందుకంటే j + k తాత్కాలికంగా గణించబడుతుంది.
ఇప్పుడు, ఇక్కడ నేను కుడి వైపు ఏమి ఉన్నాయి? నేను ఒక ఫంక్షన్ ప్రవేశాన్ని కలిగి ఉన్నాను.
ఫంక్షన్ ప్రేరణ ఏమిటి? ఇది ఒక వ్యక్తీకరణ.
కాబట్టి, దానికి నేను ఒక వ్యత్యాసాన్ని వ్రాయలేను.
నేను ఒక స్థిరమైన సూచనను వ్రాయవలసి ఉంటుంది, ఇది ఈ సూచన ద్వారా సంరక్షించబడే తాత్కాలిక ప్రదేశం.
దీనిపై, స్థిరంగా వ్రాయడం ఏకరూపత కొరకు మాత్రమే.
ఇది నిజంగా అవసరం లేదు.
మీరు విధానం అర్థం ఒకసారి మీరు గ్రహించవచ్చు.
ఇప్పుడు అవుట్పుట్ చూద్దాము.
కాబట్టి, మొదటి అవుట్పుట్ ఇది ఇక్కడ ఉంది, ఇది ప్రింట్ చేస్తుంది, మరియు దాని చిరునామా.
తరువాత ఫంక్షన్ లోపల ఉంది.
ఫంక్షన్ పిలువబడింది.
ఈ ముద్రణ తరువాత, ఫంక్షన్ ఇక్కడ పిలువబడింది.
కాబట్టి, ఈ ప్రస్తావన ఉంది, ఇది మీరు ఈ x అవుట్పుట్ అయిన అవుట్పుట్.
సూచన ద్వారా ఇది కాల్.
కాబట్టి ఊహించిన విధంగా, మరియు x ఒకే చిరునామాను కలిగి ఉంటుంది.
చివరగా, మీరు ఈ మూడో అవుట్పుట్ చూస్తారు, ఇది ప్రధానమైనది, ఫంక్షన్ రిటర్న్( return) వచ్చిన తర్వాత.
మరియు, ఒక ఫంక్షన్ ఏమి చేస్తుంది? ఫంక్షన్ మీరు దాన్ని ఆమోదించిన విలువను తిరిగి అందిస్తుంది.
కాబట్టి, అది అదే విలువను రిటర్న్ పొందబోతుందని భావిస్తున్నారు.
కాబట్టి, b అదే విలువను రిటర్న్ ఇస్తుంది.
కానీ, ఇక్కడ మీరు b యొక్క చిరునామాను ప్రింట్ చేస్తే, అది ఒక చిరునామా లేదా x యొక్క చిరునామా నుండి భిన్నంగా ఉంటుంది.
మరియు, ఈ అంచనా; ఎందుకంటే ఇది విలువ ద్వారా రిటర్న్ వస్తుంది.
కాబట్టి, తిరిగి రావడమే x యొక్క కాపీ.
ఇది తాత్కాలికంగా ఉంది మరియు తాత్కాలికంగా బి యొక్క భాగాన్ని నేను కలిగి ఉన్నాను; బి లో ఒక సూచనగా.
రిఫరెన్సు వైపున అదే విధంగా ఆలోచించండి.
ఇక్కడ, మేము కాల్ ద్వారా చూస్తున్నాము, రిఫరెన్స్ ద్వారా తిరిగి వస్తాము.
మొదటి అవుట్పుట్ ఇక్కడ నుండి, ఇది మరియు దాని చిరునామా.
రెండవది x మరియు దాని చిరునామా.
సూచన ద్వారా కాల్; వారు ఒకేలా ఉండాలి.
అవి ఒకేలా ఉన్నాయి.
ఫంక్షన్ రిటర్న్ వచ్చిన తర్వాత మూడవ ఉత్పత్తి ఇక్కడ నుండి వచ్చింది.
అది b మాత్రమే కాదు అని మీరు చూస్తారు, b యొక్క ఈ చిరునామా కూడా ఒకటి; ఎందుకంటే వాస్తవానికి ఏది రిటర్న్ వచ్చిందంటే, తిరిగి ఇవ్వబడినది x యొక్క విలువ కాదు.
కానీ, తిరిగి ఇవ్వబడింది ఏమిటంటే x యొక్క చిరునామా కూడా; X యొక్క ప్రస్తావన, x యొక్క మారుపేరు.
కాబట్టి, b ఇప్పుడు x అనే మారుపేరు అవుతుంది.
మరియు, x ఏమిటి? x అనేది ఒక మారుపేరు.
కాబట్టి, b ఈ ప్రక్రియలో ఒక మారుపేరు అవుతుంది.
కాబట్టి, విలువ మరియు రిఫరెన్స్ ద్వారా తిరిగి వచ్చే మధ్య వ్యత్యాసం.
మళ్ళీ, మీరు సూచన ద్వారా తిరిగి ఉంటే, అది కొన్ని ఆసక్తికరమైన మరియు గమ్మత్తైన సమస్యలను చూపుతుంది.
కానీ మీరు రిఫరెన్స్ ద్వారా తిరిగి చేస్తే, మరల మరలా, పెద్ద నిర్మాణాల కాపీని మేము రిటర్న్ రావాల్సిన అవసరం ఉన్నట్లయితే దాన్ని నివారించవచ్చు.
కాబట్టి, అనేక ప్రదేశాల్లో మీరు సూచన ద్వారా రిటర్న్ రావచ్చు.
నేను చెప్పినట్లుగా, రిఫరెన్స్ ద్వారా రిటర్న్ రావచ్చు, కొన్నిసార్లు సమస్యాత్మకమైనది.
ఇక్కడ చూడండి.
ప్రస్తావన ద్వారా ఒక పరామితి (parameter) తీసుకునే ఫంక్షన్ మరియు అదే పరామితి సూచన ద్వారా రిటర్న్ వస్తుంది.
మరియు, ఈ లైన్ చూడండి మరియు మొదటి మీరు చూస్తున్నది సరైన కార్యక్రమం అని మీ కళ్ళను విశ్వసించవలసి ఉంటుంది.
మీరు అసైన్మెంట్ యొక్క ఎడమ వైపున సంభవించే ఫంక్షనల్ ఇన్క్రాక్షన్ను ఎప్పుడూ చూడలేదు.
ఫంక్షన్ ప్రవేశాన్ని ఎల్లప్పుడూ కుడి వైపున ఉంటుంది.
కాబట్టి, ఇక్కడ ఇది చెల్లుతుంది; ఎందుకంటే ఫంక్షన్ రిటర్న్ ఏమిటి? ఫంక్షన్ వాస్తవానికి అలియాస్ తిరిగి.
ఇది వాస్తవానికి చిరునామాను తిరిగి అందిస్తుంది; ఇది నిజంగా ఒక వేరియబుల్ రిటర్న్ ఉంది.
కాబట్టి, నేను దానికి కేటాయింపు 3 చేస్తున్నానని చెపుతుంటే, ఆ వాస్తవానికి నేను ఒక అసైన్మెంట్ చేస్తున్నాను.
కాబట్టి, అది అర్థం ఏమిటో చూద్దాం.
అవుట్పుట్ చూద్దాము.
మేము ఇక్కడ అవుట్పుట్లను కలిగి ఉన్నాము.
కాబట్టి, ఇది cout, ఫంక్షన్ ఈ సమయంలో పిలిచారు, x 10, ఇది 10, ఇది 10 అవుతుంది.
కాబట్టి, b మారింది 10.
కాబట్టి, నేను ఈ అవుట్పుట్ చూస్తున్నప్పుడు, అది 10, b 10.
ఆశ్చర్యం లేదు.
నేను ఇక్కడ మరోసారి పిలుస్తాను.
మరియు, రిటర్న్ సూచన 3 కు కేటాయించండి.
కాబట్టి, ఇది అర్థం ఏమిటి? నేను ఒక దానిని కాల్ చేస్తే, అప్పుడు ఒక మరియు x అలియాస్ అవుతుంది.
x ఒక మారుపేరు.
నేను సూచన ద్వారా రిటర్న్ చేస్తున్నాను.
కాబట్టి, నేను తిరిగివచ్చినది X యొక్క అలియాస్, ఇది ఒక మారుపేరు.
కాబట్టి, నేను ఇక్కడ రిటర్న్ వచ్చాను నిజానికి ఒక మారుపేరు.
కాబట్టి, మీరు ఎల్లప్పుడూ ఒక దానికి 3 కేటాయించవచ్చు.
ఆ నియామకం ఎక్కడ జరుగుతుంది? ఇది ఒక మారుపేరు.
కాబట్టి, కార్యక్రమంలో ఏం జరుగుతుంది? 
A. కాబట్టి, దీనిని బయటకు తనిఖీ చేయండి.
a ఒక మారింది 3.కాబట్టి, ఈ మీరు రిఫరెన్స్ ద్వారా రిటర్న్ చేస్తే సాధ్యం అవుతుంది.
ఇప్పుడు, మేము ముందుకు వెళ్తాము, తరువాత లక్షణాలను పొందటానికి, ఈ రకమైన కార్యక్రమంలో కొన్ని ప్రదేశాలలో ప్రయోజనం కోసం ఒక గమ్మత్తైన విషయం మరియు కొంచెం గందరగోళపరిచే విషయం ఎలా ఉపయోగించాలో చూపిస్తాము.
నేను చాలా తరచుగా ఈ రకమైన సంకేతాన్ని రాయాను.
కానీ, ఈ మంచి మార్గంలో ప్రయోజనం పొందవచ్చు ప్రదేశాలలో ఉన్నాయి.
మరియు మీరు ఇప్పటివరకు చూడని కుడి కాలమ్లో( right column) దీన్ని ఉపయోగించడం, మీరు నైపుణ్యం లేనివాడితే, దీనిని చేయటానికి ప్రయత్నిస్తున్నప్పుడు మీ పాదాలకు కాల్చవచ్చు.
ఈ సంకేతం చూడుము, ఇంతకు ముందుగా ఉన్న కోడ్ ఏమిటంటే.
అది ఇప్పుడు పారామితి (parameter) x ను తీసుకుంటుంది, అది సహజంగా ఒక మారుపేరు అవుతుంది, ఎందుకంటే అది సూచన ద్వారా కాల్ మరియు ఇది స్థానిక వేరియబుల్ (variable) td అది x తో t ప్రారంభించి, ఆపై t పెరుగుతుంది.
ఆపై, ఇక్కడ చూడండి, ముందు ఇది x రిటర్న్.
ఇప్పుడు, ఈ స్థానిక వేరియబుల్ ఇది రిటర్న్ గా రిటర్న్ అవుతుంది.
మరియు, మీరు ఇదే పని చేసాడు.
మొదటి రెండు పంక్తులు ఒకే విధంగా ఉన్నాయి.
వారు ఒకే ఉత్పత్తిని ఉత్పత్తి చేస్తారు.
సో, చూడండి ఏమీ లేదు.
ఈ రేఖ వద్ద చూడండి.
మీరు దీన్ని ఇక్కడ చేసారు.
కాబట్టి, మీరు దీన్ని చేసి, ఆశిస్తారో ప్రయత్నిస్తే, కొంత మార్పు ఒకదానికి లేదా అలాంటిదే అవుతుంది.
ఏమీ జరగదని మీరు ఆశ్చర్యపోతారు; ఎందుకంటే నీవు చేసిన పని ఏమిటి? మీరు నిజానికి ఒక స్థానిక వేరియబుల్ని తిరిగి ఇచ్చారు.
కాబట్టి, ఇక్కడ తిరిగి పొందడం అనేది స్థానిక వేరియబుల్ t కు ఒక సూచన.
మరియు అది చాలా ప్రమాదకరమైనది; ఎందుకంటే మీరు సూచనను రిటర్న్ ఇచ్చిన తర్వాత, ఫంక్షన్ కాల్( function call) ముగిసింది.
కాబట్టి, స్థానిక వేరియబుల్ అదృశ్యమయ్యింది, కానీ మీ సూచన ఇప్పటికీ సజీవంగా ఉంది.
సో, మీ సూచన నేను వేరియబుల్ కలిగి చెప్పారు.
ఫంక్షన్ కాల్ రద్దు చేయబడింది.
కాబట్టి, వాస్తవానికి అది లేదు.
ఈ వేరియబుల్ t ఇంకా ఉంది, అది చనిపోతుంది.
కానీ, మీరు ఆ సూచనను కలిగి ఉన్నారు.
కాబట్టి, ఈ రకమైన కార్యక్రమం ఫలితాలు చాలా అనూహ్యమైనవి.
కాబట్టి, దిగువ పంక్తి ప్రిస్క్రిప్షన్ అనేది సూచన ద్వారా రిటర్న్ ఉపయోగిస్తుంటే, ఒక స్థానిక వేరియబుల్ని ఎన్నటికీ రిటర్న్ ఇవ్వదు.
మీరు రిఫరెన్స్ ద్వారా రిటర్న్ వస్తే, ఎల్లప్పుడూ అందుబాటులో ఉన్న వేరియబుల్ను రిటర్న్ పంపుతారు, ఇది ఫంక్షన్ కాల్ ముగిసిన తర్వాత తార్కికంగా ప్రత్యక్షంగా ఉండాలి.
కాబట్టి, ఆ వేరియబుల్స్ ప్రపంచంగా ఉండవచ్చు, ఆ వేరియబుల్స్ మనం చూస్తాం నిశ్చల సభ్యులు కావచ్చు, ఆ పారామీటర్లలో (parameters) మీరు అసలు పారామీటర్లలో అలియాస్గా ఉండవచ్చని, ఇవి గరిష్టంగా విలువలను కేటాయించగలవు.
కానీ, ఒక ఫంక్షన్ కలిగి ఉన్న ఆటోమేటిక్ స్థానిక వేరియబుల్స్( local variables) కాదు, ఎందుకంటే మీరు నిజమైన ఇబ్బందులను పొందవచ్చు మరియు ఈ గుర్తించడం చాలా కష్టంగా ఉండే దోషాలు; ఎందుకంటే మీరు కోడ్లో ఏదైనా చూడలేరు.
కోడ్లో, ఇది శుభ్రంగా మరియు సులభమైన ప్రతిదీ ఉంది.
కానీ, ఇప్పటికీ మీ ఫలితాలు ఊహించలేనివి.
చివరగా, మనము ఈ మాడ్యూల్ ద్వారా చూసినట్లుగా, ఒక వేరియబుల్ మారుపేరు గురించి ప్రస్తావన ఉంది, ఇది ఒక విధానం.
ఇది మీరు వేరియబుల్ యొక్క విలువను మార్చకుండా అనుమతిస్తుంది, .
కాబట్టి, ఆ విధంగా అది చాలా సారూప్యతను మరియు భేదాలతో విభేదాలు కలిగి ఉంది.
కాబట్టి, నేను ఈ రెండు నిలువు వరుసలలో ఈ వ్యత్యాసాన్ని క్లుప్తీకరిస్తాను.
కాబట్టి, గమనికలు మరియు సూచనలు మధ్య, రెండు చిరునామాలు చూడండి.
గమనికలు చిరునామాను సూచిస్తాయి; సూచన కూడా చిరునామాను సూచిస్తుంది.
కాబట్టి, వారు ఆ మేరకు సమానంగా ఉంటారు, కానీ అవి విభిన్న మార్గాల్లో విభేదిస్తాయి.
ఉదాహరణకు, తరువాతి స్థానం చూడండి.
గమనికలు NULL కు సూచించవచ్చు; నేను ఒక పాయింటర్ (pointer) శూన్య కేటాయించవచ్చు.
అంటే ఏమిటి? అర్థాత్మకంగా, నేను ఎక్కడైనా గురిపెట్టి లేనని అర్థం.
ఇది నేను తీసుకున్న ఎత్తి చూపిన డేటాను(data) కలిగి లేదు.
కానీ, సూచన NULL ఉండకూడదు; ఎందుకంటే అది అలియాస్.
ఇది కేవలం అలియాస్.
సో, అది ఒక వేరియబుల్ ప్రభావాన్ని కలిగి ఉండాలి.
కాబట్టి, ఇది ప్రాథమిక వ్యత్యాసం.
పాయింటర్ ఇతర వేర్వేరు డేటా పాయింట్స్ (data points) నుండి, ఒక పాయింటర్ స్థిరంగా తప్ప, నేను నిజంగా అది సూచించే డేటా మార్చవచ్చు.
కాబట్టి, మీరు దీన్ని చేయగలరని ఉదాహరణ స్పష్టంగా చూపిస్తుంది.
P మొదటగా ఒక సూచించబడి ఉంటే, అప్పుడు అది కొన్ని పాయింట్ స్టేట్మెంట్లలో (point statements), అది బి కి సూచిస్తుంది.
కానీ, ఒక సూచన కోసం, మీరు ఏమి సూచిస్తున్నారంటే నిర్వచనం ద్వారా నిర్ధారిస్తారు; ఎందుకంటే ఇది ఒక వేరియబుల్ ప్రత్యామ్నాయ పేరు.
కాబట్టి, ఖచ్చితంగా నేను ఆ సూచనను మార్చుకోలేను మరియు పేరు వేరేగా చేయలేను.
ఉదాహరణకు, మేము ఈ లైన్ లోకి చూస్తున్నట్లయితే, మీరు ఇలా చేయాలని ప్రయత్నిస్తున్నట్లయితే, మీరు దాన్ని బి & b గా వ్రాసినట్లయితే, మీరు బి యొక్క సూచనను మారుస్తామని ఆలోచిస్తే, a నుండి c కు.
మీరు దీనిని చేయలేరు ఎందుకంటే మీరు వ్రాసే క్షణం & b.
కాబట్టి, ఇది ఒక మారుపేరుగా ఉంది, & b ఇది ఒక మారుపేరు అయినందున & amp; కాబట్టి, మీరు బి గా వ్రాస్తే ఏ, ఒక దరఖాస్తు చేయాలి, ఎందుకంటే ఇది ఒక మారుపేరు.
ఆపై, ఒక చిరునామా ఆపరేటర్.
కాబట్టి, మీరు ఏమి చెప్తున్నారో; మీరు ఒక చిరునామాకు c కు కేటాయించాలని ప్రయత్నిస్తున్నారు, ఇది అర్థరహిత విషయం.
కాబట్టి, మీరు అన్ని అవకాశాలలో ప్రయత్నించవచ్చు.
ఉదాహరణకు, మీరు సరే అని చెప్పటానికి ప్రయత్నిస్తే, నేను, c కు c కు ఇవ్వడం ద్వారా సూచనను మార్చుకోవాలనుకుంటున్నాను, కానీ b is a a.
కాబట్టి, మీరు బి నుండి సి కు కేటాయించాలని ప్రయత్నిస్తే, మీరు ప్రాథమికంగా c కు కేటాయించవచ్చు.
భాష మీకు ఏ యంత్రాంగాన్ని ఇవ్వదు, ఏదైనా ఆపరేటర్ సూచనలతో ఏమీ చేయలేరు.
మీరు మాత్రమే సూచించవచ్చు.
మరియు, మీరు ఏమైనా వాస్తవంగా సూచించబడుతున్న దత్తాంశ పరంగా, సూచనగా సూచించబడుతుంది.
కాబట్టి, ఇది ప్రాథమిక వ్యత్యాసం.
గమనికలు కోసం, నేను ఎక్కడైనా గురిపెట్టి లేనందున అది సాధ్యమే.
ఒక పాయింటర్ ఉపయోగించి ముందు, మేము శూన్య తనిఖీ చేయాలి.
రిఫరెన్స్( reference)అవసరం లేదు ఎందుకంటే ఇది ఉనికిలో ఉన్నట్లయితే, అది ఏదో అలియాస్ లేదా ఉనికిలో లేదు.
కాబట్టి, కోడ్ వ్రాయడానికి చాలా సులభం చేస్తుంది.
మీరు దాని గురించి బాధపడటం లేదు మరియు ఖచ్చితంగా అది ఆ కోణంలో వేగంగా చేస్తుంది ఎందుకంటే ఆ తనిఖీలు అవసరం లేదు.
చివరగా, మీరు రెండు గమనికలు మరియు సూచనలు చిరునామాలను సరిగ్గా పరిశీలిస్తే, మరియు తేడా ఏమిటి? వ్యత్యాసం సాధికారతలో లేదు, మీరు సూచన కోసం ఎలాంటి పరంగా కాదు.
తేడా మీరు సూచన కోసం పొందలేము పరంగా ఉంది.
మీరు ఒక పాయింటర్ వేరియబుల్ ఉంటే, మీరు ఆ వేరియబుల్( variables)తో ఆపరేట్ చేసే ఆపరేటర్లు(operators) అనేక ఇవ్వబడుతుంది.
మీరు నిజంగా ఆ చిరునామాను ఒక విలువగా వాడవచ్చు మరియు వేర్వేరు పనులు చేయవచ్చు.
మీరు ఒక పూర్ణాంకం జోడించడానికి మరియు ఒక పాయింటర్ ముందుకు చేయవచ్చు.
మీరు రెండు పాయింటర్ విలువలు తీసుకొని ఒక తేడా చేయవచ్చు మరియు వ్యూహంలో ఈ రెండు పాయింటర్ల మధ్య ఎన్ని అంశాలు ఉన్నాయి.
కాబట్టి, ఈ ఆపరేటర్లు మీకు ఇవ్వబడుతున్నాయి, మీకు కావలసిన మార్గంలో మీరు పాయింటర్ను మార్చవచ్చు; ఇది పాయింటర్( pointer) చాలా శక్తివంతమైన చేస్తుంది.
సూచనలో కూడా చిరునామా నిల్వ చేయబడుతుంది.
కానీ, మీరు ఆ చిరునామాను పట్టుకోవటానికి ఎటువంటి మార్గం లేదు.
మీరు ఆ చిరునామాని కలిగి ఉండలేరు.
సూచనలో ఇవ్వబడిన ఆపరేషన్(operation) లేదు.
మీరు ప్రయత్నించిన ఏ ఆపరేషన్ అయినా, వాస్తవానికి సూచించబడిన (object)లేదా రిఫెర్ట్లో (repairs)పనిచేయడానికి సాధారణంగా దిమ్మలవుతుంది.
కాబట్టి, ఇది ప్రాథమిక వ్యత్యాసం.
మరియు, C ++ రూపకల్పనలో, రెండు గమనికలు మరియు సూచనలు వారి స్వంత ప్రదేశంగా ఉంటాయి.
గమనికలు మరియు రిఫరెన్సుతో( reference) నిజంగా దూరంగా ఉండటం సాధ్యం కాదు, అయితే మీరు ఈ రెండు విధానాలను కలిగి లేని భాషలు ఉన్నాయి.
కాబట్టి, అర్థం మంచిది.
ప్రత్యేకంగా, మీరు జావాకు తెలిసిన కొందరు తెలిస్తే మీకు జావా ఒక సూచన ఉందని తెలుస్తుంది, పాయింటర్( pointer) లేదు.
మరియు, నేను ఈ అంశాన్ని పెంచుతున్నాను, ఎందుకంటే మీరు జావా సూచనలో C ++ లో సూచన లేదు అని గమనించదలిచాను.
కాబట్టి, మీరు భావన భావనలో మరింత స్పష్టీకరణను కలిగి ఉండాలని మరియు అభిమాన జావా పుస్తకాన్ని చదివాను అని అనుకుంటే, అప్పుడు మీరు మరింత గందరగోళంగా పొందుతారు.
కాబట్టి, C ++ లో జావా యొక్క ప్రస్తావన యొక్క అసలు సమాంతరంగా లేదు, కానీ ఇది ఎక్కువగా స్థిరమైన పాయింటర్తో( pointer) సమానంగా ఉంటుంది.
మీరు జావాలో ఏమి చేయాలో సూచన అనేది వాస్తవానికి ఒక పాయింటర్, (pointer)కానీ మీరు మార్చలేని స్థిరమైన పాయింటర్(pointer).
కానీ, ఇది పూర్తిగా పాయింటర్(pointer) లేదా C ++ లో పూర్తిగా సూచన కాదు.
మరియు, భాషలు ఉన్నాయి; సి వంటి సూచన లేదు.
గమనికలు లేని భాషలు ఉన్నాయి.
C ++ లో మనకు రెండూ ఉన్నాయి.
కాబట్టి, మనకు ఇచ్చిన సందర్భంలో నిర్ణయం తీసుకోవడానికి పెద్ద బాధ్యత ఉంది, మనము పాయింటర్ను( pointer) ఉపయోగించాలా లేదా మనం ఒక రిఫరెన్స్(reference) ఉపయోగించాలి.
మరియు మేము పాటు వెళ్ళి, వివిధ లక్షణాలు మరియు వివిధ ప్రోగ్రామింగ్(programming) ఉదాహరణలు మీరు సమర్థవంతమైన C ++ ప్రోగ్రామర్( programmer) మారింది కోసం ఎంపిక న్యాయమైన మరియు కుడి ఉండాలి అని హైలైట్ ఉంచుకుంటుంది.
కాబట్టి, ఈ మాడ్యూల్ 7 లో, C ++ లో ప్రస్తావన భావనను ప్రవేశపెట్టాము మరియు విలువ మరియు కాల్ ద్వారా కాల్ మధ్య తేడాను అధ్యయనం చేశాము.
మేము రిఫరెన్స్ (reference)ద్వారా రిటర్న్( return)భావనను కూడా ప్రవేశపెట్టాము మరియు రెండు విధానాల మధ్య వ్యత్యాసాన్ని అధ్యయనం చేశాము.
మేము కొన్ని ఆసక్తికరమైన బలహీనతలను, మాయలు, గందరగోళ పరిస్థితులను ప్రదర్శించాము, వీటిలో నుండి బయటపడవచ్చు మరియు మేము సూచనలు మరియు గమనికల మధ్య వ్యత్యాసాల గురించి చర్చించాము.