C++లో, మేము int, string, char మొదలైన విభిన్న డేటా రకాల శ్రేణులను ప్రకటించవచ్చు మరియు ప్రారంభించవచ్చు. శ్రేణి అనేది ఒకే రకమైన డేటా రకం యొక్క అనేక విలువలను కలిగి ఉండే వేరియబుల్. పాత్ర యొక్క సేకరణ మరియు దానిలోని స్ట్రింగ్‌లను నిల్వ చేయడానికి 'చార్ అర్రే' ఉపయోగించబడుతుంది. 'char array' అనేది 'int array'ని పోలి ఉంటుంది. పూర్ణాంక శ్రేణి సంఖ్యా విలువలను నిల్వ చేస్తుంది, “char array” C++ ప్రోగ్రామింగ్‌లో అక్షరాలు లేదా స్ట్రింగ్‌ల సేకరణను నిల్వ చేస్తుంది. ఈ గైడ్‌లో, మేము మా కోడ్‌లలో C++లో చార్ అర్రేని ప్రారంభిస్తాము.
ఉదాహరణ 1:
హెడర్ ఫైల్‌లను చేర్చడం ద్వారా C++ కోడ్‌ను ప్రారంభిద్దాం. ఈ ఉదాహరణలో మొదటి హెడర్ ఫైల్ “iostream”. ఈ కోడ్‌లో మనకు అవసరమైన “సిన్” లేదా “కౌట్” వంటి కొన్ని ఫంక్షన్‌లు ఈ హెడర్ ఫైల్‌లో ప్రకటించబడ్డాయి. రెండవ హెడర్ ఫైల్ “string.h” ఇక్కడ జోడించబడింది, ఎందుకంటే శ్రేణి యొక్క పాత్రను మార్చడానికి మనకు అవసరమైన అనేక విధులు నిర్వచించబడ్డాయి. ఈ కోడ్‌లో “std” నేమ్‌స్పేస్ కూడా జోడించబడింది. అప్పుడు, మేము ఇక్కడ 'ప్రధాన ()' పద్ధతిని అమలు చేస్తాము.
అక్షర శ్రేణిని ప్రారంభించడానికి, మేము 'చార్' కీవర్డ్‌ని ఉంచుతాము. అప్పుడు, శ్రేణి పేరు ఇక్కడ టైప్ చేయబడింది. అక్షర శ్రేణి పేరు “new_Array”, దీని పరిమాణం “50”కి సర్దుబాటు చేయబడింది. అప్పుడు, మేము ఈ అక్షర శ్రేణిని లైన్‌తో ప్రారంభించాము. అక్షర శ్రేణిని ప్రారంభించడం కోసం మేము ఇక్కడ చేర్చిన లైన్ “నా మొదటి అక్షర శ్రేణి ఇక్కడ ఉంది!”. ఇప్పుడు, మేము ఈ అక్షర శ్రేణులను ప్రింట్ చేయాలనుకుంటున్నాము, కాబట్టి మేము 'new_Array'ని 'cout'లో ఉంచుతాము. ఇది కన్సోల్‌లో అక్షర శ్రేణిని రెండర్ చేస్తుంది.
కోడ్ 1:
#
#include
నేమ్‌స్పేస్ stdని ఉపయోగించడం;
పూర్ణాంక ప్రధాన ( )
{
చార్ కొత్త_అరే [ యాభై ] = 'నా మొదటి క్యారెక్టర్ అర్రే ఇక్కడ ఉంది!' ;
కోట్ << కొత్త_శ్రేణి << endl;
తిరిగి 0 ;
}
అవుట్‌పుట్:
కోడ్‌లో మనం ప్రారంభించిన అక్షర శ్రేణి ఇచ్చిన ఫలితంలో ఇక్కడ ప్రదర్శించబడుతుంది. అక్షర శ్రేణిని ప్రారంభించడానికి మేము ఉపయోగించిన మొత్తం డేటా కింది వాటిలో రెండర్ చేయబడింది:
ఉదాహరణ 2:
“iostream” మరియు “string.h” హెడర్ ఫైల్‌లు ఇక్కడ చేర్చబడ్డాయి. దీని కింద, మేము “std” నేమ్‌స్పేస్‌ని జోడిస్తాము. ఆపై, “ప్రధాన()”కి కాల్ చేసిన తర్వాత, మేము అక్షర శ్రేణిని “Arr_1” పేరుతో ప్రారంభిస్తాము. మేము 'చార్' డేటా రకాన్ని ఉంచి, ఆపై అక్షర శ్రేణి పేరును ఉంచుతాము.
అప్పుడు, మేము ఈ శ్రేణికి అక్షరాలను కేటాయిస్తాము లేదా మేము ఈ శ్రేణిని ఇక్కడ అక్షరాలతో ప్రారంభించామని చెప్పవచ్చు. మేము ఈ శ్రేణిలోని అక్షరాలను చొప్పించాము మరియు దీని క్రింద ఉన్న “కోసం” లూప్‌ను ఉపయోగిస్తాము ఎందుకంటే మేము ఈ అక్షరాలన్నింటినీ విడిగా ప్రదర్శించాలనుకుంటున్నాము. అప్పుడు, మేము 'cout'ని ఉపయోగిస్తాము మరియు ఈ కౌట్‌లో 'Arr_1[i]'ని జోడిస్తాము, ఇది చార్ శ్రేణిలోని అన్ని అక్షరాలను ప్రదర్శిస్తుంది.
కోడ్ 2:
##include
నేమ్‌స్పేస్ stdని ఉపయోగించడం;
పూర్ణాంక ప్రధాన ( )
{
char Arr_1 [ 10 ] = { 'a' , 'అది' , 'నేను' , 'ఓ' , 'లో' , 'n' , 'తో' , 'బి' , 'లో' , 'x' } ;
కోసం ( int i = 0 ; i < పరిమాణం ( Arr_1 ) / పరిమాణం ( Arr_1 [ 0 ] ) ; i++ )
{
కోట్ << 'అరే పాత్ర ' << Arr_1 [ i ] << endl;
}
తిరిగి 0 ;
}
అవుట్‌పుట్:
చార్ శ్రేణిలోని అన్ని అక్షరాలు ఇప్పుడు ఇక్కడ ప్రదర్శించబడతాయి. మా అందించిన కోడ్‌లో శ్రేణిని ప్రారంభించేటప్పుడు మేము ఈ అక్షరాలను చొప్పించి, ఆపై వాటిని రెండర్ చేస్తాము.
ఉదాహరణ 3:
మేము 'iostream' మరియు 'string.h' హెడర్ ఫైల్‌లను చేర్చాము, ఎందుకంటే వాటిలో నిర్వచించబడిన ఫంక్షన్‌లతో మేము పని చేసి, ఆపై 'std' నేమ్‌స్పేస్‌ను వాటి క్రింద ఉంచాము.
తరువాత, మేము 'ప్రధాన()' ఫంక్షన్‌ని ప్రారంభించిన తర్వాత 'a' పేరుతో అక్షర శ్రేణిని ప్రారంభిస్తాము. ఈ “a” శ్రేణి పరిమాణం “12”. ఇప్పుడు, మనం చేసేది డేటా రకాన్ని “చార్”కి సెట్ చేసిన తర్వాత అక్షర శ్రేణి పేరును చొప్పించడం. ఆ తర్వాత, మేము ఈ 'చార్' శ్రేణికి అక్షరాలను ప్రారంభిస్తాము. ప్రతి అక్షరాన్ని ఒక్కొక్కటిగా ప్రదర్శించడానికి, మేము ముందుగా ఈ శ్రేణికి అక్షరాలను జోడించి, ఆపై 'కోసం' లూప్‌ని ఉపయోగిస్తాము. తర్వాత, మేము ఈ 'చర్' శ్రేణిలోని అన్ని అక్షరాలను ప్రదర్శించే 'కౌట్' ఫంక్షన్‌ని ఉపయోగించి ఈ కౌట్‌కి 'a[i]'ని జోడించాము.
కోడ్ 3:
##include
నేమ్‌స్పేస్ stdని ఉపయోగించడం;
పూర్ణాంక ప్రధాన ( )
{
చార్ ఎ [ 12 ] = { 'a' , '@' , '#' , '%' , '!' , '^' , '&' , '*' , '' , 'తో' , '@' } ;
కోసం ( int i = 0 ; i < పరిమాణం ( a ) / పరిమాణం ( a [ 0 ] ) ; i++ )
{
కోట్ << 'పాత్ర ' << a [ i ] << endl;
}
తిరిగి 0 ;
}
అవుట్‌పుట్:
ఇది ఇప్పుడు 'చార్' శ్రేణిలోని ప్రతి అక్షరాన్ని చూపుతుంది. ఇచ్చిన కోడ్‌లో, మేము శ్రేణిని ప్రారంభించాము మరియు ఈ అక్షరాలను జోడించాము, తద్వారా వాటిని ఇక్కడ అందించాము.
ఉదాహరణ 4:
మేము తప్పనిసరిగా 'iostream' మరియు 'string.h' హెడర్ ఫైల్‌లలో నిర్వచించబడిన ఫంక్షన్‌లతో పని చేయాలి; మేము వీటిని ముందుగా చేర్చుతాము, తరువాత “std” నేమ్‌స్పేస్‌ని చేర్చుతాము. పైన పేర్కొన్న 'ప్రధాన()' ఫంక్షన్ కాల్‌ని అనుసరించి అక్షర శ్రేణిని ప్రారంభించేందుకు మేము 'myCharArray' పేరును ఉపయోగిస్తాము. “myCharArray” పరిమాణం “20”కి సర్దుబాటు చేయబడింది మరియు మేము దానిని “అక్షర శ్రేణి”తో ప్రారంభించాము.
ఇప్పుడు, మేము ఈ అక్షర శ్రేణిని ప్రదర్శించాలనుకుంటున్నాము. మేము ఈ శ్రేణికి జోడించిన అక్షరాల సేకరణను ప్రదర్శించడానికి 'myCharArray'ని జోడించే 'cout'ని ఉపయోగిస్తాము. అక్షర శ్రేణి 'myCharArray2″ పేరుతో ప్రారంభించబడుతుంది. ఇక్కడ, ”myCharArray2″ శ్రేణికి “5” పరిమాణం ఉంది. చేయాల్సిందల్లా డేటా రకాన్ని “చార్”కి సెట్ చేయడం మరియు అక్షర శ్రేణి పేరును చొప్పించడం.
ఈ 'చార్' శ్రేణిలో అక్షరాలు ప్రారంభించబడతాయి. మేము ముందుగా ఈ శ్రేణిలోకి అక్షరాలను చొప్పించాము, ఆపై ప్రతి అక్షరాన్ని విడివిడిగా చూపించడానికి దిగువన ఉన్న 'కోసం' లూప్‌ని ఉపయోగిస్తాము. తర్వాత, ఈ char శ్రేణిలోని అన్ని అక్షరాలను ప్రదర్శిస్తూ, ఈ కౌట్‌కు “myCharArray2[a]” జోడించడానికి మేము “cout” ఫంక్షన్‌ని ఉపయోగిస్తాము.
కోడ్ 4:
##include
నేమ్‌స్పేస్ stdని ఉపయోగించడం;
పూర్ణాంక ప్రధాన ( )
{
char myCharArray [ ఇరవై ] = 'పాత్ర శ్రేణి' ;
కోట్ << myCharArray << endl;
char myCharArray2 [ 5 ] = { 'a' , 'బి' , 'సి' , 'd' , 'అది' } ;
కోసం ( int a = 0 ; a < పరిమాణం ( myCharArray2 ) / పరిమాణం ( myCharArray2 [ 0 ] ) ; a++ )
{
కోట్ << myCharArray2 [ a ] << endl;
}
తిరిగి 0 ;
}
అవుట్‌పుట్:
అక్షర శ్రేణుల రెండు విలువలు క్రింది వాటిలో ప్రదర్శించబడతాయి. ముందుగా, మేము మొదటి అక్షర శ్రేణిలో జోడించిన పూర్తి స్ట్రింగ్‌ను రెండర్ చేసాము. అప్పుడు, రెండవ చార్ శ్రేణి ప్రదర్శించబడుతుంది, దీనిలో మేము అక్షరాలను చొప్పించాము మరియు వాటిని ఒకే లైన్‌లో విడిగా ప్రదర్శిస్తాము.
ఉదాహరణ 5:
“iostream” మరియు “std” నేమ్‌స్పేస్‌ని జోడించిన తర్వాత, మేము ఇక్కడ “main()” అని పిలుస్తాము మరియు “char” డేటా రకం యొక్క “c_array”ని “100” పరిమాణంతో ప్రారంభించాము. అప్పుడు, మేము 'ఇక్కడ అక్షర శ్రేణిలో డేటాను నమోదు చేయండి'ని జోడించే సందేశాన్ని ప్రదర్శిస్తాము, కాబట్టి ఈ లైన్ ప్రింట్ చేసినప్పుడు వినియోగదారు అక్షరాలను నమోదు చేస్తారు.
వినియోగదారు నుండి “char” శ్రేణిలోని అక్షరాన్ని పొందడానికి “cin” ఫంక్షన్ ఉపయోగించబడుతుంది. మేము “c_array”ని “cin” తర్వాత ఉంచుతాము, తద్వారా వినియోగదారు ఇన్‌పుట్ చేసే డేటా ఈ “c_array”లో సేవ్ చేయబడుతుంది. ఇప్పుడు, మేము 'c_array'ని ఉంచడం ద్వారా 'cout' సహాయంతో శ్రేణిలోని అక్షరాలను ప్రింట్ చేస్తాము.
తరువాత, ఒక సందేశం చూపబడుతుంది, దానికి మేము జోడించాము, 'ఇప్పుడు మళ్ళీ, అక్షర శ్రేణిలో డేటాను నమోదు చేయండి'. ఈ లైన్ ప్రింట్ చేసినప్పుడు వినియోగదారు ఈ ప్రాంతంలోని అక్షరాలను నమోదు చేస్తారు. “char” శ్రేణిలో ఉపయోగించడానికి వినియోగదారు నుండి అక్షరాన్ని తిరిగి పొందడానికి, మేము “cin” ఫంక్షన్‌ని ఉపయోగిస్తాము. ఇప్పుడు, మేము 'c_array'ని ఫీడ్ చేయడం ద్వారా శ్రేణి నుండి అక్షరాలను ప్రింట్ చేయడానికి 'cout'ని ఉపయోగిస్తాము.
కోడ్ 5:
#నేమ్‌స్పేస్ stdని ఉపయోగించడం;
పూర్ణాంక ప్రధాన ( )
{
చార్ c_array [ 100 ] ;
కోట్ <> c_array;
కోట్ << 'మీరు ప్రవేశించారు:' << c_array << endl;
కోట్ <> c_array;
కోట్ << 'మీరు ప్రవేశించారు:' << c_array << endl;
తిరిగి 0 ;
}
అవుట్‌పుట్:
ఇక్కడ, మేము మొదటి 'చార్' శ్రేణిలో 'కంప్యూటర్'ని నమోదు చేసాము. అప్పుడు, అది 'Enter' నొక్కిన తర్వాత తదుపరి లైన్‌లో ప్రదర్శించబడుతుంది. దీని తరువాత, మేము రెండవ 'చార్ అర్రే'లో 'సైన్స్'లోకి ప్రవేశించాము. ఇది మళ్లీ “Enter” నొక్కిన తర్వాత కింది వాటిలో కూడా రెండర్ చేయబడుతుంది.
ముగింపు
“char array” C++ ప్రోగ్రామింగ్‌ను ప్రారంభించే భావన ఇక్కడ వివరంగా వివరించబడింది. C++లో అక్షరాలు మరియు స్ట్రింగ్‌ల సేకరణను నిల్వ చేయడానికి “char array” ఉపయోగించబడుతుందని మేము చర్చించాము. మేము బహుళ “చార్ శ్రేణులను” ప్రారంభించాము మరియు వాటిని మా కోడ్‌లలో ప్రదర్శించాము. ఈ గైడ్‌లోని మా చివరి కోడ్‌లోని వినియోగదారు నుండి అక్షరాలను పొందడానికి మేము 'చార్ అర్రే'ని కూడా ప్రారంభించాము. అన్ని ఉదాహరణలు ఇక్కడ క్షుణ్ణంగా వివరించబడ్డాయి.