ఉదాహరణ 1:
డేటాను ఇన్‌పుట్ చేయడానికి లేదా అవుట్‌పుట్ చేయడానికి ఫంక్షన్‌లను ఉపయోగించడంలో సహాయపడే హెడర్ ఫైల్ అయిన “iostream” ఇక్కడ చేర్చబడింది. దీని కింద, మేము ప్రామాణిక నేమ్‌స్పేస్ “std”ని ఉపయోగిస్తాము మరియు “main()”ని అమలు చేస్తాము. ఇప్పుడు, “main()”లో, మేము “mybyteArray[]” పేరు యొక్క బైట్ శ్రేణిని “సంతకం చేయని చార్” డేటా రకంతో ప్రకటిస్తాము మరియు దానిని ఐదు మూలకాలతో ప్రారంభిస్తాము.
అప్పుడు, మేము కావలసిన డేటాను అందించడంలో మరియు 'ఫర్' లూప్‌ను ఉంచడంలో సహాయపడే 'కౌట్'ని ఉపయోగిస్తాము. ఈ “ఫర్” లూప్ బైట్ శ్రేణిలోని మూలకాలను పొందడంలో సహాయపడుతుంది మరియు “My byteArray[” << i << “]”ని ఉంచినప్పుడు ఈ బైట్ శ్రేణి యొక్క మూలకాలను వాటి హెక్సాడెసిమల్ సంఖ్యలతో పాటు రెండరింగ్ చేయడంలో “cout” సహాయపడుతుంది. మరియు కౌట్‌లో 'హెక్స్'.
కోడ్ 1:
#నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
int ప్రధాన ( ) {
సంతకం చేయలేదు చార్ mybyteArray [ ] = { 0x31 , 0x32 , 0x33 , 0x34 , 0x35 } ;
కోట్ << 'బైట్ శ్రేణి యొక్క మూలకాలు:' << endl ;
కోసం ( int i = 0 ; i < పరిమాణం ( mybyteArray ) ; i ++ ) {
కోట్ << 'నా బైట్అరే[' << i << '] = ' << హెక్స్ << ( int ) mybyteArray [ i ] << endl ;
}
తిరిగి 0 ;
}
అవుట్‌పుట్:
కోడ్ యొక్క ఫలితం ఇక్కడ రెండర్ చేయబడింది మరియు మేము మునుపటి కోడ్‌లో సృష్టించిన బైట్ శ్రేణి ఇప్పుడు ప్రదర్శించబడుతుంది.
ఉదాహరణ 2:
ఈ కోడ్ ఫంక్షన్‌లను ఉపయోగించి ఇన్‌పుట్ లేదా అవుట్‌పుట్ డేటాను సులభతరం చేసే “iostream” హెడర్ ఫైల్‌ను కలిగి ఉంటుంది. దీని క్రింద, మేము “main()” ఫంక్షన్‌ని పిలుస్తాము మరియు “std” ప్రామాణిక నేమ్‌స్పేస్‌ని ఉపయోగిస్తాము. మేము 'byteA[]' పేరు మరియు 'సంతకం చేయని చార్' డేటా రకంతో బైట్ శ్రేణిని ప్రకటించి, ప్రారంభిస్తాము. మేము ఈ బైట్ శ్రేణికి ఆరు మూలకాలను కేటాయించి, ఆపై ప్రతి మూలకాన్ని యాక్సెస్ చేయడానికి 'ఫర్' లూప్‌ని ఉపయోగిస్తాము. మేము “కౌట్”ని ఉపయోగిస్తాము కాబట్టి ఈ బైట్ శ్రేణిలోని ఐటెమ్‌ల హెక్సాడెసిమల్ సంఖ్యలు మేము దానిలో “హెక్స్” మరియు ”బైట్అర్రే[” << a << “]” రెండింటినీ చేర్చినందున క్రింద ప్రదర్శించబడతాయి.
ఇప్పుడు, “0x11”ని “byteA[0]”కి కేటాయించడం ద్వారా మేము ఈ బైట్ శ్రేణి యొక్క మూలకాలను మారుస్తాము. అప్పుడు, మేము వరుసగా “0x46” మరియు “0x77”ని “byteA[2]” మరియు “byteA[4]”కి కేటాయిస్తాము. అప్పుడు, ఈ విలువలు మనం సృష్టించిన బైట్ శ్రేణి నుండి సవరించబడతాయి. దీని తర్వాత, బైట్ శ్రేణి యొక్క అన్ని మూలకాలను మరియు దిగువ జోడించబడిన 'కౌట్'ని యాక్సెస్ చేయడానికి మేము మళ్లీ 'ఫర్' లూప్‌ని ఉపయోగిస్తాము. ఇప్పుడు, సవరించిన విలువలు వాటి హెక్సాడెసిమల్ సంఖ్యలతో పాటు ఇక్కడ రెండర్ చేయబడ్డాయి.
కోడ్ 2:
#నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
int ప్రధాన ( ) {
సంతకం చేయలేదు చార్ byteA [ ] = { 0x21 , 0x22 , 0x23 , 0x24 , 0x25 , 0x26 } ;
కోట్ << 'బైట్ శ్రేణి యొక్క మూలకాలను యాక్సెస్ చేస్తోంది' << endl ;
కోసం ( int a = 0 ; a < పరిమాణం ( byteA ) ; a ++ ) {
కోట్ << 'బైట్అరే[' << a << '] = ' << హెక్స్ << ( int ) byteA [ a ] << endl ;
}
కోట్ << ' \n బైట్ శ్రేణి యొక్క మూలకాలను మార్చడం:' << endl ;
byteA [ 0 ] = 0x11 ;
byteA [ 2 ] = 0x46 ;
byteA [ 4 ] = 0x77 ;
కోసం ( int a = 0 ; a < పరిమాణం ( byteA ) ; a ++ ) {
కోట్ << 'బైట్అరే[' << a << '] = ' << హెక్స్ << ( int ) byteA [ a ] << endl ;
}
తిరిగి 0 ;
}
అవుట్‌పుట్:
మేము సృష్టించిన బైట్ శ్రేణి మరియు సవరించిన శ్రేణి రెండర్ చేయబడ్డాయి. మేము ఈ బైట్ శ్రేణి యొక్క విలువలను మా కోడ్‌లో సవరించాము, ఇది ఈ ఫలితంలో కూడా అందించబడుతుంది.
ఉదాహరణ 3:
ఇక్కడ, ఈ కోడ్‌లోని మా స్ట్రింగ్ డేటాను బైట్ అర్రేగా మార్చడానికి మేము “ట్రాన్స్‌ఫార్మ్()” పద్ధతిని ఉపయోగిస్తాము. “iostream”, “cstddef” మరియు “algorithm” హెడర్ ఫైల్‌లు ఈ కోడ్‌లో చేర్చబడ్డాయి. ఈ హెడర్ ఫైల్‌లు దిగుమతి చేయబడ్డాయి, తద్వారా వాటిలో నిర్వచించబడిన ఫంక్షన్‌లను మనం సులభంగా ఉపయోగించుకోవచ్చు. దీని కింద, మేము “std” నేమ్‌స్పేస్‌ని ఉంచుతాము మరియు “main()” పద్ధతిని పిలుస్తాము. అప్పుడు, మేము 'హలో వరల్డ్'తో 'స్ట్రింగ్' డేటా రకం యొక్క 'myString' వేరియబుల్‌ని ప్రారంభిస్తాము.
ఇప్పుడు, మేము ఇచ్చిన స్టేట్‌మెంట్‌ను ప్రదర్శించడానికి “కౌట్” జోడిస్తాము. దీని క్రింద, మేము 'myString.length()' వలె అదే పరిమాణంలో బైట్ శ్రేణిని సృష్టిస్తాము. దీని తర్వాత, మేము స్ట్రింగ్ క్యారెక్టర్‌లపై మళ్ళించే “ట్రాన్స్‌ఫార్మ్()” ఫంక్షన్‌ను ఉపయోగిస్తాము మరియు స్ట్రింగ్‌లోని మూలకాన్ని బైట్‌లుగా మార్చే “కాన్స్ట్ చార్ & క్యారెక్టర్” మరియు “రిటర్న్ బైట్(క్యారెక్టర్)”ని ఉంచుతాము మరియు వాటిని బైట్‌కి కాపీ చేస్తాము. అమరిక.
దీని తర్వాత, మేము 'for' లూప్‌ని ఉపయోగిస్తాము, ఇక్కడ మేము 'const byte& byt: byteArray'ని జోడిస్తాము, ఇది బైట్ శ్రేణిపై మళ్ళిస్తుంది. అప్పుడు, మేము బైట్ శ్రేణిలోకి మార్చబడిన అన్ని మూలకాలను ప్రదర్శించే 'కౌట్' ను జోడిస్తాము.
కోడ్ 3:
##
#
నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
int ప్రధాన ( )
{
స్ట్రింగ్ myString = 'హలో వరల్డ్' ;
కోట్ << 'తీగ ఉంది' << myString << endl << endl ;
కోట్ << 'ByteArrayకి మార్చబడిన స్ట్రింగ్ ' << endl ;
బైట్ బైట్అర్రే [ myString. పొడవు ( ) ] ;
రూపాంతరము (
myString. ప్రారంభం ( ) ,
myString. ముగింపు ( ) ,
బైట్అర్రే ,
[ ] ( స్థిరంగా చార్ & పాత్ర ) {
తిరిగి బైట్ ( పాత్ర ) ;
} ) ;
కోసం ( స్థిరంగా బైట్ & ఒక ఫ్లాట్ : బైట్అర్రే )
{
కోట్ << నుండి_పూర్ణాంకం < int > ( ఒక ఫ్లాట్ ) << ',' ;
}
కోట్ << endl ;
తిరిగి 0 ;
}
అవుట్‌పుట్:
స్ట్రింగ్ మరియు బైట్ శ్రేణిలోకి మార్చబడిన స్ట్రింగ్ ఇప్పుడు ఈ ఫలితంలో రెండర్ చేయబడ్డాయి. మేము మా కోడ్‌లోని “ట్రాన్స్‌ఫార్మ్()” పద్ధతిని ఉపయోగించి ఈ స్ట్రింగ్‌ని బైట్ అర్రేగా మార్చాము.
ఉదాహరణ 4:
ఈ కోడ్‌లోని “memcpy()” పద్ధతిని ఉపయోగించి మన స్ట్రింగ్ డేటాను బైట్ అర్రేగా మారుద్దాం. ఇప్పుడు, ఈ కోడ్‌లో “iostream”, “cstddef” మరియు “algorithm” హెడర్ ఫైల్‌లు ఉన్నాయి. మేము ఈ హెడర్ ఫైల్‌లను దిగుమతి చేస్తాము, తద్వారా వాటిలో వివరించబడిన ఫంక్షన్‌లను సులభంగా ఉపయోగించవచ్చు. మేము దీని కింద “std” నేమ్‌స్పేస్‌ను ఉంచుతాము మరియు ఈ స్థానం నుండి “ప్రధాన()” ఫంక్షన్‌ను అమలు చేస్తాము.
తరువాత, మేము 'stringData' వేరియబుల్‌లో 'బైట్ అర్రే'ని ప్రారంభిస్తాము. అందించిన స్టేట్‌మెంట్‌ను చూపించడానికి, మేము ఇప్పుడు “cout” ఆదేశాన్ని చేర్చుతాము. దాని కింద, “stringData.length()” వలె అదే పరిమాణంతో బైట్ శ్రేణి నిర్మించబడింది. మేము “memcpy()” పద్ధతిని ఉపయోగిస్తాము మరియు ఈ ఫంక్షన్‌లో వరుసగా “ArrayOfBytes”, “stringData.data()” మరియు “stringData.length()” అనే మూడు పారామీటర్‌లను పాస్ చేస్తాము. మేము ప్రకటించిన బైట్ శ్రేణికి స్ట్రింగ్ అక్షరం యొక్క మెమరీని కాపీ చేయడంలో ఈ ఫంక్షన్ సహాయపడుతుంది.
దీనిని అనుసరించి, మేము బైట్ శ్రేణిపై ప్రయాణించడానికి “const byte& my_byte: ArrayOfBytes”ని జోడించే “for” లూప్‌ని ఉపయోగిస్తాము. ఆపై, బైట్ శ్రేణిగా మార్చబడిన ప్రతి మూలకాన్ని చూపే “కౌట్” ఫంక్షన్‌ని మేము జోడిస్తాము.
కోడ్ 4:
##
#
నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
int ప్రధాన ( )
{
స్ట్రింగ్ స్ట్రింగ్ డేటా = 'బైట్ అర్రే' ;
కోట్ << 'స్ట్రింగ్ డేటా' << stringData << endl << endl ;
కోట్ << 'స్ట్రింగ్ ఇక్కడ బైట్అరేగా మార్చబడింది, ఇది' << endl ;
బైట్ ArrayOfBytes [ stringData. పొడవు ( ) ] ;
memcpy ( ArrayOfBytes , stringData. సమాచారం ( ) , stringData. పొడవు ( ) ) ;
కోసం ( స్థిరంగా బైట్ & నా_బైట్ : ArrayOfBytes )
{
కోట్ << నుండి_పూర్ణాంకం < int > ( నా_బైట్ ) << ',' ;
}
తిరిగి 0 ;
}
అవుట్‌పుట్:
ఈ ఫలితం అసలైన స్ట్రింగ్ మరియు బైట్ శ్రేణిగా మార్చబడిన స్ట్రింగ్‌ను రెండర్ చేస్తుంది. ఈ స్ట్రింగ్‌ను బైట్ అర్రేకి మార్చడానికి మేము మా కోడ్ యొక్క “memcpy()” పద్ధతిని ఉపయోగిస్తాము.
ముగింపు
C++లోని బైట్ శ్రేణులు బైనరీ డేటాతో సమర్ధవంతంగా పనిచేయడానికి తక్కువ-స్థాయి విధానాన్ని అందిస్తాయని మేము తెలుసుకున్నాము. వారు మాకు మెమరీపై నియంత్రణను మరియు సీరియలైజేషన్, నెట్‌వర్కింగ్ మరియు తక్కువ-స్థాయి డేటా ప్రాసెసింగ్ వంటి పనులకు పునాదిని అందిస్తారని మేము అన్వేషించాము. ఈ కథనంలో, మేము C++లో బైట్ శ్రేణిని ప్రకటించడం మరియు ప్రారంభించడం మరియు స్ట్రింగ్‌ను వాటి కోడ్‌లతో పాటు బైట్ శ్రేణిలోకి మార్చడం అనే భావనను అన్వేషించాము.