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