उदाहरण 1:
यहां 'आईओस्ट्रीम' शामिल है जो हेडर फ़ाइल है जो डेटा को इनपुट या आउटपुट करने के लिए फ़ंक्शंस का उपयोग करने में सहायता करती है। इसके नीचे, हम मानक नामस्थान 'एसटीडी' का उपयोग करते हैं और 'मुख्य()' का आह्वान करते हैं। अब, 'मुख्य()' में, हम 'अहस्ताक्षरित चार' डेटा प्रकार के साथ 'mybyteArray[]' नाम की एक बाइट सरणी घोषित करते हैं और इसे पांच तत्वों के साथ आरंभ भी करते हैं।
फिर, हम 'काउट' का उपयोग करते हैं जो वांछित डेटा प्रस्तुत करने और 'फॉर' लूप लगाने में मदद करता है। यह 'फॉर' लूप बाइट सरणी के तत्वों को प्राप्त करने में सहायता करता है, और 'काउट' इस बाइट सरणी के तत्वों को उनके हेक्साडेसिमल संख्याओं के साथ प्रस्तुत करने में सहायता करता है क्योंकि हम 'माई बाइटएरे [' << i << ']' रखते हैं। और कोउट में 'हेक्स'।
कोड 1:
#शामिल करेंनेमस्पेस एसटीडी का उपयोग करना ;
int यहाँ मुख्य ( ) {
अहस्ताक्षरित चार mybyteArray [ ] = { 0x31 , 0x32 , 0x33 , 0x34 , 0x35 } ;
अदालत << 'बाइट सरणी के तत्व हैं:' << अंतः ;
के लिए ( int यहाँ मैं = 0 ; मैं < का आकार ( mybyteArray ) ; मैं ++ ) {
अदालत << 'मेरा बाइटअरे[' << मैं << '] = ' << हेक्स << ( int यहाँ ) mybyteArray [ मैं ] << अंतः ;
}
वापस करना 0 ;
}
आउटपुट:
कोड का परिणाम यहां प्रस्तुत किया गया है और पिछले कोड में हमने जो बाइट सरणी बनाई थी वह अब प्रदर्शित होती है।
उदाहरण 2:
इस कोड में 'iostream' हेडर फ़ाइल शामिल है जो फ़ंक्शंस का उपयोग करके इनपुट या आउटपुट डेटा की सुविधा प्रदान करती है। इसके नीचे, हम 'मुख्य()' फ़ंक्शन को कॉल करते हैं और 'एसटीडी' मानक नामस्थान का उपयोग करते हैं। फिर हम 'बाइटए[]' नाम और 'अहस्ताक्षरित चार' डेटा प्रकार के साथ एक बाइट सरणी घोषित और आरंभ करते हैं। हम इस बाइट सरणी में छह तत्व निर्दिष्ट करते हैं और फिर प्रत्येक तत्व तक पहुंचने के लिए 'फॉर' लूप का उपयोग करते हैं। हम 'काउट' का उपयोग करते हैं इसलिए इस बाइट सरणी में आइटमों की हेक्साडेसिमल संख्याएं नीचे प्रदर्शित की जाती हैं क्योंकि हम इसमें 'हेक्स' और 'बाइटएरे[' << ए << ']' दोनों शामिल करते हैं।
अब, हम '0x11' को 'byteA[0]' निर्दिष्ट करके इस बाइट सरणी के तत्वों को बदलते हैं। फिर, हम क्रमशः '0x46' और '0x77' को 'byteA[2]' और 'byteA[4]' असाइन करते हैं। फिर, इन मानों को हमारे द्वारा बनाए गए बाइट सरणी से संशोधित किया जाता है। इसके बाद, हम बाइट सरणी के सभी तत्वों और नीचे जोड़े गए 'काउट' तक पहुंचने के लिए फिर से 'फॉर' लूप का उपयोग करते हैं। अब, संशोधित मान उनकी हेक्साडेसिमल संख्याओं के साथ यहां प्रस्तुत किए गए हैं।
कोड 2:
#शामिल करेंनेमस्पेस एसटीडी का उपयोग करना ;
int यहाँ मुख्य ( ) {
अहस्ताक्षरित चार बाइटए [ ] = { 0x21 , 0x22 , 0x23 , 0x24 , 0x25 , 0x26 } ;
अदालत << 'बाइट सरणी के तत्वों तक पहुंच' << अंतः ;
के लिए ( int यहाँ ए = 0 ; ए < का आकार ( बाइटए ) ; ए ++ ) {
अदालत << 'बाइटअरे[' << ए << '] = ' << हेक्स << ( int यहाँ ) बाइटए [ ए ] << अंतः ;
}
अदालत << ' \एन बाइट सरणी के तत्वों को बदलना:' << अंतः ;
बाइटए [ 0 ] = 0x11 ;
बाइटए [ 2 ] = 0x46 ;
बाइटए [ 4 ] = 0x77 ;
के लिए ( int यहाँ ए = 0 ; ए < का आकार ( बाइटए ) ; ए ++ ) {
अदालत << 'बाइटअरे[' << ए << '] = ' << हेक्स << ( int यहाँ ) बाइटए [ ए ] << अंतः ;
}
वापस करना 0 ;
}
आउटपुट:
हमारे द्वारा बनाई गई बाइट सरणी और संशोधित सरणी प्रस्तुत की गई है। हमने अपने कोड में इस बाइट सरणी के मानों को संशोधित किया है जो इस परिणाम में भी प्रस्तुत किया गया है।
उदाहरण 3:
यहां, हम इस कोड में अपने स्ट्रिंग डेटा को बाइट सरणी में बदलने के लिए 'ट्रांसफॉर्म ()' विधि का उपयोग करते हैं। इस कोड में 'iostream', 'cstddef', और 'एल्गोरिदम' हेडर फ़ाइलें शामिल हैं। ये हेडर फ़ाइलें आयात की जाती हैं ताकि हम उनमें परिभाषित कार्यों का आसानी से उपयोग कर सकें। इसके नीचे, हम 'std' नेमस्पेस रखते हैं और 'main()' विधि को कॉल करते हैं। फिर, हम 'हैलो वर्ल्ड' के साथ 'स्ट्रिंग' डेटा प्रकार के 'मायस्ट्रिंग' वेरिएबल को आरंभ करते हैं।
अब, हम दिए गए कथन को प्रदर्शित करने के लिए 'cout' जोड़ते हैं। इसके नीचे, हम 'myString.length()' के समान आकार की बाइट सरणी बनाते हैं। इसके बाद, हम 'ट्रांसफॉर्म ()' फ़ंक्शन का उपयोग करते हैं जो स्ट्रिंग वर्णों पर पुनरावृत्त होता है और 'कॉन्स्ट चार एंड कैरेक्टर' और 'रिटर्न बाइट (कैरेक्टर)' रखता है जो स्ट्रिंग के तत्व को बाइट्स में परिवर्तित करता है और उन्हें बाइट में कॉपी करता है। सरणी.
इसके बाद, हम 'फॉर' लूप का उपयोग करते हैं जहां हम 'कॉन्स्ट बाइट और बाइट: बाइटएरे' जोड़ते हैं जो बाइट ऐरे पर पुनरावृत्त होता है। फिर, हम 'काउट' जोड़ते हैं जो बाइट सरणी में परिवर्तित सभी तत्वों को प्रदर्शित करता है।
कोड 3:
#शामिल करें#शामिल करें
#<एल्गोरिदम>शामिल करें
नेमस्पेस एसटीडी का उपयोग करना ;
int यहाँ मुख्य ( )
{
स्ट्रिंग मायस्ट्रिंग = 'हैलो वर्ल्ड' ;
अदालत << 'स्ट्रिंग है' << मेरी डोरी << अंतः << अंतः ;
अदालत << 'ByteArray में परिवर्तित स्ट्रिंग है' << अंतः ;
बाइट बाइटअरे [ मेरी डोरी. लंबाई ( ) ] ;
परिवर्तन (
मेरी डोरी. शुरू ( ) ,
मेरी डोरी. अंत ( ) ,
बाइटअरे ,
[ ] ( कॉन्स्ट चार & चरित्र ) {
वापस करना बाइट ( चरित्र ) ;
} ) ;
के लिए ( कॉन्स्ट बाइट & फ्लैट : बाइटअरे )
{
अदालत << to_integer < int यहाँ > ( फ्लैट ) << ', ' ;
}
अदालत << अंतः ;
वापस करना 0 ;
}
आउटपुट:
स्ट्रिंग और परिवर्तित स्ट्रिंग को बाइट सरणी में अब इस परिणाम में प्रस्तुत किया गया है। हमने अपने कोड में 'ट्रांसफ़ॉर्म()' विधि का उपयोग करके इस स्ट्रिंग को बाइट सरणी में परिवर्तित किया।
उदाहरण 4:
आइए इस कोड में 'memcpy()' विधि का उपयोग करके अपने स्ट्रिंग डेटा को बाइट सरणी में बदलें। अब, इस कोड में 'iostream', 'cstddef', और 'एल्गोरिदम' हेडर फ़ाइलें शामिल हैं। हम इन हेडर फ़ाइलों को आयात करते हैं ताकि हम उनमें वर्णित कार्यों का आसानी से उपयोग कर सकें। हम इसके नीचे 'std' नेमस्पेस रखते हैं और इस स्थान से 'main()' फ़ंक्शन को इनवॉक करते हैं।
इसके बाद, हम 'स्ट्रिंगडेटा' वेरिएबल में 'बाइट ऐरे' को आरंभ करते हैं। दिए गए कथन को दिखाने के लिए, अब हम 'काउट' कमांड शामिल करते हैं। उसके नीचे, 'stringData.length()' के समान आकार वाली एक बाइट सरणी बनाई गई है। हम 'memcpy()' विधि का उपयोग करते हैं और इस फ़ंक्शन में तीन पैरामीटर पास करते हैं जो क्रमशः 'ArrayOfBytes', 'stringData.data()', और 'stringData.length()' हैं। यह फ़ंक्शन स्ट्रिंग के वर्ण की मेमोरी को हमारे द्वारा घोषित बाइट सरणी में कॉपी करने में सहायता करता है।
इसके बाद, हम 'for' लूप का उपयोग करते हैं जिसमें हम बाइट सरणी पर जाने के लिए 'const byte& my_byte: ArrayOfBytes' जोड़ते हैं। फिर, हम 'काउट' फ़ंक्शन जोड़ते हैं जो प्रत्येक तत्व को दिखाता है जिसे बाइट सरणी में बदल दिया गया है।
कोड 4:
#शामिल करें#शामिल करें
#शामिल करें
नेमस्पेस एसटीडी का उपयोग करना ;
int यहाँ मुख्य ( )
{
स्ट्रिंग स्ट्रिंगडेटा = 'बाइट ऐरे' ;
अदालत << 'स्ट्रिंग डेटा है' << स्ट्रिंगडेटा << अंतः << अंतः ;
अदालत << 'स्ट्रिंग को यहां ByteArray में परिवर्तित किया गया है जो कि है' << अंतः ;
बाइट ArrayOfBytes [ स्ट्रिंगडेटा. लंबाई ( ) ] ;
memcpy ( एरे ऑफ बाइट्स , स्ट्रिंगडेटा. डेटा ( ) , स्ट्रिंगडेटा. लंबाई ( ) ) ;
के लिए ( कॉन्स्ट बाइट & मेरी_बाइट : एरे ऑफ बाइट्स )
{
अदालत << to_integer < int यहाँ > ( मेरी_बाइट ) << ', ' ;
}
वापस करना 0 ;
}
आउटपुट:
यह परिणाम मूल स्ट्रिंग और स्ट्रिंग को प्रस्तुत करता है जो बाइट सरणी में परिवर्तित हो जाती है। हम इस स्ट्रिंग को बाइट सरणी में बदलने के लिए अपने कोड की 'मेम्सीपीई ()' विधि का उपयोग करते हैं।
निष्कर्ष
हमने सीखा कि C++ में बाइट ऐरे बाइनरी डेटा के साथ कुशलतापूर्वक काम करने के लिए निम्न-स्तरीय दृष्टिकोण प्रदान करते हैं। हमने पता लगाया कि वे हमें मेमोरी पर नियंत्रण और क्रमबद्धता, नेटवर्किंग और निम्न-स्तरीय डेटा प्रोसेसिंग जैसे कार्यों के लिए आधार प्रदान करते हैं। इस लेख में, हमने C++ में बाइट ऐरे को घोषित करने और आरंभ करने की अवधारणा के साथ-साथ स्ट्रिंग को उनके कोड के साथ बाइट ऐरे में बदलने की अवधारणा का पता लगाया।