సి ++ లో శ్రేణులను ఎలా అమలు చేయాలి?

ఒక శ్రేణి అదే డేటా రకానికి చెందిన మూలకాల యొక్క వరుస సేకరణ. అవి వరుసగా మెమరీలో నిల్వ చేయబడతాయి. అర్రే అనేది ఒకే రకమైన మూలకాలను కలిగి ఉన్న డేటా నిర్మాణం. శ్రేణి మూలకాలు జావాలో ఉన్నట్లుగా c ++ లోని వస్తువులుగా పరిగణించబడవు. ఈ వ్యాసంలో మేము C ++ లో శ్రేణుల గురించి చర్చిస్తాము.

C ++ లో శ్రేణులు

మీరు మ్యూజిక్ రికార్డ్ స్టోర్ వద్ద ఉన్నారని Ima హించుకోండి మరియు XYZ రికార్డ్స్ లేబుల్ క్రింద అన్ని రికార్డులను ఒకదానికొకటి పైన ఒకదానికొకటి ఏర్పాటు చేయమని నేను మీకు చెప్తున్నాను. ఈ వరుస రికార్డుల సేకరణను అర్రే అని పిలుస్తారు. శ్రేణి అనేది ఒకే డేటా రకం మూలకాల యొక్క వరుస సేకరణ. పై మా ఉదాహరణలో, XYZ రికార్డ్స్ డేటా రకం మరియు మీరు సేకరించిన అన్ని రికార్డులు ఒకే ప్రచురణకర్తలను కలిగి ఉంటాయి. శ్రేణిలోని అన్ని అంశాలు సాధారణ పేరుతో పరిష్కరించబడతాయి.

C ++ లోని శ్రేణులపై ఈ వ్యాసం ఈ బేస్ పాయింటర్లను కేంద్రీకరిస్తుంది,

• సింగిల్ డైమెన్షనల్ అర్రే
• డిక్లరేషన్ సమయంలో ప్రారంభించడం
• వినియోగదారు ద్వారా ప్రారంభించడం
• ఏదైనా పాయింట్ వద్ద శ్రేణిని యాక్సెస్ చేస్తోంది
• బహుళ డైమెన్షనల్ అర్రే

సింగిల్ డైమెన్షనల్ శ్రేణులు ఏమిటో అర్థం చేసుకోవడం ద్వారా ప్రారంభిద్దాం,

సింగిల్ డైమెన్షనల్ అర్రే

ప్రకటించడానికి సింటాక్స్ a సింగిల్ డైమెన్షనల్ అర్రే:

మనకు డేటా రకం ఉంది, అది పూర్ణాంక, ఫ్లోట్ లేదా డబుల్ వంటి ప్రాథమిక డేటా రకాలు కావచ్చు. శ్రేణి పేరు శ్రేణి యొక్క పేరు మరియు మేము శ్రేణి యొక్క పరిమాణాన్ని ప్రకటిస్తాము.మా పై ఉదాహరణలో, శ్రేణి ఉంటుంది,

XYZ రికార్డ్ రికార్డ్ అర్రే [100]

మరొక ఉదాహరణను పరిశీలిద్దాం:

పూర్ణాంక పరీక్ష [20]

శ్రేణి పరీక్ష రకం int యొక్క అంశాలను కలిగి ఉంటుంది మరియు పరిమాణం 20 కలిగి ఉంటుంది.

C ++ లో శ్రేణులు: శ్రేణి పరిమాణం

శ్రేణి యొక్క ప్రకటన సమయంలో శ్రేణి పరిమాణం ఇవ్వబడుతుంది. శ్రేణి యొక్క పరిమాణం ఇచ్చిన తర్వాత దాన్ని మార్చలేము. కంపైలర్ అప్పుడు శ్రేణికి ఎక్కువ మెమరీ స్థలాన్ని కేటాయిస్తుంది.

ఉదాహరణను పరిశీలించండి

పూర్ణాంక పరీక్ష [20]

