ప్రోగ్రామింగ్ C ++ లో మాడ్యూల్ 7 కు  స్వాగతం.
 మేము C + లోకి సి యొక్క విధానపరమైన పొడిగింపు గురించి చర్చించడాన్ని కొనసాగిస్తాము.
 మేము మాడ్యూల్ 6 లో పరిచయం చేసాము మరియు సివి-క్వాలిఫైయర్ యొక్క రెండు ప్రాథమిక అంశాలను చర్చించాము, నిరంతర మరియు అస్థిరాలను క్వాలిఫైయర్ మరియు ఇన్లైన్ ఫంక్షన్ల ఉపయోగం.
 ఈ మాడ్యూల్‌లో, మేము మరొక భావనను ప్రవేశపెడతాము, దీనిని రిఫరెన్స్ అంటారు.
 రిఫరెన్స్  యొక్క ఈ భావన చాలా దగ్గరి సంబంధం కలిగి ఉంటుంది, కానీ పాయింటర్ భావన నుండి చాలా భిన్నంగా ఉంటుంది.
 కాబట్టి, మేము కూడా చేస్తాము; మేము మాడ్యూల్ గుండా వెళ్ళినప్పుడు, మనము సూచన మరియు పాయింటర్( pointer) మధ్య పోల్చడానికి మరియు విరుద్ధంగా ప్రయత్నిస్తాము.
 కాబట్టి, వారి ఉద్దేశం అర్థం మరియు ఈ విరుద్ధతను అర్థం చేసుకోవడం.
 ఈ మేము ద్వారా వెళ్ళే వివిధ నిర్దిష్ట విషయాలు.
 ఒక ప్రస్తావన ఇప్పటికే ఉన్న వేరియబుల్( variables) కోసం అలియాస్ లేదా పర్యాయపదంగా ఉంటుంది.
 కాబట్టి, అలియాస్ మా స్వంత పేర్ల పరంగా మాకు ఉన్నది.
 మాకు ఇచ్చిన పేరు ఉంది.
 మేము కొన్ని పెంపుడు జంతువు పేర్లను కలిగి ఉన్నాము మరియు వాటి పేర్లతో దీనిని పిలుస్తాము.
 కాబట్టి, ఇక్కడ సూచన వేరియబుల్ (variables) కూడా అదే ప్రయోజనం ఉంది.
 కాబట్టి, నేను ప్రకటించబడిన ఒక వేరియబుల్(variables).
 ఇక్కడ అది 15 కు ప్రారంభించబడుతుంది మరియు ఈ సందర్భంలో మేము ఒక వేరియబుల్ i ను కలిగి ఉంది, ఇది నిర్వచించబడింది.
 ఇది ప్రాధమిక విలువ 15 ఉంది. ఇప్పుడు, నేను మరొక వేరియబుల్ని నిర్వచించాను మరియు ప్రత్యేకంగా ఈ చిహ్నాన్ని ఇక్కడ & చిహ్నాన్ని చూడండి.
 మేము వేరియబుల్ j ని నిర్వచించి దానిని ప్రారంభించాము.
 ఇటువంటి వేరియబుల్ (వేరియబుల్) j ని i కి రిఫరెన్స్ లేదా i కోసం రిఫరెన్స్ వేరియబుల్ అంటారు.
 కాబట్టి, ఈ సూచన వేరియబుల్ వాస్తవానికి i ప్రత్యామ్నాయ పేరు మరియు అలియాస్ పేరు.
 కాబట్టి, నేను మెమరీని ( memory)పరిశీలిస్తే, i మరియు j రెండూ నిజానికి ఒకే మెమరీ (memory) స్థానాన్ని సూచిస్తాయి.
 కాబట్టి, నాకు మెమరీ చిరునామా 200 ఉంటే, నేను క్రింద చూపినట్లుగా, అది i యొక్క చిరునామా మరియు దాని కంటెంట్ 15 అయితే, j యొక్క చిరునామా కూడా 200 అవుతుంది, నేను 200.
 కాబట్టి, ఇది ఇకపై అప్రధానమైనది, ఈ ప్రత్యేక సూచన (j) ప్రవేశపెట్టబడింది.నేను నేను i గా సూచిస్తాను లేదా నేను j గా సూచిస్తాను.
 ఇది సూచన యొక్క ప్రాథమిక భావన.
 అందువల్ల, సూచన యొక్క ప్రవర్తనను అర్థం చేసుకోవడానికి ఒక చిన్న ప్రోగ్రామ్ పై దృష్టి పెడదాం.
 ఈ ప్రోగ్రామ్‌లో, నేను మీకు చూపిస్తాను, A వేరియబుల్ మరియు B సూచనగా సెట్ చేయబడింది.
 తరువాత రెండు అవుట్పుట్ స్టేట్మెంట్లలో, మేము మొదట a మరియు b యొక్క విలువను ప్రింట్ చేస్తాము.
 మేము ఇక్కడ అవుట్పుట్ చూడవచ్చు; 10 మరియు 10; ఎందుకంటే 10 మరియు బి ఇంటిపేరు (అలియాస్).
 అందువల్ల, నేను B ను ప్రింట్ చేసినా, 10 ను ప్రింట్ చేస్తాను.
 మరియు మంచం యొక్క రెండవ వరుసలో, ఇక్కడ ఒక పంక్తి ఉందని మేము ముద్రించాము.
 మేము a యొక్క చిరునామాను ప్రింట్ చేస్తాము మరియు b యొక్క చిరునామాను ప్రింట్ చేస్తాము.
 ఈ పంక్తిని ముద్రించే చిరునామాలు ఇవి.
 అవి ఒకే చిరునామా అని మనం మళ్ళీ తనిఖీ చేయవచ్చు.
 అవి వాస్తవానికి ఒకే వేరియబుల్, అవి రెండు వేర్వేరు పేర్లు.
 కాబట్టి, వేరియబుల్ విలువను మార్చడానికి ప్రయత్నిద్దాం.
 కాబట్టి, ఇక్కడ మనం ఇంక్రిమెంట్ చేస్తాము, ఆపై దాన్ని మళ్ళీ అవుట్పుట్ చేయండి.
 మేము ఇంక్రిమెంట్ చేస్తే, అది 11 అవుతుంది, కాబట్టి మీరు ఇక్కడ A 11 అవుతుంది, మరియు B, ఇప్పుడు B తో ఆపరేషన్ చేసినప్పటికీ, B కూడా పదకొండు అవుతుంది.
 మరియు, మీరు దీన్ని ఇతర మార్గాల్లో కూడా చేయవచ్చు.
 మీరు b ని పెంచుకుంటే, b 12 అవుతుంది. మరియు a, b ను సూచించే వేరియబుల్ కూడా 12 గా మారింది. అనగా, అవి చాలా బలంగా కలిసి ఉంటాయి మరియు ఏదైనా ఒకదాని యొక్క ప్రయోజనం కోసం ఉపయోగించబడతాయి.
 కాబట్టి, ఇది ప్రాథమిక వేగం.
 ఇప్పుడు, మీరు దీన్ని చేయడానికి ప్రయత్నిస్తే, మీరు మీ స్వంతంగా పొందగలిగే కొన్ని నిర్దిష్ట ఆపదలు ఉన్నాయని మీరు జాగ్రత్తగా ఉండాలి.
 అందువల్ల, నేను ఇక్కడ స్పష్టం చేసే మూడు సాధారణ ఆపదలు; ఇది ఎక్కువగా ఉండవచ్చు.
 అంటే, మనం కేవలం ఒక సూచనను నిర్వచించటానికి ప్రయత్నిస్తే, కానీ దానిని వేరియబుల్‌తో ప్రారంభించకుండా.
 అప్పుడు, కంపైలర్ మీకు లోపం ఇస్తుంది ఎందుకంటే రిఫరెన్స్ కొన్ని ఇతర వేరియబుల్‌కు మారుపేరు.
 కాబట్టి, మీరు దానితో వేరియబుల్‌ను నిర్వచించకపోతే, దానితో వేరియబుల్‌ను ప్రారంభించండి, దీనికి రిఫరెన్స్ తీసుకోవడానికి సూచన లేదు.
 కాబట్టి, ఇది తప్పు.
 కాబట్టి, మీరు టేబుల్ వద్ద మాత్రమే చూస్తే, ఎడమ వైపున నేను తప్పు ప్రకటనను చూపిస్తాను మరియు కుడి వైపున నేను సంబంధిత సరైన సంస్కరణను చూపిస్తాను మరియు ఇచ్చిన కారణాన్ని మీరు అర్థం చేసుకోవచ్చు.
 నేను తరువాతిదాన్ని చూస్తే, అంటే, నేను ఇక్కడ చూస్తే, మీరు స్థిరమైన విలువను సూచించడానికి ప్రయత్నిస్తున్నారు.
 ఇది కూడా లోపం ఎందుకంటే స్థిరమైన విలువ కేవలం విలువ.
 దీనికి నివసించడానికి చిరునామా లేదు.
 అందువల్ల, మీరు విలువకు సూచనను కలిగి ఉండలేరు, కానీ మీరు విలువకు స్థిరమైన సూచనను కలిగి ఉండవచ్చు; ఎందుకంటే ఇది స్థిరమైన విలువ.
 కాబట్టి, సూచన కూడా స్థిరంగా ఉండాలి.
 లేకపోతే, మీరు సంభవించే ప్రమాదం గురించి ఆలోచించవచ్చు; మేము సమ్మతితో చూపించినట్లు ఇది ప్రమాదకరమైనది.
 నేను, అది నిజమైతే, అది సరైనదని ume హించుకోండి, అప్పుడు j 5.
 ఇప్పుడు, నేను ++ j చేస్తే? ఎవరైతే దానిని ప్రస్తావిస్తున్నారో వారు పెరుగుతారు.
 కాబట్టి, అది అవుతుంది; కాబట్టి, స్థిరమైన 5 స్థిరమైన 6 అవుతుంది, ఇది సాధ్యం కాదు.
 అందువల్ల, ఇది ఒక కాన్స్టాంట్‌గా నిర్వచించబడింది, తద్వారా మీరు దీనికి ఎటువంటి మార్పులు చేయలేరు.
 అదేవిధంగా, మీరు ఇక్కడ చూస్తే, తరువాతి భాగంలో నాకు j + k అనే వ్యక్తీకరణ ఉంది.
 మరియు, నేను అదే సూచన చేయడానికి ప్రయత్నిస్తున్నాను.
 అయితే, మళ్ళీ వ్యక్తీకరణ యొక్క చిరునామా లేదు.
 J + k యొక్క లెక్కింపు తాత్కాలిక స్థానంగా మాత్రమే నిల్వ చేయబడుతుంది మరియు ఆ తాత్కాలిక స్థానాలు నిర్వహించబడవు.
 అందువల్ల, మళ్ళీ నేను దాని గురించి ప్రస్తావించలేను.
 నేను రిఫరెన్స్ కలిగి ఉండాలనుకుంటే, ఆ రిఫరెన్స్ స్థిరంగా ఉండాలి, ఇది రిఫరెన్స్ విలువగా లెక్కించినట్లు j + k విలువను సూచిస్తుంది.
 అందువల్ల, మీరు దానిని మార్చలేరు ఎందుకంటే j + k వ్యక్తీకరణను మార్చలేము.
 అందువలన, నేను చేస్తే; మేము సూచనను అనుమతిస్తే, మేము దానిని మార్చగలుగుతాము; వ్యక్తీకరణకు సూచన చేయబడుతుంటే ఇది అర్థపరంగా చెల్లుబాటు కాదు.
 కాబట్టి, మీరు ఇవన్నీ చెప్పగలరు.
 ఈ సమయంలో, j + k కి కొంత విలువ ఉంది; ఇది స్థిరంగా పరిగణించబడుతుంది.
 మరియు, నాకు దీనికి సూచన ఉంది.
 అందువల్ల, ఆ సూచనలన్నీ స్థిరంగా ఉంచాలి.
 ఎక్కువ నష్టం జరగవచ్చు, కానీ ఇవి సాధారణం.
 అందువల్ల, నేను వాటిని చర్చించడానికి ఎంచుకుంటాను.
 ఇప్పుడు, మేము దీన్ని ఎందుకు చేస్తున్నాము? అందువల్ల, ఫంక్షన్లకు పారామితులను పంపే పూర్తిగా కొత్త భావనను నేను ప్రవేశపెట్టాలి.
 సి నుండి ఫంక్షన్ వరకు పరామితి ఎలా పంపబడుతుందో మాకు తెలుసు.
 దీనిని విలువ ద్వారా కాల్ అంటారు.
 శీఘ్ర పునరావృతం కోసం, నిర్వచించిన ఫంక్షన్ అధికారిక పారామితులను కలిగి ఉంటుంది.
 దీనిని పిలిచినప్పుడు, నాకు అసలు పారామితులు ఉన్నాయి.
 స్థానాల క్రమం మరియు కాల్ సమయం లో, ప్రతి వాస్తవ పారామితుల విలువలు అధికారిక పారామితిలోకి కాపీ చేయబడతాయి మరియు తరువాత ఫంక్షన్ అని పిలువబడతాయి.
 అందువల్ల, పిలిచినప్పుడు, ఫంక్షన్ కాల్‌లో ఉంటుంది.
 వాస్తవ పారామితులు కొంత మెమరీలో ఉంటాయి మరియు ఇలాంటి ఫార్మల్ పారామితులు వేర్వేరు మెమరీలో ఉంటాయి.
 దీనికి విరుద్ధంగా, మేము కాల్ ద్వారా పిలవబడేదాన్ని రిఫరెన్స్ ద్వారా చేయవచ్చు.
 అందువల్ల, మీరు ఈ ప్రత్యేకమైన పంక్తిపై దృష్టి పెట్టాలని నేను కోరుకుంటున్నాను.
 మేము ప్రయత్నిస్తున్నాము, మేము ఫంక్షన్ హెడర్ ఇచ్చాము.
 అంతిమ పరీక్షలో పని ఒక నమూనా.
 ఈ మొదటి పరామితిని చూద్దాం, ఇక్కడ & తో ముందే ఉన్న పరామితి పేరును వ్రాస్తాము, ఇది సూచన కోసం సంజ్ఞామానం.
 ఇటువంటి పరామితిని రిఫరెన్స్ పరామితి అంటారు.
 ఆ ఫంక్షన్‌లో నాకు మరొక పరామితి సి కూడా ఉంది, ఇది నిర్దిష్ట విలువ పరామితి మరియు మేము విలువ నియమాల ప్రకారం కాల్‌ను అనుసరిస్తాము.
 ఇప్పుడు, వాడుక యొక్క ఈ భాగాన్ని చూద్దాం.
 కాబట్టి, దాన్ని వాడండి మరియు మేము వేరియబుల్ కోసం ఎంచుకుంటాము మరియు ఫంక్షన్ అని పిలుస్తాము.
 అంటే, నిజమైన పారామితిగా మనం రెండు అధికారిక పారామితుల స్థానంలో ఒకదాన్ని పాస్ చేస్తాము.
 మళ్ళీ, ఇది ఫంక్షన్ యొక్క నిర్వచనం; రెండు పారామితులు ఇవ్వబడిన చోట, మేము వాటి విలువను మాత్రమే ప్రింట్ చేస్తాము మరియు మేము వారి చిరునామాను మాత్రమే ప్రింట్ చేస్తాము.
 ఇప్పుడు, అవుట్పుట్ చూద్దాం.
 కాబట్టి మేము ఇలా చేస్తే, ఫంక్షన్ కాల్కు ముందు మొదటి అవుట్పుట్ (అవుట్పుట్) ఈ స్లైడ్ నుండి వస్తుంది, ఇది అవుట్పుట్, ఇది స్థానంలో ఉందని నాకు చెబుతుంది.
 మరియు, ఇది చిరునామా.
 రెండవ అవుట్పుట్ ఈ కౌట్ నుండి వస్తుంది, ఇది b ను ప్రింట్ చేస్తుంది మరియు b యొక్క చిరునామాను ఇస్తుంది.
 చాలా ఆసక్తికరంగా చూడండి
 B యొక్క చిరునామా విలువ వ్యవస్థ ద్వారా మేము కాల్‌లో ఆశించని చిరునామాకు సమానం.
 మరియు, విలువ ద్వారా పిలువబడేదాన్ని చూపించడానికి, మీరు మూడవ అవుట్పుట్ లైన్ మంచం మరియు పారామితి సి యొక్క సంబంధిత అవుట్పుట్ చూస్తారు.
 మరియు, సి యొక్క విలువ ఒకేలా ఉన్నప్పటికీ, అది ఉండాలి, సి యొక్క చిరునామా భిన్నంగా ఉంటుంది.
 కాబట్టి, B మరియు C అనే రెండు పారామితుల మధ్య, C అసలు నియమం ద్వారా అసలు కాల్‌ను అనుసరిస్తుందని ఇది స్పష్టంగా చూపిస్తుంది, దీని ద్వారా c నుండి కాపీ చేయబడిన ఒక విలువ మాత్రమే ఉంటుంది.
 a మరియు c రెండు వేర్వేరు మెమరీ స్థానాల్లో ఉన్నాయి, అయితే, b అనేది ప్రాథమికంగా a కి వేరే పేరు.
 ఇది a కి మారుపేరు (అయాస్) గా మారింది.
 నేను వేర్వేరు పేర్లతో రెండు వేరియబుల్స్ కలిగి ఉన్నప్పుడు అలియాస్ లక్షణాలపై మనం చూసిన ఈ లక్షణాలు, కానీ అవి ఒకే మెమరీ స్థలాన్ని ఆనందిస్తాయి మరియు అందువల్ల ఒకే విలువను కలిగి ఉంటాయి.
 కాబట్టి, ఇది రిఫరెన్స్ వేరియబుల్.
 కాబట్టి మేము పారామితులలో పారామితులు, రిఫరెన్స్ వేరియబుల్స్ ఉపయోగించినప్పుడు, మేము వాటిని రిఫరెన్స్ మెకానిజం ద్వారా కాల్స్ అని పిలుస్తాము.
 అందువల్ల, రిఫరెన్స్‌లోని కాల్ మరియు ఫార్మల్ పరామితి అసలు పరామితి యొక్క సూచనలో కాలర్ మరియు కాలీలో వేర్వేరు పేర్లను కలిగి ఉంటాయి, కానీ అవి ఒకే మెమరీ స్థానాన్ని కలిగి ఉంటాయి.
 కాబట్టి, ఇది C ++ మాకు అనుమతించే క్రొత్త లక్షణం.
 ఇక్కడ, నేను చెప్పినవన్నీ స్లైడ్ దిగువన వ్రాయబడ్డాయి.
 మీరు చదవగలిగేది అంతే.
 ఇప్పుడు, మేము కొంతకాలం అధ్యక్షత వహిస్తాము.
 రిఫరెన్స్ మెకానిజం ద్వారా కాల్ అంటే ఏమిటో మాత్రమే నేర్చుకున్నాము.
 కానీ, మేము దీన్ని ఎందుకు చేస్తున్నామో ఇంకా ఆలోచిస్తాము.
 అందువల్ల, మేము దీన్ని ఎందుకు ప్రయత్నిస్తున్నామో అర్థం చేసుకోవడానికి, నేను సి నుండి ఒక ఉదాహరణ తీసుకుంటాను.
 మరియు, ఇది ఒక ఉదాహరణ, సి గురించి చాలా తక్కువ చేసిన మీలో ప్రతి ఒక్కరికీ, నేను స్వాప్ ఫంక్షన్ రాయడానికి ప్రయత్నిస్తున్నానని నాకు తెలుసు.
 ఇది రెండు వేరియబుల్స్ మరియు బి తీసుకుంటుంది మరియు వాటిని మార్చుకోవడానికి ప్రయత్నిస్తుంది.
 అందువల్ల, మేము దీనిపై దృష్టి పెడుతున్నాము.
 ఇది ఒక సంతకం.
 నేను ఈ ఫంక్షన్‌ను వ్రాస్తే, నేను ఈ కోడ్‌ను ఇక్కడ వ్రాస్తే నేను స్వాప్ అని చెప్తున్నాను మరియు a మరియు b యొక్క విలువ ఏమిటో తెలుసుకోవడానికి.
 కాబట్టి, ఈ ప్రత్యేకమైన ముద్రణ నుండి వచ్చిన మొదటి ముద్రణ ఇది; A మరియు B స్వాప్ 10 మరియు 15 విలువలను కలిగి ఉన్నాయని ఇది చూపిస్తుంది, ఎందుకంటే అవి ప్రారంభించబడ్డాయి.
 అప్పుడు, నేను స్వాప్ చేయడానికి వెళ్తాను.
 కాబట్టి, సి మరియు డి 10 మరియు 15 అవుతుంది, స్వాప్ కోడ్ వాటిని మార్పిడి చేస్తుంది మరియు వెనుకకు, నేను మళ్ళీ ప్రింట్ చేస్తాను.
 కానీ, దురదృష్టవశాత్తు విలువలు, వాస్తవ పారామితులు పరస్పరం మార్చుకోబడలేదు.
 అందువల్ల, స్వాప్ పని చేయలేదు మరియు should హించాలి.
 ఎందుకంటే తంత్రం అంటే ఏమిటి? విలువ ద్వారా విధానం కాల్; అంటే నేను ఫంక్షన్ స్వాప్ అని పిలిచినప్పుడు, ఫంక్షన్ దానిని కాపీ చేయడానికి c కి తీసుకుంది, b యొక్క విలువను d కి కాపీ చేస్తుంది.
 ఆపై, ఫంక్షన్ అది చేయాలనుకున్నది చేసింది.
 ఇది సి మరియు డిలను మార్చుకుంది.
 కానీ, ఈ సి మరియు డి లు a మరియు b ల నుండి వేర్వేరు ప్రదేశాలను కలిగి ఉంటాయి.
 కాబట్టి, ఏమీ జరగలేదు, మరియు బి.
 అవి నిజమైన పారామితులుగా బాగా సంరక్షించబడతాయి.
 అందువల్ల, ఫంక్షన్ తిరిగి వచ్చినప్పుడు, మరియు B ఒకే విధంగా ఉంటాయి.
 అవి స్వాప్ కాలేదు.
 అందువల్ల, ఇచ్చిపుచ్చుకోవడం ఆ విధంగా పనిచేయదు.
 అందువల్ల, మేము ఈ విధంగా స్వాప్ రాయలేమని సి లో నేర్చుకున్నాము.
 నేను ఏమి చేయాలి? నేను చుట్టూ యుక్తి చేయాలి; కొన్ని ఉపాయాలు
 కాబట్టి, మనం ఏమి చేయాలి? మేము చేయడానికి ప్రయత్నించే ఉపాయం స్వాప్‌ను నిర్వచించడం.
 నేను దానిని చిరునామాగా పేర్కొన్నాను; చిరునామా ద్వారా కాల్ చాలా అధికారికంగా ఆమోదించబడిన పేరు కాదు.
 దీనిని వాస్తవానికి విలువ అని పిలుస్తారు, కాని ఒకే తేడా ఏమిటంటే మనం ఇక్కడ పాస్ చేసే పరామితి పాయింటర్ రకం పరామితి.
 కాబట్టి, మేము రెండు పూర్ణాంకాలను మార్చుకునే బదులు, ఇప్పుడు పూర్ణాంకాల కోసం రెండు పాయింట్లను మార్చుకుంటాము.
 అందువల్ల, ఈ కోడ్ పాయింటర్లతో కూడా వ్రాయబడుతుంది, ఈ పాయింటర్లు ఎక్కడ ఉన్నాయి.
 నేను మొదటిదాన్ని ప్రస్తావించాల్సినప్పుడల్లా, నేను దీన్ని ఇప్పుడు * x మరియు రెండవదాన్ని * y తో చేయాలి మరియు మేము దీన్ని చేస్తాము.
 కాబట్టి, ఇవి సంకేతాలు, నేను వాటిని ఈ స్లైడ్‌లో పిలవవలసి వస్తే, a, మరియు b అనే రెండు నిజమైన పారామితులను తప్పనిసరిగా a యొక్క చిరునామాగా మరియు b యొక్క చిరునామాగా పంపించాలి.
 కాబట్టి, మేము రెండు చిరునామాలను పాస్ చేస్తాము.
 ఇప్పుడు, ఏమి జరుగుతుందో, నేను X ని చూస్తే; ఒకదానికి పాయింటర్ ఉంది.
 y అనేది బి యొక్క పాయింటర్.
 ఇప్పుడు, అది ఏమి చేస్తోంది? ఇది * x మరియు * y విలువలను మార్పిడి చేయడానికి ప్రయత్నిస్తోంది.
 ఇది x మరియు y విలువను మార్చడం లేదు.
 ఇది మార్చుకోలేనిది కాదు.
 ఇది * x మరియు * y విలువలను మార్చుకుంటుంది.
 * X అంటే ఏమిటి? * x నిజానికి a.
 X a చిరునామా అయితే, * x వాస్తవానికి.
 కాబట్టి, నేను * y లో స్వాప్ (స్వాప్) * x మరియు అలా చేసినప్పుడు, ఇది వాస్తవానికి బి.
 కాబట్టి, నేను * x తో * x ను మార్పిడి చేసినప్పుడు, నేను నిజంగా b తో మార్పిడి చేస్తున్నాను (స్వాప్).
 కాబట్టి, నేను చేస్తున్నది ప్రాథమికంగా విలువ ద్వారా కాల్ అసలు పరామితిని మార్చడానికి నన్ను అనుమతించదు, నేను వారి చిరునామాను పంపుతున్నాను మరియు రిమోట్‌గా నేను పారామితులను వాస్తవంగా మార్చుకుంటాను చిరునామాను సూచించడానికి చిరునామాను అనుమతించడం, ఆపై మార్పులు చేయండి.
 కాబట్టి, ఒక విధంగా నేను విలువ ద్వారా కాల్ నియమాన్ని ఉల్లంఘిస్తున్నాను ఎందుకంటే అది లేకుండా నేను మార్పును తిరిగి పొందలేను.
 కాబట్టి, ఇక్కడ మనకు అది ఉంటుంది; మేము దానిని చూస్తాము.
 మేము నేరుగా విలువలను మార్చుకోలేనందున, మేము చిరునామా రకం వ్యవస్థ నుండి కాల్‌ని ఉపయోగిస్తాము, అక్కడ మేము చిరునామాను మరియు ఆ విలువలను ఆ చిరునామాకు పంపిస్తాము.
 ఖచ్చితంగా, ఫలితాలను పొందడానికి ఇది బ్యాక్ డోర్ రకం.
 మరియు, మేము దీన్ని ఎందుకు చేస్తున్నాము? మనం దీన్ని చేయవలసిన ప్రాథమిక లక్షణాలు ఏమిటి? ఒక నిర్దిష్ట ఉదాహరణ స్వాప్ కావచ్చు.
 లక్షణం ఏమిటంటే, మేము విలువ ద్వారా పిలిస్తే, అసలు పరామితి అధికారిక పరామితిలోకి కాపీ చేయబడుతుంది.
 అందువల్ల, మీరు ఒక అధికారిక పరామితితో ఒక ఫంక్షన్‌లో ఏమి చేసినా, ఆ ప్రభావాలు అసలు పరామితికి తిరిగి రావు.
 ఇది మేము కోరుకున్నది.
 అయితే, స్వాప్‌లో మనం అసలు పరామితికి తిరిగి రావడానికి అధికారిక పరామితిని మార్చాలి.
 అప్పుడే, స్వాప్ సంభవించవచ్చు.
 నేను ఒక స్వాప్ (స్వాప్) చేస్తుంటే, మరియు B మారదు మరియు B మారదు వరకు B స్వాప్ (స్వాప్) చేయదు.
 కాబట్టి సాధారణీకరించడానికి, విలువ ద్వారా కాల్ మాకు ఇన్పుట్ రకం పారామితులను మాత్రమే కలిగి ఉండటానికి అనుమతిస్తుంది; విలువలు కాలర్ ఫంక్షన్ నుండి పిలువబడే ఫంక్షన్కు వెళ్ళగలవా?
 అయినప్పటికీ, విలువకు కాల్ నన్ను అవుట్పుట్ రకం పరామితిని నిర్వహించడానికి అనుమతించదు; అంటే, నేను ఫంక్షన్‌లోని విలువను లెక్కించలేను మరియు దానిని పరామితికి తిరిగి ఇవ్వలేను.
 కాబట్టి, ఫంక్షన్ వంటివి ఒకే విలువను మాత్రమే ఇస్తాయి.
 కాబట్టి, నేను ఒకటి కంటే ఎక్కువ అవుట్పుట్ కోరుకునే ఫంక్షన్ కావాలనుకుంటే, నాకు యంత్రాంగం లేదు, సి.
 స్ట్రెయిట్ ద్వారా విలువ యంత్రాంగం.
 అందువల్ల, చిరునామాలను ఉపయోగించడం మరియు దానిని ఒక రౌండ్లో చేయడం మాత్రమే ఇతర విధానం.
 ఇప్పుడు, మేము చూస్తాము.
 ఇప్పుడు, మనం మాట్లాడిన రెండు అంశాలను కలపడానికి ప్రయత్నిద్దాం.
 ఒకటి, మేము రిఫరెన్స్ అనే భావనను ప్రవేశపెట్టాము, రిఫరెన్స్ ద్వారా కాల్ చేసాము మరియు ఒక ఫంక్షన్ (ఫంక్షన్) నుండి ఒక సి ఫంక్షన్ (ఫంక్షన్) వరకు బహుళ అవుట్‌పుట్‌లను కలిగి ఉండటంలో ఇబ్బంది గురించి మాట్లాడాము.
 కాబట్టి, ముఖ్యంగా స్వాప్ ఉదాహరణను మళ్ళీ చూద్దాం.
 ఇప్పుడు, రండి.
 ఎడమ వైపున, ఉదాహరణకు మాకు కాల్ ఉంది.
 మేము చూసిన ఉదాహరణ వాస్తవానికి తప్పు, ఎందుకంటే అది మారదు ఎందుకంటే అది మారకూడదు.
 ఈ విలువ ప్రోటోటైప్ ద్వారా వచ్చిన కాల్.
 ఇప్పుడు, సి ++ లో మనం ఇక్కడ చేసిన అన్ని మార్పులు కేవలం విలువ ఆధారంగా కాల్ చేయడం కంటే.
 ఇప్పుడు మనకు రెండు పారామితులు ఉన్నాయని చెప్తున్నారు, వీటిని రిఫరెన్స్ ద్వారా పిలుస్తారు.
 ఈ పారామితులు సాధారణ పారామితులు కావు.
 అవి రిఫరెన్స్ పారామితులు.
 మరియు, ఇప్పుడు మీరు రిఫరెన్స్ పరామితితో మొత్తం వ్రాస్తారు.
 ఇది కాక, మీరు C లో చూసే వాటికి మరియు C ++ లో మీరు చూసే వాటికి మధ్య ఉన్న కోడ్ ఒకే విధంగా ఉంటుంది.
 మార్పులు చేసిన రెండు ప్రదేశాలు ఇవి.
 ప్రభావం ఏమిటి? ఇది రిఫరెన్స్ నుండి వచ్చిన కాల్ అయితే, అది ప్రత్యేక కాల్ అయినప్పుడు, నిజమైన పరామితి A మరియు ఇక్కడ అధికారిక పారామితి X, అవి, అవి ఒకే స్థలాన్ని ఆనందిస్తాయి; x అనేది a కి మరొక పేరు, y అనేది b కి మరొక పేరు.
 అందువల్ల, నేను x మరియు y లను పరస్పరం మార్చుకుంటే అది A, మరియు B లను మార్పిడి చేస్తుంది.
 కాబట్టి, నేను నా కోడ్‌లో పూర్తి ప్రభావాన్ని పొందగలను.
 కాబట్టి, అలా చేయడం ద్వారా నేను ఎలా ప్రయోజనం పొందగలను? అనేక విషయాలు; ఒకటి నేను వెనుక తలుపుకు తీసుకోవలసిన అవసరం లేదు.
 నాకు పరామితి ఇన్పుట్ కావాలంటే, నేను విలువ ప్రకారం పిలుస్తాను; పరామితి అవుట్‌పుట్ కావాలని నేను కోరుకుంటే, అప్పుడు నేను రిఫరెన్స్ ద్వారా పిలుస్తాను ఎందుకంటే ఫంక్షన్‌లోని ఆ ఫార్మల్ పరామితిలో చేసిన మార్పులు అసలు పారామితులు అవుతాయి.ఇది కూడా అందుబాటులో ఉంటుంది ఎందుకంటే అసలు పరామితి మరియు సంబంధిత అధికారిక పరామితి ఒకే చిరునామాను ఆనందిస్తాయి.
 కాబట్టి, C ++ లో రిఫరెన్స్ మెకానిజం ద్వారా రిఫరెన్స్ మరియు కాలింగ్ ఉపయోగించడం యొక్క ప్రయోజనం ఇది.
 ఇది ఖచ్చితంగా కోడ్‌ను చాలా క్లీనర్ చేస్తుంది.
 ఇది ప్రోగ్రామ్‌లను రాయడం మరింత సులభం మరియు నమ్మదగినదిగా చేస్తుంది.
 మరియు, మేము తరువాత చూడబోతున్నట్లుగా, ఇది చాలా ప్రయత్నాలను ఆదా చేస్తుంది ఎందుకంటే విలువ ద్వారా పిలుపులో మీరు ఆ విలువ యొక్క కాపీని తయారు చేయాలి.
 ఇప్పుడు, మీ విలువ పూర్ణాంకం ఉన్నంత వరకు, కాపీని తయారు చేయడం ఖరీదైనది కాకపోవచ్చు.
 అయితే, మీరు వెళుతున్న పరామితి బహుశా 10 కిలోల బైట్‌లను కలిగి ఉండే ఒక నిర్మాణం అయితే 200 వేర్వేరు సభ్యులు, 200 వేర్వేరు భాగాలు కలిగి ఉంటే imagine హించుకోండి, కాబట్టి దాన్ని కాపీ చేయడం మీకు చాలా ఖరీదైనది.
 కాబట్టి, మీరు ఆ ఖర్చును భరించకూడదు.
 మీరు సూచనను మాత్రమే ఉపయోగించగలరు.
 రిఫరెన్స్ పరామితిని ఉపయోగించడం యొక్క ఒక దుష్ప్రభావం.
 ఇప్పుడు, మేము రిఫరెన్స్ పరామితిని చేస్తే, అనగా మేము కాల్ ద్వారా రిఫరెన్స్ ద్వారా ఉపయోగిస్తే, అప్పుడు పరామితి వాస్తవానికి ఇన్పుట్ మరియు అవుట్పుట్.) పరామితి.
 ఇది ఇన్పుట్ ఎందుకంటే, నిజమైన పరామితికి ఏ విలువ ఉందో నేను చెప్పినప్పుడు, అధికారిక పరామితి కూడా అదే విలువను కలిగి ఉంటుంది.
 కాబట్టి, ఇది ఇన్పుట్ యొక్క ప్రయోజనాన్ని అందిస్తుంది.
 కాబట్టి, నన్ను నిజంగా పిలవవలసిన అవసరం లేదు.
 నేను సూచనల ద్వారా మాత్రమే కాల్‌లను ఉపయోగించగలను.
 కానీ, నేను రిఫరెన్స్ నుండి పిలిస్తే, సంభావ్యత ఏమిటంటే, అధికారిక పరామితిలో ఏదైనా మార్పు వాస్తవ పరామితిలో కూడా ప్రతిబింబిస్తుంది.
 అందువల్ల, అధికారిక పరామితిలో ఏదైనా అనధికారిక మార్పు లేదా అధికారిక పరామితిలో ఉద్దేశపూర్వక మార్పు నా అసలు పరామితిని పాడు చేస్తుంది.
 కాబట్టి, నేను కాల్‌ను రిఫరెన్స్ ద్వారా ఉపయోగించగలిగేదాన్ని మనం చేయగలమా, కాని దాన్ని ఇన్‌పుట్ పరామితిగా మార్చండి.
 కాబట్టి, దీన్ని చేయడానికి, మీరు const ను ఉపయోగిస్తారు.
 కాబట్టి, ఇక్కడ ఏమి ఉంది? ఇక్కడ కోడ్ చూడండి.
 ఈ ఫంక్షన్ పై ప్రత్యేకంగా దృష్టి పెట్టండి, ఇది x రకం రకం యొక్క అధికారిక పారామితిని తీసుకుంటుంది.
 కానీ, మేము ఏమి చేసాము? ఇంతకుముందు ఇది కాన్స్ట్ అని చెప్పాము.
 కాబట్టి దాని అర్థం ఏమిటి? ఎందుకంటే ఇది రిఫరెన్స్ ద్వారా పిలుపు ఎందుకంటే ఇది రిఫరెన్స్ పరామితి, కాబట్టి నేను ఈ సమయంలో A అని పిలిచినప్పుడు; A మరియు X ఒకే చిరునామాను సూచిస్తాయి.
 అయితే, రిఫరెన్స్ x స్థిరంగా ఉందని నేను చెప్తున్నాను; అంటే x యొక్క మార్పు సాధ్యం కాదు.
 ఇది పాయింటర్ లేకపోవడం మరియు పాయింటర్ డేటా యొక్క సంగ్రహణ పరంగా చర్చించిన పరిస్థితి.
 డేటా స్వయంగా స్థిరంగా ఉండదని మేము ఖచ్చితంగా అనుకుంటున్నాము, కాని నేను ఆ డేటాకు సూచించబడిన స్థిరాంకాన్ని కలిగి ఉంటే, ఆ పాయింటర్ (పాయింటర్) డేటాను మార్చడానికి నన్ను అనుమతించదు.
 అందువల్ల, అదేవిధంగా ఇక్కడ నాకు స్థిరమైన సూచన ఉంది లేదా డేటా యొక్క సంక్షిప్తతకు నాకు సూచన ఉంది.
 కాబట్టి, x నన్ను మార్చడానికి అనుమతించదు.
 కాబట్టి, ఒక ఫంక్షన్ లోపల ఉంటే, నేను ++ x వంటిదాన్ని వ్రాయడానికి ప్రయత్నిస్తాను.
 ఈ కోడ్ కంపైల్ చేయదు ఎందుకంటే నేను x విలువను x గా మార్చడానికి ప్రయత్నిస్తున్నాను.
 అయితే, x అనేది స్థిరమైన సూచన.
 x అనేది స్థిరమైన విలువ.
 కాబట్టి, దానితో ఏది ప్రారంభమైంది.
 దానితో ఏమి ప్రారంభమైంది? ఇది ఏకకాలంలో ప్రారంభమైంది.
 కాల్ చేసినప్పుడు అది మార్చబడదు.
 కాబట్టి, ఇప్పుడు ఏమి జరుగుతుంది? వీలునామా విలువ కాల్ సమయంలో x విలువగా లభిస్తుంది.
 అది చిరునామా.
 కానీ x, మీరు ఫంక్షన్ లోపల మార్చలేరు.
 అందువల్ల, గొడ్డలిలో ఏదైనా మార్పు అసలు పరామితిని ప్రభావితం చేయదు.
 అందువల్ల, ప్రభావం తిరిగి రాకపోవచ్చు.
 కాబట్టి, ఇప్పుడు, పరామితి పూర్తిగా ఇన్పుట్ పరామితి అవుతుంది.
 అందువల్ల, రిఫరెన్స్ ఉపయోగించి మనం ఇన్పుట్ పరామితిని సృష్టించవచ్చు లేదా మనం స్థిరమైన రిఫరెన్స్ (పారామితి). రిఫరెన్స్) పరామితి అయితే మాత్రమే ఇన్పుట్ పరామితిని తయారు చేయవచ్చు.
 అందువల్ల, విలువలను బట్టి కాల్‌లను ఉపయోగించకుండా, పెద్ద సంఖ్యలో కేసులలో స్థిరమైన రిఫరెన్స్ పరామితిని మాత్రమే ఉపయోగించడానికి ప్రయత్నిస్తాము; ఎందుకంటే మీరు కాపీ చేయనవసరం లేదు.
 మరియు, మా వాస్తవ పరామితి ప్రభావితం కాదని మేము ఇంకా సురక్షితంగా ఉంటాము.
 అందువల్ల, కుడి వైపున మేము దీన్ని చేయడానికి సరైన మార్గం ఏమిటో ప్రదర్శిస్తాము, ఇక్కడ x అనేది స్థిరమైన సూచన మరియు మీరు దీన్ని చేయడానికి ప్రయత్నించరు.
 ఇక్కడ, మేము x ని పెంచడానికి ప్రయత్నిస్తున్నాము మరియు దానిని తిరిగి ఇస్తాము.
 ఇక్కడ, మేము దీన్ని చేయము.
 మేము x ను దానికి ఒకదాన్ని జోడించి, దానిని తిరిగి ఇవ్వడం ద్వారా లెక్కిస్తాము.
 కుడి వైపున ఉన్న కోడ్ సంకలనం చేయబడింది మరియు బాగా నడుస్తుంది.
 ఉల్లంఘన లేదు.
 ఎడమ వైపున ఉన్న కోడ్ సంకలన లోపాన్ని కలిగి ఉంటుంది మరియు మేము దానికి కొనసాగలేము.
 ఈ సమయంలో, మేము ఆగిపోతాము మరియు మేము తరువాతి భాగానికి కొనసాగుతాము.