C # లో ref మరియు అవుట్ మధ్య వ్యత్యాసం
విషయము
C # లో ఉపయోగించే పారామితి మాడిఫైయర్లు “Ref” మరియు “Out”. Ref మరియు అవుట్ ఉపయోగించి, మీరు ఏదైనా విలువ రకాన్ని దాని పద్ధతి ద్వారా ఏదైనా పద్ధతికి పంపవచ్చు. ఏదైనా విలువ రకాన్ని దాని సూచన ద్వారా దాటడానికి కారణం ref మరియు అవుట్ కీవర్డ్ మధ్య ప్రధాన వ్యత్యాసాన్ని పరిచయం చేస్తుంది. ది ref కీవర్డ్ రివర్ కీవర్డ్‌తో దానికి పంపిన ఆర్గ్యుమెంట్ యొక్క కంటెంట్‌ను మార్చడానికి పిలిచే పద్ధతిని అనుమతిస్తుంది. ది బయటకు ఒకే కాల్‌లో ఒకటి కంటే ఎక్కువ విలువలను తిరిగి ఇవ్వడానికి కీవర్డ్ అనే పద్దతిని అనుమతిస్తుంది. పోలిక చార్ట్తో పాటు ref మరియు అవుట్ మధ్య వ్యత్యాసాన్ని అధ్యయనం చేద్దాం.
- పోలిక చార్ట్
- నిర్వచనం
- కీ తేడాలు
- ముగింపు
పోలిక చార్ట్
| పోలిక కోసం ఆధారం | ref | అవుట్ |
|---|---|---|
| ప్రాథమిక | ఇది ref కీవర్డ్‌తో కొనసాగిన వాదన విలువలో మార్పును అనుమతిస్తుంది. | అవుట్ కీవర్డ్ ముందు ఉన్న విలువలను తిరిగి ఇవ్వడానికి ఇది ఒక పద్ధతిని అనుమతిస్తుంది. |
| మొదలుపెట్టటం | పద్ధతి కాల్‌కు ముందు ref పరామితిని ప్రారంభించాలి. | అవుట్ పరామితి ముగిసే ముందు పిలవబడే పద్ధతి లోపల ప్రారంభించబడాలి. |
| ప్రకటన | పద్ధతి ద్వారా మార్చవలసిన పరామితిని పద్ధతి డిక్లరేషన్ మరియు మెథడ్ కాలింగ్ అయితే రిఫర్‌గా ప్రకటించారు. | తిరిగి ఇవ్వవలసిన పరామితిని పద్ధతి డిక్లరేషన్ మరియు మెథడ్ కాలింగ్ అయితే రిఫ్ గా ప్రకటించాలి. |
Ref కీవర్డ్ యొక్క నిర్వచనం
“Ref” అనేది పారామితి మాడిఫైయర్, కాల్-బై-రిఫరెన్స్‌తో ఒక పద్ధతిని పిలవవలసిన అవసరం ఉన్నప్పుడు ఉపయోగించబడుతుంది. పిలిచే పద్ధతిలోని వాదనలకు చేసిన మార్పులు ఆ వేరియబుల్ యొక్క అసలు విలువలో ప్రతిబింబించాలని మేము కోరుకున్నప్పుడు, అప్పుడు ref పారామితి మాడిఫైయర్ ఉపయోగించబడుతుంది. మేము రిఫరెన్స్‌గా ప్రకటించదలిచిన విలువ రకానికి ముందు పద్ధతి డిక్లరేషన్ సమయంలో “రెఫ్” కీవర్డ్ మరియు మెథడ్ కాలింగ్ ఉంటుంది. ఒక పద్ధతిని పిలిచినప్పుడు మరియు ప్రకటించేటప్పుడు ఒకటి కంటే ఎక్కువ పరామితులను “ref” గా ప్రకటించవచ్చు.
సిస్టమ్ ఉపయోగించి; తరగతి డెమోరిఫ్ {పబ్లిక్ శూన్య స్క్వేర్ (ref int s) {s = s * s; Ref} తరగతి Ref_main {స్టాటిక్ శూన్యత ప్రధాన () {DemoRef ob = new DemoRef (); int a = 10; కన్సోల్.రైట్‌లైన్ ("ఒక ముందు పద్ధతి కాల్:" + a); ob.Square (ref a); // వాడిన ref కీవర్డ్ కన్సోల్.రైట్‌లైన్ ("కాల్ తరువాత:" + a); method} // అవుట్పుట్ ఎ బిఫోర్ మెథడ్ కాల్: 10 ఎ తర్వాత పద్ధతి కాల్: 100
పై కోడ్‌లో, వేరియబుల్ ‘ఎ’ దానికి అనుసంధానించబడిన పారామితి మాడిఫైయర్ రెఫ్‌తో పాటు స్క్వేర్ (రెఫ్ ఎ) పద్ధతికి వాదనగా పంపబడుతుంది. దీని అర్థం స్క్వేర్ (రెఫ్ ఎ) దానిలోని వేరియబుల్ ‘ఎ’ పై ఏ విధమైన మార్పులు చేసినా, పద్ధతి వెలుపల కూడా ‘ఎ’ యొక్క అసలు విలువలో ప్రతిబింబిస్తుంది.
పారామితి మాడిఫైయర్ “ref” తో వ్యవహరించేటప్పుడు గుర్తుంచుకోవలసిన కొన్ని ముఖ్యమైన అంశాలు ఉన్నాయి.
- మీరు ఒక పద్ధతికి ref ద్వారా ప్రయాణిస్తున్న వాదన పద్ధతి కాలింగ్‌కు ముందు ప్రారంభించబడాలి.
- పద్ధతి ప్రారంభ విలువను ref వాదనకు కేటాయించకూడదు.
- మీరు రిఫరెన్స్ వేరియబుల్‌తో పాటు రెఫర్‌ని కూడా ఉపయోగించవచ్చు.
అవుట్ కీవర్డ్ యొక్క నిర్వచనం
మీరు ఒక పద్ధతిని పిలిచిన ప్రతిసారీ, అది ఒకే విలువను మాత్రమే అందిస్తుంది. కాల్‌లో ఒకటి కంటే ఎక్కువ విలువలను తిరిగి ఇవ్వడానికి మీకు ఒక పద్ధతి కావాలంటే, పద్ధతి ముగిసినప్పుడు మీరు తిరిగి రావాలనుకునే పారామితులతో పాటు “అవుట్” కీవర్డ్‌ని ఉపయోగించాలి. కొన్నిసార్లు మనం ఏదైనా పద్దతికి పంపించకూడదనుకున్నప్పుడు, కాని పద్దతిని మనం తిరిగి కీవర్డ్‌తో ఉపయోగించే పారామితులను తిరిగి ఇవ్వాలనుకుంటున్నాము.దీన్ని ఉదాహరణతో అర్థం చేసుకుందాం.
సిస్టమ్ ఉపయోగించి; తరగతి డెమో ut ట్ {పబ్లిక్ ఇంటెంట్ కుళ్ళిపోతుంది (డబుల్ x, డబుల్ భిన్నం అవుట్) {int మొత్తం_నం; మొత్తం_నం = (పూర్ణాంకానికి) x; భిన్నం = x - మొత్తం_నం; మొత్తం_నం తిరిగి; Out} క్లాస్ అవుట్_మైన్ట్ {స్టాటిక్ శూన్యత ప్రధాన () {డెమో అవుట్ ఓబ్ = కొత్త డెమోఆట్ (); int i; డబుల్ ఫ్రాక్; i = ob.Decompose (100.125, అవుట్ ఫ్రాక్); // ఉపయోగించిన కీవర్డ్ కన్సోల్.రైట్‌లైన్ ("మొత్తం సంఖ్య భాగం" + i); కన్సోల్.రైట్‌లైన్ ("భిన్నం భాగం" + ఫ్రాక్); output} // అవుట్పుట్ పూర్ణాంక భాగం 100 భిన్న భాగం 0.125
పై కోడ్‌లో, రెండు విలువలు, పద్ధతి కుళ్ళిపోవడం () ద్వారా తిరిగి ఇవ్వబడుతున్నాయి. ఒకటి “రిటర్న్” అంటే మొత్తం_నమ్ అనే కీవర్డ్ ద్వారా తిరిగి వస్తుంది, మరియు మరొకటి పద్దతిని పిలిచేటప్పుడు అవుట్ కీవర్డ్ ముందు ఉన్న పరామితిని తిరిగి ఇస్తుంది, అనగా “ఫ్రాక్”.
కీవర్డ్ గురించి గుర్తుంచుకోవలసిన ముఖ్యమైన అంశాలు.
- Ref కీవర్డ్ వలె కాకుండా, పద్ధతి కాలింగ్‌కు ముందు కీవర్డ్‌ని ఉపయోగించే పరామితిని ప్రారంభించకూడదు.
- పిలవబడే పద్ధతి లోపల పరామితికి ఒక విలువను కేటాయిస్తుంది, ఎందుకంటే దీనిని పిలిచే పద్ధతి లోపల కేటాయించబడనిదిగా పరిగణించబడుతుంది, అనగా దీనికి ప్రారంభ విలువ లేదని భావించబడుతుంది.
- పద్ధతి ముగిసే ముందు పిలవబడే పద్ధతి అవుట్ పరామితికి విలువను కేటాయించాలి.
- కీవర్డ్ రిఫరెన్స్ వేరియబుల్‌కు కూడా వర్తిస్తుంది.
- Ref కీవర్డ్‌కు ముందు ఉన్న వేరియబుల్ ఏదైనా పద్ధతికి పంపబడినప్పుడు, ఆ పద్ధతి లోపల దానికి చేసిన మార్పులు దాని అసలు విలువలో ప్రతిబింబిస్తాయి. ఒక పద్ధతికి వేరియబుల్ పాస్ అయినప్పుడు అవుట్ కీవర్డ్ ముందు పద్ధతి రిటర్న్ కీవర్డ్‌ని ఉపయోగించకుండా దాన్ని తిరిగి ఇస్తుంది.
- Ref పరామితిని ఒక పద్ధతికి పంపే ముందు ప్రారంభించాలి. మరోవైపు, para ట్ పారామితిని పంపిన పద్ధతి లోపల ప్రారంభించాలి.
- ఒక పద్ధతిని పిలుస్తున్నప్పుడు, ప్రకటించేటప్పుడు లేదా నిర్వచించేటప్పుడు, ref పరామితిని స్పష్టంగా ref గా ప్రకటించారు. మరోవైపు, ఒక పద్ధతిని పిలిచేటప్పుడు, ప్రకటించేటప్పుడు లేదా నిర్వచించేటప్పుడు, అవుట్ పరామితి స్పష్టంగా అవుట్ గా ప్రకటించబడుతుంది.
ముగింపు:
వేరియబుల్‌ను ఒక పద్ధతికి రిఫరెన్స్ ద్వారా పంపించాల్సినప్పుడల్లా రెఫ్ అండ్ అవుట్ కీవర్డ్‌ని ఉపయోగించవచ్చు. అయితే, రెండు కీలకపదాలను ఉపయోగించటానికి కారణం భిన్నంగా ఉంటుంది, ఇక్కడ ref కీవర్డ్ ముందు వాదన యొక్క విలువను మార్చడానికి ref కీవర్డ్ ఉపయోగించబడుతుంది, అని పిలువబడే పద్ధతికి పంపబడుతుంది మరియు ముందు వాదన యొక్క విలువను తిరిగి ఇవ్వడానికి keyw ట్ కీవర్డ్ ఉపయోగించబడుతుంది. అవుట్ కీవర్డ్ ద్వారా.