పై ఉదాహరణలో, మనకు int రకం యొక్క శ్రేణి పరీక్ష ఉంది. మేము శ్రేణి పరిమాణాన్ని 20 గా ఇచ్చాము. దీని అర్థం మెమరీలోని శ్రేణికి వరుసగా 20 మెమరీ స్థానాలు ఉచితంగా ఇవ్వబడతాయి.

శ్రేణి సూచిక మరియు ప్రారంభించడం

శ్రేణిలోని ప్రతి స్థానంతో అనుబంధించబడిన సంఖ్య మరియు ఈ సంఖ్యను అంటారు శ్రేణి సూచిక . ఇది 0 నుండి మరియు చివరి మూలకం వరకు మొదలవుతుంది, ఇది శ్రేణి మైనస్ ఒకటి. మైనస్ ఒకటి ఉంది ఎందుకంటే మనం సున్నా నుండి లెక్కించటం మొదలుపెడతాము మరియు ఒకటి కాదు. శ్రేణి సూచికలు ఎల్లప్పుడూ సున్నా నుండి ప్రారంభమవుతాయి.

ఈ ఉదాహరణను పరిశీలించండి, ఇది వయస్సు శ్రేణి.

ఇక్కడ శ్రేణిలో 12,41,3,13,7 విలువలు ఉన్నాయి మరియు సూచికలు 0,1,2,3,4,5. మేము ఇండెక్స్ 4 వద్ద ఒక మూలకాన్ని సూచించాలనుకుంటే అది వయస్సు [4] గా సూచించబడుతుంది మరియు విలువ 7 ప్రదర్శించబడుతుంది.

అప్రమేయంగా, శ్రేణి అన్ని సున్నా విలువలను కలిగి ఉంటుంది.అర్రే ప్రారంభించడం డిక్లరేషన్ సమయంలో జరుగుతుంది. వినియోగదారు అర్రే విలువలోకి ఎప్పుడు మరియు అవసరమైనప్పుడు ప్రవేశిస్తే కూడా ఇది తరువాత నిర్వహించబడుతుంది.

డిక్లరేషన్ సమయంలో ప్రారంభించడం ఎలా పనిచేస్తుందో చూద్దాం,

డిక్లరేషన్ సమయంలో ప్రారంభించడం

డిక్లరేషన్ సమయంలో శ్రేణిని ప్రారంభించవచ్చు. డిక్లరేషన్ సమయంలో శ్రేణి అంశాలను పేర్కొనడం ద్వారా ఇది జరుగుతుంది. ఇక్కడ శ్రేణి పరిమాణం కూడా పరిష్కరించబడింది మరియు అది మనచే నిర్ణయించబడుతుంది.

కోడ్‌ను పరిగణించండి,

# నేమ్‌స్పేస్‌ను ఉపయోగించడం చేర్చండి std int main () {int arr [] = {10, 20, 30, 40} తిరిగి 0}

వివరణ

పై ఉదాహరణలో, మేము int రకం యొక్క శ్రేణిని మరియు arr అనే పేరుతో సృష్టిస్తాము. మేము శ్రేణి మూలకాలను నేరుగా తెలుపుతాము. మా శ్రేణిలోని మూలకాల సంఖ్యను లెక్కించడం ద్వారా శ్రేణి యొక్క పరిమాణం నిర్ణయించబడుతుంది. ఈ సందర్భంలో, పరిమాణం 4.

C ++ లోని శ్రేణులపై ఈ వ్యాసంలో తదుపరి వినియోగదారు ప్రారంభించడం ఎలా పనిచేస్తుందో చూద్దాం

వినియోగదారు ద్వారా ప్రారంభించడం

ఈ పద్ధతిలో, శ్రేణి యొక్క పరిమాణాన్ని నిర్ణయించడానికి వినియోగదారుని మేము అనుమతిస్తాము. ఈ సందర్భంలో, శ్రేణి యొక్క పరిమాణాన్ని పట్టుకోవడానికి మనకు వేరియబుల్ మరియు శ్రేణి యొక్క అంశాలను అంగీకరించడానికి లూప్ అవసరం. మేము డిక్లరేషన్ సమయంలో యాదృచ్ఛిక పరిమాణాన్ని కేటాయిస్తాము మరియు అవసరమైన విధంగా మాత్రమే ఉపయోగిస్తాము. ప్రారంభంలో పరిమాణం సాధారణంగా ఎక్కువ వైపు ఉంటుంది. ఫర్ లూప్‌ను నియంత్రించడానికి మనకు వేరియబుల్ i ఉంది.

