Halimbawa 1:
Ang 'iostream' ay kasama dito na kung saan ay ang header file na tumutulong sa paggamit ng mga function sa input o output ng data. Sa ilalim nito, ginagamit namin ang karaniwang namespace na 'std' at hinihimok ang 'main()'. Ngayon, sa 'main()', idedeklara namin ang isang byte array ng pangalang 'mybyteArray[]' na may 'unsigned char' na uri ng data at sinisimulan din ito ng limang elemento.
Pagkatapos, ginagamit namin ang 'cout' na tumutulong sa pag-render ng nais na data at ilagay ang 'para sa' loop. Ang 'for' loop na ito ay tumutulong sa pagkuha ng mga elemento ng byte array, at ang 'cout' ay tumutulong sa pag-render ng mga elemento ng byte array na ito kasama ng kanilang mga hexadecimal na numero habang inilalagay natin ang 'My byteArray[' << i << “]” at 'hex' sa cout.
Code 1:
#includegamit ang namespace std ;
int pangunahing ( ) {
hindi pinirmahan char mybyteArray [ ] = { 0x31 , 0x32 , 0x33 , 0x34 , 0x35 } ;
cout << 'Ang mga elemento ng byte array ay:' << endl ;
para sa ( int i = 0 ; i < sukat ng ( mybyteArray ) ; i ++ ) {
cout << 'Aking byteArray[' << i << '] = ' << hex << ( int ) mybyteArray [ i ] << endl ;
}
bumalik 0 ;
}
Output:
Ang kinalabasan ng code ay nai-render dito at ang byte array na ginawa namin sa nakaraang code ay ipinapakita na ngayon.
Halimbawa 2:
Kasama sa code na ito ang 'iostream' na header file na nagpapadali sa input o output data gamit ang mga function. Sa ibaba nito, tinatawag namin ang 'main()' function at ginagamit ang 'std' standard namespace. Pagkatapos ay idedeklara at pinasimulan namin ang isang byte array na may 'byteA[]' na pangalan at ang 'unsigned char' na uri ng data. Nagtatalaga kami ng anim na elemento sa byte array na ito at pagkatapos ay ginagamit ang 'para sa' loop upang ma-access ang bawat elemento. Ginagamit namin ang 'cout' upang ang mga hexadecimal na numero ng mga item sa byte array na ito ay ipinapakita sa ibaba habang kasama namin ang parehong 'hex' at 'byteArray[' << a << ']' dito.
Ngayon, binabago namin ang mga elemento ng byte array na ito sa pamamagitan ng pagtatalaga ng '0x11' sa 'byteA[0]'. Pagkatapos, itinalaga namin ang '0x46' at '0x77' sa 'byteA[2]' at 'byteA[4]', ayon sa pagkakabanggit. Pagkatapos, ang mga halagang ito ay binago mula sa byte array na aming ginawa. Pagkatapos nito, muli naming ginagamit ang 'para sa' loop upang ma-access ang lahat ng mga elemento ng byte array at ang idinagdag na 'cout' sa ibaba. Ngayon, ang mga binagong halaga ay nai-render dito kasama ng kanilang mga hexadecimal na numero.
Code 2:
#includegamit ang namespace std ;
int pangunahing ( ) {
hindi pinirmahan char byteA [ ] = { 0x21 , 0x22 , 0x23 , 0x24 , 0x25 , 0x26 } ;
cout << 'Pag-access sa mga elemento ng byte array' << endl ;
para sa ( int a = 0 ; a < sukat ng ( byteA ) ; a ++ ) {
cout << 'Ang byteArray[' << a << '] = ' << hex << ( int ) byteA [ a ] << endl ;
}
cout << ' \n Pagbabago ng mga elemento ng byte array:' << endl ;
byteA [ 0 ] = 0x11 ;
byteA [ 2 ] = 0x46 ;
byteA [ 4 ] = 0x77 ;
para sa ( int a = 0 ; a < sukat ng ( byteA ) ; a ++ ) {
cout << 'Ang byteArray[' << a << '] = ' << hex << ( int ) byteA [ a ] << endl ;
}
bumalik 0 ;
}
Output:
Ang byte array na ginawa namin at ang binagong array ay nai-render. Binago namin ang mga halaga ng byte array na ito sa aming code na na-render din sa kinalabasan na ito.
Halimbawa 3:
Dito, ginagamit namin ang 'transform()' na paraan upang i-convert ang aming string data sa byte array sa code na ito. Ang 'iostream', 'cstddef', at 'algorithm' na mga file ng header ay kasama sa code na ito. Ang mga header file na ito ay na-import upang madali naming magamit ang mga function na tinukoy sa kanila. Sa ilalim nito, inilalagay namin ang 'std' namespace at tinatawag ang 'main()' na paraan. Pagkatapos, sinisimulan namin ang variable na 'myString' ng uri ng data na 'string' gamit ang 'Hello World'.
Ngayon, idinagdag namin ang 'cout' upang ipakita ang ibinigay na pahayag. Sa ibaba nito, gumawa kami ng byte array na kapareho ng laki ng 'myString.length()'. Pagkatapos nito, ginagamit namin ang function na 'transform()' na umuulit sa mga string character at inilalagay ang 'const char& character' at 'return byte(character)' na nagko-convert ng elemento ng string sa mga byte at kinopya ang mga ito sa byte array.
Pagkatapos nito, ginagamit namin ang loop na 'para sa' kung saan idinaragdag namin ang 'const byte& byt: byteArray' na umuulit sa byte array. Pagkatapos, idagdag namin ang 'cout' na nagpapakita ng lahat ng mga elemento na na-convert sa byte array.
Code 3:
#include#include
#include
gamit ang namespace std ;
int pangunahing ( )
{
string myString = 'Hello World' ;
cout << 'Ang string ay' << myString << endl << endl ;
cout << 'Ang na-convert na string sa ByteArray ay ' << endl ;
byte byteArray [ myString. haba ( ) ] ;
ibahin ang anyo (
myString. magsimula ( ) ,
myString. wakas ( ) ,
byteArray ,
[ ] ( const char at karakter ) {
bumalik byte ( karakter ) ;
} ) ;
para sa ( const byte at isang patag : byteArray )
{
cout << to_integer < int > ( isang patag ) << ',' ;
}
cout << endl ;
bumalik 0 ;
}
Output:
Ang string at na-convert na string sa byte array ay nai-render na ngayon sa kinalabasan na ito. Na-convert namin ang string na ito sa byte array gamit ang 'transform()' na paraan sa aming code.
Halimbawa 4:
Gawing byte array ang aming data ng string gamit ang 'memcpy()' na paraan sa code na ito. Ngayon, kasama sa code na ito ang mga file ng header na 'iostream', 'cstddef', at 'algorithm'. Ini-import namin ang mga header file na ito upang magamit namin ang mga function na inilarawan sa mga ito nang madali. Ipinoposisyon namin ang 'std' namespace sa ilalim nito at hinihimok ang function na 'main()' mula sa lokasyong ito.
Susunod, sinisimulan namin ang 'Byte Array' sa variable na 'stringData'. Upang ipakita ang ibinigay na pahayag, isinama na namin ngayon ang utos na 'cout'. Sa ilalim nito, binubuo ang isang byte array na may kaparehong laki ng 'stringData.length()'. Ginagamit namin ang 'memcpy()' na paraan at nagpapasa ng tatlong parameter sa function na ito na 'ArrayOfBytes', 'stringData.data()', at 'stringData.length()', ayon sa pagkakabanggit. Nakakatulong ang function na ito sa pagkopya ng memorya ng character ng string sa byte array na aming idineklara.
Kasunod nito, ginagamit namin ang loop na 'para sa' kung saan nagdaragdag kami ng 'const byte& my_byte: ArrayOfBytes' upang tumawid sa byte array. Pagkatapos, idinaragdag namin ang function na 'cout' na nagpapakita ng bawat elemento na na-transform sa byte array.
Code 4:
#include#include
#include
gamit ang namespace std ;
int pangunahing ( )
{
string stringData = 'Byte Array' ;
cout << 'Ang string data ay' << stringData << endl << endl ;
cout << 'Ang string ay na-convert sa ByteArray dito na ' << endl ;
byte ArrayOfBytes [ stringData. haba ( ) ] ;
memcpy ( ArrayOfBytes , stringData. datos ( ) , stringData. haba ( ) ) ;
para sa ( const byte at my_byte : ArrayOfBytes )
{
cout << to_integer < int > ( my_byte ) << ',' ;
}
bumalik 0 ;
}
Output:
Ang resultang ito ay nagre-render ng orihinal na string at ang string na binago sa isang byte array. Ginagamit namin ang pamamaraang 'memcpy()' ng aming code upang baguhin ang string na ito sa byte array.
Konklusyon
Nalaman namin na ang mga byte array sa C++ ay nag-aalok ng mababang antas na diskarte sa mahusay na pagtatrabaho sa binary data. Ginalugad namin na nagbibigay sila sa amin ng kontrol sa memorya at isang pundasyon para sa mga gawain tulad ng serialization, networking, at mababang antas ng pagproseso ng data. Sa artikulong ito, ginalugad namin ang konsepto ng pagdedeklara at pagsisimula ng byte array sa C++ pati na rin ang conversion ng string sa byte array kasama ang kanilang mga code.