1: విలువ వారీగా వాదనలను ఆమోదించడం
వేరియబుల్ యొక్క కాపీ తయారు చేయబడుతుంది మరియు ఫంక్షన్‌కు అందించబడుతుంది వాదనలు విలువ ద్వారా ఆమోదించబడతాయి . ఫంక్షన్ లోపల వేరియబుల్‌కు చేసిన అన్ని మార్పులు కాపీని మాత్రమే ప్రభావితం చేస్తాయి; అసలు వేరియబుల్‌కి ఏదీ మార్చబడలేదు. ఫలితంగా, విలువ ద్వారా పాస్ అనేది సురక్షితమైన పద్ధతి ఎందుకంటే అసలు వేరియబుల్ విలువను అనుకోకుండా సవరించే అవకాశం లేదు.
విలువ ద్వారా పాస్ , అయితే, అసమర్థంగా ఉండవచ్చు, ముఖ్యంగా పెద్ద లేదా సంక్లిష్టమైన డేటా రకాలతో వ్యవహరించేటప్పుడు. డేటా కాపీ అవసరమయ్యే ప్రతి ఫంక్షన్ కాల్ త్వరగా CPU మరియు మెమరీ వనరులను ఖాళీ చేయగలదు. ఇంకా, విలువ ద్వారా పాస్ అసలు వేరియబుల్ విలువను మార్చడానికి ఉద్దేశించిన ఫంక్షన్‌ల కోసం ఉపయోగించబడదు ఎందుకంటే కాపీ మరియు అసలు వేరియబుల్ లింక్ చేయబడవు.
2: రిఫరెన్స్ ద్వారా వాదనలను ఆమోదించడం
వేరియబుల్స్ కావచ్చు సూచన ద్వారా ఆమోదించబడింది C++లో కూడా, ఇది ఈ సమస్యలను పరిష్కరించడానికి సహాయపడుతుంది. అసలు వేరియబుల్ ఎప్పుడు ఫంక్షన్‌కి పంపబడుతుంది సూచన ద్వారా ఉత్తీర్ణత , మరియు ఫంక్షన్ లోపల వేరియబుల్‌కు చేసిన ఏవైనా మార్పులు అసలు వేరియబుల్‌ను కూడా ప్రభావితం చేస్తాయి. దీనివల్ల, సూచన ద్వారా ఉత్తీర్ణత పెద్ద లేదా సంక్లిష్టమైన డేటా రకాల కోసం గణనీయంగా మరింత ప్రభావవంతంగా ఉంటుంది మరియు కాపీ చేయవలసిన అవసరాన్ని నివారిస్తుంది.
అనాలోచిత సవరణలను నిరోధించడానికి, ఒక ఫంక్షన్ తప్పనిసరిగా constగా నిర్దేశించబడాలి. ఫంక్షన్ డిక్లరేషన్‌కు const కీవర్డ్‌ని జోడించడం వలన, 'int గణన(const int& a, const int& b)'లో ఇది నెరవేరుతుంది.
అయితే, సూచన ద్వారా వాదనలను ఆమోదించడం వివరాలకు కూడా జాగ్రత్తగా శ్రద్ధ అవసరం. అనుభవం లేని ప్రోగ్రామర్లు అనుకోకుండా దుష్ప్రభావాలను సృష్టించడం, అనుకోకుండా డేటాను పంచుకోవడం మరియు బాహ్య డేటాను భర్తీ చేయడం వంటి పొరపాట్లు చేయవచ్చు.
రెండింటినీ ప్రదర్శించే క్రింది కోడ్‌ను పరిగణించండి వాదన పాస్ పద్ధతులు :
#నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
శూన్యం పాస్ బై వాల్యూ ( int x ) {
x = 5 ;
కోట్ << 'పాస్ బై వాల్యూ లోపల:' << x << endl ;
}
శూన్యం PassByReference ( int & x ) {
x = 5 ;
కోట్ << 'పాస్ బై రిఫరెన్స్ లోపల:' << x << endl ;
}
int ప్రధాన ( ) {
int సంఖ్య1 = 2 , సంఖ్య2 = 2 ;
కోట్ << 'ఫంక్షన్ కాల్స్ ముందు: num1= ' << సంఖ్య1 << 'సంఖ్య2=' << సంఖ్య2 << endl ;
పాస్ బై వాల్యూ ( సంఖ్య1 ) ;
PassByReference ( సంఖ్య2 ) ;
కోట్ << 'ఫంక్షన్ కాల్స్ తర్వాత: num1= ' << సంఖ్య1 << 'సంఖ్య2=' << సంఖ్య2 << endl ;
తిరిగి 0 ;
}
పై కోడ్‌లో, మొదటి ఫంక్షన్, పాస్ బై వాల్యూ , విలువ ద్వారా పూర్ణాంక ఆర్గ్యుమెంట్‌ని అందుకుంటుంది. ఫంక్షన్‌లో, ఒక కొత్త పూర్ణాంకం వేరియబుల్ సృష్టించబడింది మరియు విలువ 5 కేటాయించబడుతుంది. అసలు పూర్ణాంకం సవరించబడలేదు. రెండవ విధి, PassByReference , సూచన ద్వారా పూర్ణాంక ఆర్గ్యుమెంట్‌ని అందుకుంటుంది. ఈ సందర్భంలో, ఫంక్షన్ నేరుగా అసలు వేరియబుల్‌ను తారుమారు చేస్తుంది.
అవుట్‌పుట్
ఊహించినట్లుగా, మొదటి కాల్ అవుట్‌పుట్‌లు 5, కానీ అసలు వేరియబుల్‌పై ప్రభావం చూపదు. దీనికి విరుద్ధంగా, రెండవ కాల్ num2 విలువను 5కి మారుస్తుంది, ఇది తుది ప్రకటన యొక్క అవుట్‌పుట్‌ను ప్రభావితం చేస్తుంది.
పాస్ బై వాల్యూ వర్సెస్ పాస్ బై రెఫరెన్స్
1: ఫంక్షన్‌కి కాల్ చేసే మార్గం
మధ్య ఒక తేడా విలువ ద్వారా పాస్ మరియు సూచన ద్వారా ఉత్తీర్ణత ఫంక్షన్‌ని ఎలా అంటారు. ఎప్పుడు విలువ ద్వారా పాస్ , ఫంక్షన్ కాల్ తప్పనిసరిగా వేరియబుల్ విలువను కలిగి ఉండాలి, ఉదాహరణకు `లెక్కించు(a, b)`. ఎప్పుడు సూచన ద్వారా ఉత్తీర్ణత , ఫంక్షన్ కాల్ తప్పనిసరిగా వేరియబుల్ మెమరీ చిరునామాను కలిగి ఉండాలి, ఇది `లెక్కించు(&a, &b)` వంటి యాంపర్‌సండ్ అక్షరంతో సూచించబడుతుంది.
2: డేటా రకాలు
సాధారణంగా, విలువ ద్వారా పాస్ చిన్న లేదా సాధారణ డేటా రకాలతో పని చేస్తున్నప్పుడు లేదా ఫంక్షన్ అసలు వేరియబుల్‌ను సవరించడానికి ఉద్దేశించనప్పుడు చాలా సముచితమైనది. సూచన ద్వారా ఉత్తీర్ణత పెద్ద లేదా సంక్లిష్టమైన డేటా రకాలకు లేదా ఫంక్షన్ అసలు వేరియబుల్ విలువను సవరించడానికి ఉద్దేశించినప్పుడు మరింత సముచితమైనది.
ముగింపు
పారామితులు ఉన్నప్పుడు విలువ ద్వారా ఆమోదించబడింది ఒక ఫంక్షన్‌కు, వేరియబుల్ యొక్క కాపీ సృష్టించబడుతుంది మరియు సరఫరా చేయబడుతుంది. ద్వారా సూచన ద్వారా ఉత్తీర్ణత , అసలు వేరియబుల్ ఫంక్షన్‌కి పంపబడుతుంది. C++లో, విలువ లేదా సూచన ద్వారా వాదనలను పాస్ చేయడం అనేది ఒక ప్రాథమిక భావన. సరైన విధానాన్ని ఎంచుకోవడం నిర్దిష్ట పరిస్థితులపై ఆధారపడి ఉంటుంది మరియు జాగ్రత్తగా మూల్యాంకనం చేయాలి. ఉపయోగించడం వల్ల కలిగే ప్రయోజనాలు సూచన సులభంగా ఉపయోగించడానికి టెంప్టేషన్ ఉన్నప్పటికీ, విధానం మరింత ప్రభావవంతమైన కోడ్‌కు దారి తీస్తుంది విలువ ద్వారా పాస్ పద్ధతి.