ఉదాహరణను పరిశీలించండి,

# నేమ్‌స్పేస్‌ను ఉపయోగించి చేర్చండి std int main () {int arr [50], n, i cout<<'Enter the size of array:'<>n ఖర్చు<<'Enter the elements of array:'<arr [i]} తిరిగి 0}

అవుట్పుట్

వివరణ

పై ప్రోగ్రామ్‌లో, మేము 50 పరిమాణాల శ్రేణిని ప్రకటిస్తాము. అప్పుడు మేము ఈ శ్రేణిలో ప్రవేశించాలనుకుంటున్న మూలకాల సంఖ్యను నమోదు చేయమని వినియోగదారుని అడుగుతాము. అప్పుడు మేము వినియోగదారు ఎంటర్ చేసిన శ్రేణి అంశాలను అంగీకరిస్తాము.

C ++ లో శ్రేణులు: శ్రేణిని ప్రదర్శిస్తోంది

శ్రేణిని ప్రదర్శించడానికి ఫర్-లూప్ అవసరం. మేము మొత్తం శ్రేణికి ప్రయాణించి శ్రేణి యొక్క అంశాలను ప్రదర్శిస్తాము.

ఇక్కడ ఒక ఉదాహరణ,

# నేమ్‌స్పేస్‌ను ఉపయోగించి చేర్చండి std int main () {int arr [50], n, i cout<<'Enter the size of array:'<>n ఖర్చు<<'Enter the elements of array:'<arr [i]} ఖర్చు<<'Array elements are:'<
 అవుట్పుట్ 
  
 వివరణ 
పై ప్రోగ్రామ్‌లో, మేము 50 పరిమాణాల శ్రేణిని ప్రకటిస్తాము. అప్పుడు మేము ఈ శ్రేణిలో ప్రవేశించాలనుకుంటున్న మూలకాల సంఖ్యను నమోదు చేయమని వినియోగదారుని అడుగుతాము. అప్పుడు మేము వినియోగదారు ఎంటర్ చేసిన శ్రేణి అంశాలను అంగీకరిస్తాము. శ్రేణి మూలకాలను ప్రదర్శించడానికి మేము మళ్ళీ for for loop ని ఉపయోగిస్తాము.
C ++ వ్యాసంలో ఈ శ్రేణులతో కదులుతోంది,
 ఏదైనా పాయింట్ వద్ద శ్రేణిని యాక్సెస్ చేస్తోంది 
శ్రేణి మూలకాలను ప్రాప్యత చేయడం చాలా సులభం మరియు శ్రేణి సూచికను ఉపయోగించడం ద్వారా జరుగుతుంది. దిగువ కోడ్‌ను చూడండి.
# నేమ్‌స్పేస్‌ను ఉపయోగించడం చేర్చండి std int main () {int arr [5], i arr [4] = 2 arr [2] = 17 arr [0] = 17 cout<<'Array elements are:'<
 అవుట్పుట్ 
  
 వివరణ 
పై ప్రోగ్రామ్‌లో, మనకు పరిమాణం 5 యొక్క శ్రేణి ఉంది. మేము శ్రేణి సూచికను ఉపయోగించి వేర్వేరు ప్రదేశాలలో మూలకాలను నమోదు చేస్తాము. పై అవుట్పుట్ పొందడానికి మేము శ్రేణిని ప్రింట్ చేస్తాము.
 అప్రమేయంగా, అన్ని శ్రేణి అంశాలు సున్నా. 
 మేము శ్రేణి పరిమాణాన్ని దాటితే ఏమి జరుగుతుంది? 
