శ్రేణి అంటే ఒకే డేటా రకం మూలకాల సమూహం. అనేక కార్యక్రమాలు ప్రధాన ప్రోగ్రామ్‌లో లేదా దాని వెలుపల, ఫంక్షన్లలో శ్రేణులపై నిర్వహించబడతాయి. C ++ లో, ఫంక్షన్ల విషయంలో, మేము వాటిని పాస్ చేయాలి. ఇది పారామితుల ద్వారా ఆర్గ్యుమెంట్‌గా జరుగుతుంది. ఈ వాదనలు వివిధ మార్గాల్లో ఉండవచ్చు, పరిమాణ శ్రేణులు లేదా పాయింటర్ శ్రేణి ద్వారా. ఈ ట్యుటోరియల్‌లో, ఫంక్షన్ల యొక్క విభిన్న పారామితులను ఉపయోగించి శ్రేణి బదిలీ యొక్క కొన్ని ప్రధాన అంశాలను మేము కవర్ చేస్తాము.
వాక్యనిర్మాణం
[తిరిగిరకం] [యొక్క పేరుఫంక్షన్] (సమాచారంరకంశ్రేణి పేరు[అమరికపరిమాణం]){
ఫంక్షన్శరీరం
}
ఉదాహరణ 1
C ++ ప్రోగ్రామ్‌లో మేము విద్యార్థుల మార్కులను ముద్రించాల్సిన ఉదాహరణను పరిశీలించండి. ఈ ప్రింట్ ప్రధాన ప్రోగ్రామ్‌లో కాకుండా ప్రత్యేక ఫంక్షన్‌లో తీసుకోబడుతుంది. దీనికి విరుద్ధంగా, మేము ప్రధాన ప్రోగ్రామ్‌లో ఇన్‌పుట్‌లను తీసుకుంటాము మరియు ఈ విలువలను ఫంక్షన్‌కి పరామితిగా బదిలీ చేస్తాము. ఫంక్షన్ పరిగణించండి. దాని పరామితిలో, శ్రేణి యొక్క విలువలను అంగీకరించే ఒక శ్రేణి డేటాటైప్ వేరియబుల్ ఉంది. పూర్తి శ్రేణి ఇక్కడ ప్రకటించబడింది. మార్కులు for loop సహాయంతో ప్రదర్శించబడతాయి. శ్రేణుల మాదిరిగానే, వాటి నుండి ముద్రణ పొందడానికి మాకు లూప్‌లు అవసరం.
ప్రధాన ఫంక్షన్ వైపు కదులుతున్నప్పుడు, మేము దాని పరిమాణం మరియు విలువలతో శ్రేణిని ప్రకటిస్తాము. మేము ఫంక్షన్‌కు కాల్ చేయాలి. కాబట్టి పద్ధతి ఏమిటంటే, ఫంక్షన్ పేరును పరామితిలో శ్రేణి పేరుతో ఒక ఆర్గ్యుమెంట్‌గా వ్రాస్తాము. మేము శ్రేణి పరిమాణాన్ని నిర్వచించలేదు.
ప్రదర్శన(మార్కులు);
పారామీటర్‌లోని వాదన శ్రేణి యొక్క మెమరీ చిరునామాను సూచిస్తుంది. ఫంక్షన్ యొక్క హెడర్ యొక్క పరామితిలో, int m [7] int *m గా మార్చబడుతుంది. ఇందులో ఒరిజినల్ అర్రే వలె అదే చిరునామా ఉంటుంది. మేము ఫంక్షన్ యొక్క బాడీలో m [5] ను ఉపయోగించినప్పుడు, మేము అసలు శ్రేణిని మార్చబోతున్నాము.
శూన్య ప్రదర్శన(int m[7] )
లైనక్స్ ఆపరేటింగ్ సిస్టమ్‌లో, టెర్మినల్ ద్వారా అవుట్‌పుట్ పొందడానికి కొన్ని ముందస్తు అవసరాలను ఇన్‌స్టాల్ చేయాలి. కంపైల్ చేయడానికి మరియు కమాండ్ ప్రాంప్ట్ టెర్మినల్‌లో కోడ్‌ను అమలు చేయడానికి దీనికి కంపైలర్ అవసరం. G ++ సంకలనం కోసం C ++ లో ఉపయోగించబడుతుంది.
$g ++ -లేదాకోడ్ 3 కోడ్ 3.సి
$/కోడ్ 3
సోర్స్ ఫైల్ నుండి అవుట్‌పుట్ ఫైల్‌కి అవుట్‌పుట్‌ను నిల్వ చేయడానికి –o ఉపయోగించబడుతుంది.
అవుట్‌పుట్ నుండి, ప్రధాన ఫంక్షన్‌లో శ్రేణిలో ప్రారంభించిన అన్ని సంఖ్యలు డిస్‌ప్లే ఫంక్షన్ ద్వారా పాస్ చేయబడి, ప్రదర్శించబడతాయని మీరు గమనించవచ్చు.
ఉదాహరణ 2
పరామితి గుండా శ్రేణికి సంబంధించిన మరొక ఉదాహరణ ఫంక్షన్‌కు బహుమితీయ శ్రేణిని పంపడం. రెండు డైమెన్షనల్ అర్రే (2 డి) ఇక్కడ ఉపయోగించబడింది. ప్రధాన ఫంక్షన్‌లో, మేము శ్రేణిని ప్రారంభించాలి.
Int శ్రేణి[వరుస][కాలమ్]2d శ్రేణి ప్రారంభంలో అడ్డు వరుస మరియు కాలమ్ ఉన్నాయి. మరియు ప్రోగ్రామ్ అంతటా వారి ఆర్డర్ అలాగే ఉంచబడుతుంది. 2d శ్రేణి బ్రాకెట్లలో రెండు సంఖ్యలతో ప్రారంభించబడింది. మేము ప్రారంభంలో 2 నిలువు వరుసలను వివరించాము.
ప్రదర్శన(ఒకదానిపై);మేము పారామీటర్‌లోని శ్రేణి పేరును వాదనగా మాత్రమే ఉపయోగిస్తాము.
ఇప్పుడు మేము డిస్‌ప్లే ఫంక్షన్ యొక్క పనితీరును చూస్తాము. ఫంక్షన్ ప్రారంభించినప్పుడు, ప్రధాన ప్రోగ్రామ్ ద్వారా ఫంక్షన్ కాల్ ద్వారా పంపబడిన శ్రేణిని అంగీకరించడానికి శ్రేణి వేరియబుల్ పడుతుంది.
శూన్య ప్రదర్శన(int n[][2] )నిలువు వరుసల సంఖ్యను పేర్కొనడం తప్పనిసరి. పోల్చి చూస్తే, వరుసల విషయంలో ఇది అవసరం లేదు. అందుకే మేము ఫలితాలను ప్రదర్శించడానికి లూప్ కోసం ఉపయోగిస్తున్నందున ఇక్కడ వరుస బ్రాకెట్లను ఖాళీగా ఉంచాము. కానీ 2 డైమెన్షనల్ అర్రే విషయంలో, మేము లూప్ కోసం ఒక గూడును ఉపయోగిస్తాము. అందులో 2 వేరియబుల్స్‌తో స్టేట్‌మెంట్‌ల కోసం రెండు ఉన్నాయి.
అదే కంపైలర్‌ని ఉపయోగించడం ద్వారా మనం అవుట్‌పుట్‌ను చూడవచ్చు. ప్రతి విలువ అడ్డు వరుస మరియు కాలమ్ సంఖ్యతో విడిగా ప్రదర్శించబడే ఫలితాలను మీరు చూడవచ్చు.
ఉదాహరణ 3
ఈ ఉదాహరణ మునుపటి వాటి నుండి కొంచెం భిన్నంగా ఉంటుంది. ఈ ఉదాహరణలో, ఫంక్షన్ కాల్ యొక్క పారామీటర్‌లో శ్రేణి పరిమాణాన్ని మేము పేర్కొన్నాము. మరియు ఫంక్షన్ డిక్లరేషన్‌లో, శ్రేణి పరిమాణాన్ని ఆమోదించడానికి వేరియబుల్ కూడా ప్రవేశపెట్టబడింది.
ప్రధాన కార్యక్రమం నుండి ప్రారంభించి, విలువలతో శ్రేణి ప్రారంభించబడింది.
సగటు = పొందండి(సంతులనం,5);ఫలితం సగటు వేరియబుల్‌లో నిల్వ చేయబడుతుంది. శ్రేణి పేరును మాత్రమే పంపడానికి బదులుగా, శ్రేణి పరిమాణం కూడా పారామీటర్‌కు జోడించబడుతుంది.
పారామీటర్ శ్రేణి పరిమాణాన్ని స్వీకరించడానికి శ్రేణి రకం వేరియబుల్ మరియు ఒక పూర్ణాంక డేటా రకాన్ని కూడా కలిగి ఉంటుంది. ప్రధాన ప్రోగ్రామ్ రకం int ఎందుకంటే ఇది ఫంక్షన్ నుండి పూర్ణాంక విలువను అందుకుంటుంది. లేకపోతే, ఇతర సందర్భాల్లో ఇది శూన్యమైనది.
ఇప్పుడు మనం అవుట్‌పుట్ చూస్తాము. ఫంక్షన్ నుండి పొందిన చిత్రం ద్వారా ఈ విలువ కనిపిస్తుంది.
ఉదాహరణ 4
ఈ ఉదాహరణ శ్రేణిలోని గరిష్ట సంఖ్యను నిర్ణయించడానికి సంబంధించినది, నిజానికి, రెండు శ్రేణుల నుండి. ఇక్కడ మేము ప్రధాన ప్రోగ్రామ్‌లో రెండు శ్రేణులను ప్రారంభిస్తాము. రెండు శ్రేణులు విడిగా ఫంక్షన్ కాల్‌లలో ఫంక్షన్‌కు పంపబడతాయి
printMax(arr1);printMax(arr2);
ఇక్కడ printMax అనేది ఫంక్షన్ పేరు మరియు arr అనేది శ్రేణి. ఫంక్షన్ నుండి ఫలితం తిరిగి రాదు మరియు అక్కడ ప్రదర్శించబడుతుంది. లూప్ రెండు శ్రేణుల గరిష్ట సంఖ్యను లెక్కిస్తుంది. If- స్టేట్‌మెంట్ ఫర్ లూప్ లోపల ఉపయోగించబడుతుంది. ఫంక్షన్ యొక్క శీర్షిక:
శూన్యమైన printMax(int arr[5]) 
రెండు శ్రేణులు వేర్వేరు విలువలను కలిగి ఉన్నందున, రెండు ఫలితాలు భిన్నంగా ఉంటాయి.
ఉదాహరణ 5
ఈ ఉదాహరణ పారామితుల గుండా వెళుతున్న అన్ని రకాల శ్రేణుల సారాంశం. ఇవి పరిమాణాలు, పరిమాణాలు లేదా పాయింటర్ శ్రేణులు కావచ్చు. మేము వాటిని ఒక్కొక్కటిగా పరిశీలిస్తాము.
ప్రధాన కార్యక్రమంలో, ప్రతి ఫంక్షన్ ముందుగా ప్రకటించబడుతుంది. మీరు వారి ప్రకటనలో వ్యత్యాసాన్ని ఎత్తి చూపవచ్చు.
మొత్తం 1(int tmp[5]);Int మొత్తం 2(int tmp[]);
మొత్తం 3(int*tmp);
ఈ మూడు శ్రేణులు ఫంక్షన్‌లో ఈ పారామితులను కలిగి ఉన్న శ్రేణులను పాస్ చేయగలవని వర్ణిస్తాయి.
ఫంక్షన్ ప్రారంభించిన తర్వాత, శ్రేణి ప్రకటించబడిన ప్రధాన ప్రోగ్రామ్ మాకు ఉంది. మునుపటి ఉదాహరణ వలె కాకుండా, ఒక శ్రేణి రెండింటికి బదులుగా ప్రారంభించబడింది, కానీ అది మూడు విభిన్న మార్గాల్లో ఆమోదించబడింది. ఇప్పుడు మనం ఇక్కడ చేసిన ఫంక్షన్ కాల్స్ చూస్తాము.
మొత్తం = మొత్తం 1(అమ్మకాలు);మొత్తం = మొత్తం 2(అమ్మకాలు);
మొత్తం = sume3(అమ్మకాలు);
ప్రధాన ఫంక్షన్‌లో అవుట్‌పుట్ ప్రదర్శించబడుతుంది, కాబట్టి ఫంక్షన్ ద్వారా తిరిగి వచ్చిన విలువను అంగీకరించడానికి ఒక వేరియబుల్ ప్రకటించబడింది. మూడు ఫంక్షన్ కాల్‌ల నుండి, ఇక్కడ పారామితులు ఒకేలా ఉన్నాయని మీరు చూడవచ్చు. ప్రతి శ్రేణిలో శ్రేణి పేరు మాత్రమే ఉంటుంది. కానీ శ్రేణిని అంగీకరించే ఫంక్షన్ యొక్క పారామితులు భిన్నంగా ఉంటాయి.
అన్ని మూడు ఫంక్షన్ల లోపలి శరీరం ఒకే విధంగా ఉంటుంది, అన్ని సంఖ్యల మొత్తాన్ని For loop వినియోగం నుండి లెక్కించబడుతుంది. పద్దతి మరియు శ్రేణి విలువలు ఒకే విధంగా ఉంటాయి; ఫంక్షన్ల పారామితుల మధ్య మాత్రమే వివక్ష ఉంది. అందువల్ల, మేము శ్రేణిని అంగీకరించడానికి లేదా ఒకే కార్యాచరణను నిర్వహించడానికి వివిధ పద్ధతులను ఉపయోగించవచ్చని నిరూపించబడింది మరియు సమాధానం ఒకటే. అవుట్‌పుట్‌ను తనిఖీ చేయడం ద్వారా మేము దానిని నిర్ధారించవచ్చు. అదే సంకలనం విధానాన్ని ఉపయోగించి, దిగువ జోడించిన చిత్రంలో చూపిన అవుట్‌పుట్ మాకు లభిస్తుంది.
ఉపయోగించిన మూడు ఫంక్షన్‌లకు సమాధానం ఒకేలా ఉందని మీరు చూడవచ్చు.
ముగింపు
ఈ ఆర్టికల్లో, పారామితులలో శ్రేణి యొక్క పాసింగ్ పద్ధతి గురించి వినియోగదారు తెలుసుకుంటారు. విలువను తిరిగి ఇచ్చేటప్పుడు లేదా వాదనలలో పాస్ చేసేటప్పుడు అనేక సందర్భాల్లో శ్రేణులు నిర్వహించబడతాయి.