శ్రేణులు అనేది C++ భాషలోని డేటా నిర్మాణాలు, ఇవి స్థిర-పరిమాణ డేటా నిర్మాణాలు మరియు ప్రకటించబడిన తర్వాత శ్రేణి పరిమాణాన్ని మార్చలేవు. శ్రేణులలో, మీరు ఒకే డేటాటైప్ యొక్క బహుళ విలువలను నిల్వ చేయవచ్చు.
శ్రేణికి మూలకాలను జోడించడం అనేది C++ కోడింగ్‌లో విస్తృతంగా ఉపయోగించే టాస్క్‌లలో ఒకటి. శ్రేణికి మూలకాలను జోడించడానికి, మీరు తప్పనిసరిగా గరిష్ట పరిమాణంతో కొత్త శ్రేణిని సృష్టించాలి, ఇప్పటికే ఉన్న మూలకాలను కొత్త శ్రేణిలోకి కాపీ చేసి, ఆపై కొత్త మూలకాన్ని ఆ శ్రేణికి జోడించాలి.
ఈ కథనం ఉదాహరణలతో C++ శ్రేణికి మూలకాన్ని చొప్పించడానికి వివరణాత్మక మార్గదర్శిని అందిస్తుంది.
C++ అర్రేకి ఒక మూలకాన్ని ఎలా జోడించాలి
C++ శ్రేణిలో మూలకాలను జోడించడానికి వివిధ పద్ధతులు ఉన్నాయి, వాటిని చర్చిద్దాం.
విధానం 1: ఎలిమెంట్స్‌ని వన్-బై-వన్ శ్రేణికి నమోదు చేయండి
ముందుగా, మీరు శ్రేణి యొక్క పరిమాణాన్ని కేటాయించాలి, అది ఏ పరిమాణం అయినా కావచ్చు. అప్పుడు మీరు పరిమాణం యొక్క శ్రేణిలోకి ఇన్‌పుట్ చేయవలసిన మూలకాలను ఒక్కొక్కటిగా నమోదు చేయాలి. మీరు శ్రేణిని ప్రారంభంలో పరిష్కరించిన తర్వాత దాని పరిమాణాన్ని మార్చలేరని గుర్తుంచుకోండి. మీరు మూలకాలను ఇన్‌పుట్ చేసిన తర్వాత, అది శ్రేణికి జోడించబడుతుంది మరియు కౌట్ ఫంక్షన్‌ని ఉపయోగించి ముద్రించబడుతుంది.
C++ కోడ్‌లో శ్రేణి చివరిలో మూలకాన్ని జోడించడానికి దిగువ ఇచ్చిన ఉదాహరణను అనుసరించండి:
#చేర్చండినేమ్స్పేస్ stdని ఉపయోగిస్తోంది ;
int ప్రధాన ( )
{
int అమరిక [ 6 ] , i , x ;
కోట్ << 'ఏదైనా 5 అర్రే ఎలిమెంట్‌లను నమోదు చేయండి:' ;
కోసం ( i = 0 ; i < 5 ; i ++ ) ఆహారపు >> అమరిక [ i ] ;
ఆహారపు >> అమరిక [ i ] ;
కోట్ << ' \n అర్రేలో చొప్పించడానికి కొత్త మూలకాన్ని నమోదు చేయండి: ' ; ఆహారపు >> x ;
ఆహారపు >> x ;
అమరిక [ i ] = x ;
కోట్ << ' \n నవీకరించబడిన శ్రేణి: \n ' ;
కోసం ( i = 0 ; i < 6 ; i ++ )
కోట్ << అమరిక [ i ] << '' ;
కోట్ << endl ;
తిరిగి 0 ;
}
పై కోడ్‌లో, మేము శ్రేణి యొక్క గరిష్ట పరిమాణాన్ని ప్రారంభించాము, ఇది 6 మరియు మొదటి 5 మూలకాలను ఒక్కొక్కటిగా నమోదు చేస్తాము. అప్పుడు మేము శ్రేణికి కొత్త మూలకాన్ని జోడించి, 6 మూలకాలను కలిగి ఉన్న నవీకరించబడిన శ్రేణిని ప్రింట్ చేస్తాము.
ప్రోగ్రామ్ యొక్క అవుట్‌పుట్ క్రిందిది.
విధానం 2 : శ్రేణిలో నిర్దిష్ట స్థానం/ఇండెక్స్‌కు మూలకాలను నమోదు చేయండి
పై పద్ధతిలో, మీరు మునుపటి శ్రేణి మూలకాల ముగింపు తర్వాత మాత్రమే మూలకాన్ని జోడించగలరు. అయినప్పటికీ, మీరు నిర్దిష్ట సూచికకు లేదా శ్రేణిలో స్థానానికి ఒక మూలకాన్ని మాన్యువల్‌గా జోడించాలనుకుంటే, మీరు ఈ పద్ధతిని ఉపయోగించవచ్చు. ఇక్కడ ఈ పద్దతిలో, పైన పేర్కొన్న పద్ధతిలో మనం ఇప్పటికే ఉపయోగించిన శ్రేణి యొక్క గరిష్ట పరిమాణాన్ని ఉపయోగిస్తాము మరియు ఆ శ్రేణిని ప్రింట్ చేస్తాము. ఆ తర్వాత, మనం ఆ శ్రేణికి మూలకాన్ని జోడించదలిచిన స్థానాన్ని ఎంచుకోవాలి.
క్రింద చూపిన ఉదాహరణను అనుసరించండి:
#includeనేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
int ప్రధాన ( )
{
int అమరిక [ ఇరవై ] , i , మూలకం , స్థానం , పరిమాణం ;
కోట్ << 'దయచేసి అర్రే పరిమాణాన్ని నమోదు చేయండి:' ;
ఆహారపు >> పరిమాణం ;
కోట్ << 'నమోదు చేయి' << పరిమాణం << 'శ్రేణి మూలకాలు :' ;
కోసం ( i = 0 ; i < పరిమాణం ; i ++ )
ఆహారపు >> అమరిక [ i ] ;
కోట్ << 'స్థానాన్ని ఎంచుకోండి:' ;
ఆహారపు >> స్థానం ;
కోసం ( i = పరిమాణం ; i >= స్థానం ; i -- )
అమరిక [ i ] = అమరిక [ i - 1 ] ;
కోట్ << ' \n దయచేసి శ్రేణిలో విలువను నమోదు చేయండి: ' ;
ఆహారపు >> మూలకం ;
అమరిక [ i ] = మూలకం ;
పరిమాణం ++;
కోట్ << ' \n మేము కలిగి ఉన్న కొత్త శ్రేణి లేదు: \n ' ;
కోసం ( i = 0 ; i < పరిమాణం ; i ++ )
కోట్ << అమరిక [ i ] << '' ;
కోట్ << endl ;
తిరిగి 0 ;
}
పై కోడ్‌లో, మేము శ్రేణి పరిమాణాన్ని నమోదు చేస్తాము మరియు ఎలిమెంట్‌లను శ్రేణిలో జోడిస్తాము. అప్పుడు మనం శ్రేణికి మూలకాన్ని జోడించదలిచిన స్థానాన్ని ఎంచుకుంటాము. మూలకం నమోదు చేసిన వెంటనే, అది ఆ స్థానంలో ఉన్న శ్రేణి జాబితాకు జోడించబడుతుంది.
కింది శ్రేణి యొక్క అవుట్‌పుట్ క్రింద చూపబడింది:
ముగింపు
శ్రేణులు అనేది మన సిస్టమ్ మెమరీలో వరుస స్థలం, ఇక్కడ మనం వినియోగదారు నుండి సజాతీయ డేటాను ఉంచవచ్చు లేదా తీసుకోవచ్చు. ఇది C++ భాషలో డేటా నిర్మాణం యొక్క అత్యుత్తమ రూపం. పై మార్గదర్శకాలలో, శ్రేణిలో కొత్త మూలకాన్ని జోడించడానికి మేము విభిన్న విధానాలను చూశాము. మొదటిది సరళమైన పద్ధతి, ఇది శ్రేణి చివరిలో మూలకాన్ని జోడించడంలో సహాయపడుతుంది మరియు రెండవ విధానంలో శ్రేణి యొక్క కొత్త మూలకం మీరు స్థానాన్ని ఎంచుకునే శ్రేణిలో ఎక్కడైనా మారవచ్చు మరియు ఇది శ్రేణిలో ఆ స్థానానికి ముందు మూలకాన్ని చొప్పిస్తుంది.