సి ++ లో, మేము మూలకాలను సరిహద్దుగా యాక్సెస్ చేయడానికి ప్రయత్నిస్తే, కంపైలర్ ద్వారా లోపం చూపబడకపోవచ్చు కాని మాకు సరైన అవుట్పుట్ లభించదు.
ఇది C ++ వ్యాసంలోని ఈ శ్రేణుల చివరి బిట్‌కు మనలను తీసుకువస్తుంది,
సెలీనియం వెబ్‌డ్రైవర్‌లో డేటా నడిచే ఫ్రేమ్‌వర్క్
 బహుళ డైమెన్షనల్ అర్రే 
శ్రేణుల శ్రేణులు బహుళ డైమెన్షనల్ శ్రేణులు. బహుళ-డైమెన్షనల్ శ్రేణిలోని ప్రతి మూలకం దాని స్వంత శ్రేణిని కలిగి ఉండటం దీనికి కారణం. కొలతలు బట్టి మల్టీ డైమెన్షనల్ అర్రే ద్వారా మళ్ళించడానికి లూప్‌లకు మనకు n అవసరం.
 బహుళ డైమెన్షనల్ శ్రేణులను ప్రకటించడానికి సింటాక్స్ 
డేటాటైప్ శ్రేణి పేరు [size1] [size2] & hellip .. [size n]
int a [10] [20]
ఉదాహరణను పరిశీలించండి,
పై శ్రేణి యొక్క పరిమాణం 10 మూలకాలు 200 మూలకాలు.అదేవిధంగా, మనకు రెండు లేదా మూడు లేదా అంతకంటే ఎక్కువ డైమెన్షనల్ శ్రేణులు ఉండవచ్చు.ప్రతి కోణానికి లూప్ కోసం ఒకటి అవసరం. కాబట్టి, రెండు డైమెన్షనల్ శ్రేణికి రెండు- మరియు త్రిమితీయ శ్రేణికి మూడు అవసరం.
 కోడ్‌ను పరిగణించండి 
# నేమ్‌స్పేస్‌ను ఉపయోగించడం చేర్చండి std int main () {int arr [3] [2] = {, 0,1}, {2,3}, {4,5}} (int i = 0 i<3 i++) { for (int j = 0 j < 2 j++) { cout << 'Element:' cout < 
 అవుట్పుట్ 
  
 వివరణ 
పై కోడ్‌లో, మేము 3 * 2 మాతృకను ప్రదర్శిస్తాము. ఈ శ్రేణికి 3 వరుసలు మరియు 2 నిలువు వరుసలు ఉన్నాయి. మాకు ఉచ్చులు 2 ఉన్నాయి. ప్రతి శ్రేణి యొక్క ఒక కోణానికి బాధ్యత వహిస్తుంది. లూప్ కోసం బయటి వరుసలు మరియు నిలువు వరుసల లోపలి జాగ్రత్తలు తీసుకుంటుంది.
అదేవిధంగా, మేము త్రిమితీయ శ్రేణి కోసం ఒక కోడ్ వ్రాయగలము మరియు ఉచ్చులకు మూడు ఉంటుంది మరియు ప్రతి పరిమాణం లూప్ కోసం ఒకటి నియంత్రించబడుతుంది.
ఈ విధంగా మేము ‘సి ++ లోని శ్రేణులు’ పై ఈ వ్యాసం చివరకి వచ్చాము. మీరు మరింత తెలుసుకోవాలనుకుంటే, చూడండి   విశ్వసనీయ ఆన్‌లైన్ లెర్నింగ్ సంస్థ ఎడురేకా చేత. ఎడురేకా యొక్క జావా J2EE మరియు SOA శిక్షణ మరియు ధృవీకరణ కోర్సు కోర్ మరియు అధునాతన జావా భావనలతో పాటు హైబర్నేట్ & స్ప్రింగ్ వంటి వివిధ జావా ఫ్రేమ్‌వర్క్‌ల కోసం మీకు శిక్షణ ఇవ్వడానికి రూపొందించబడింది.
 మాకు ప్రశ్న ఉందా? దయచేసి ఈ బ్లాగ్ యొక్క వ్యాఖ్యల విభాగంలో దీనిని ప్రస్తావించండి మరియు మేము వీలైనంత త్వరగా మిమ్మల్ని సంప్రదిస్తాము