Exempel 1:
'iostream' ingår här som är rubrikfilen som hjälper till att använda funktionerna för att mata in eller mata ut data. Under detta använder vi standardnamnrymden 'std' och anropar 'main()'. Nu, i 'main()', deklarerar vi en byte-array med namnet 'mybyteArray[]' med datatypen 'unsigned char' och initierar den med fem element.
Sedan använder vi 'cout' som hjälper till att återge önskad data och placera 'för'-loopen. Denna 'for'-loop hjälper till att få elementen i byte-matrisen, och 'cout' hjälper till att återge elementen i denna byte-matris tillsammans med deras hexadecimala tal när vi placerar 'My byteArray[' << i << ']' och 'hex' i cout.
Kod 1:
#includeanvänder namnutrymme std ;
int huvud ( ) {
osignerad röding mybyteArray [ ] = { 0x31 , 0x32 , 0x33 , 0x34 , 0x35 } ;
cout << 'Elementen i byte-arrayen är:' << endl ;
för ( int i = 0 ; i < storlek av ( mybyteArray ) ; i ++ ) {
cout << 'My byteArray[' << i << '] = ' << hex << ( int ) mybyteArray [ i ] << endl ;
}
lämna tillbaka 0 ;
}
Produktion:
Resultatet av koden renderas här och byte-arrayen som vi skapade i den tidigare koden visas nu.
Exempel 2:
Den här koden inkluderar rubrikfilen 'iostream' som underlättar in- eller utdata med hjälp av funktionerna. Under detta anropar vi funktionen 'main()' och använder standardnamnrymden 'std'. Vi deklarerar och initierar sedan en byte-array med 'byteA[]'-namnet och datatypen 'unsigned char'. Vi tilldelar sex element till denna byte-array och använder sedan 'for'-loopen för att komma åt varje element. Vi använder 'cout' så att de hexadecimala talen för objekten i denna byte-matris visas nedan eftersom vi inkluderar både 'hex' och 'byteArray[' << a << ']' i den.
Nu ändrar vi elementen i denna byte-array genom att tilldela '0x11' till 'byteA[0]'. Sedan tilldelar vi '0x46' och '0x77' till 'byteA[2]' respektive 'byteA[4]'. Sedan modifieras dessa värden från byte-arrayen som vi skapade. Efter detta använder vi 'for'-loopen igen för att komma åt alla element i byte-arrayen och den tillagda 'cout' nedan. Nu återges de modifierade värdena här tillsammans med deras hexadecimala tal.
Kod 2:
#includeanvänder namnutrymme std ;
int huvud ( ) {
osignerad röding byteA [ ] = { 0x21 , 0x22 , 0x23 , 0x24 , 0x25 , 0x26 } ;
cout << 'Åtkomst till element i byte array' << endl ;
för ( int a = 0 ; a < storlek av ( byteA ) ; a ++ ) {
cout << 'The byteArray[' << a << '] = ' << hex << ( int ) byteA [ a ] << endl ;
}
cout << ' \n Ändra element i byte-arrayen:' << endl ;
byteA [ 0 ] = 0x11 ;
byteA [ 2 ] = 0x46 ;
byteA [ 4 ] = 0x77 ;
för ( int a = 0 ; a < storlek av ( byteA ) ; a ++ ) {
cout << 'The byteArray[' << a << '] = ' << hex << ( int ) byteA [ a ] << endl ;
}
lämna tillbaka 0 ;
}
Produktion:
Byte-arrayen som vi skapade och den modifierade arrayen renderas. Vi modifierade värdena för denna byte-array i vår kod som också återges i det här resultatet.
Exempel 3:
Här använder vi metoden 'transform()' för att konvertera våra strängdata till byte-arrayen i den här koden. Rubrikfilerna 'iostream', 'cstddef' och 'algoritm' ingår i den här koden. Dessa header-filer importeras så att vi enkelt kan använda funktionerna som är definierade i dem. Under detta placerar vi namnutrymmet 'std' och anropar metoden 'main()'. Sedan initierar vi variabeln 'myString' för datatypen 'sträng' med 'Hello World'.
Nu lägger vi till 'cout' för att visa det givna uttalandet. Under detta skapar vi byte-arrayen av samma storlek som 'myString.length()'. Efter detta använder vi funktionen 'transform()' som itererar över strängtecknen och placerar 'const char&-tecken' och 'return byte(character)' som omvandlar strängens element till byte och kopierar dem till byte array.
Efter detta använder vi 'for'-loopen där vi lägger till 'const byte& byt: byteArray' som itererar över byte-arrayen. Sedan lägger vi till 'cout' som visar alla element som konverteras till byte-arrayen.
Kod 3:
#include#include
#inkludera
använder namnutrymme std ;
int huvud ( )
{
sträng myString = 'Hej världen' ;
cout << 'Snöret är' << myString << endl << endl ;
cout << 'Den konverterade strängen till ByteArray är' << endl ;
byte byteArray [ myString. längd ( ) ] ;
omvandla (
myString. Börja ( ) ,
myString. slutet ( ) ,
byteArray ,
[ ] ( konst röding & karaktär ) {
lämna tillbaka byte ( karaktär ) ;
} ) ;
för ( konst byte & en lägenhet : byteArray )
{
cout << till_heltal < int > ( en lägenhet ) << ', ' ;
}
cout << endl ;
lämna tillbaka 0 ;
}
Produktion:
Strängen och den konverterade strängen till byte-arrayen renderas nu i detta resultat. Vi konverterade denna sträng till byte-arrayen med metoden 'transform()' i vår kod.
Exempel 4:
Låt oss förvandla vår strängdata till en byte-array med metoden 'memcpy()' i den här koden. Nu innehåller den här koden rubrikfilerna 'iostream', 'cstddef' och 'algoritm'. Vi importerar dessa header-filer så att vi enkelt kan använda funktionerna som beskrivs i dem. Vi placerar 'std'-namnrymden under detta och anropar 'main()'-funktionen från denna plats.
Därefter initierar vi 'Byte Array' i variabeln 'stringData'. För att visa det angivna uttalandet inkluderar vi nu kommandot 'cout'. Under det konstrueras en byte-array med samma storlek som 'stringData.length()'. Vi använder metoden 'memcpy()' och skickar tre parametrar i den här funktionen som är 'ArrayOfBytes', 'stringData.data()' respektive 'stringData.length()'. Denna funktion hjälper till att kopiera minnet av strängens tecken till den byte-array som vi deklarerade.
Efter detta använder vi 'for'-loopen där vi lägger till 'const byte& my_byte: ArrayOfBytes' för att gå över byte-arrayen. Sedan lägger vi till funktionen 'cout' som visar alla element som har omvandlats till byte-arrayen.
Kod 4:
#include#include
#include
använder namnutrymme std ;
int huvud ( )
{
string stringData = 'Byte Array' ;
cout << 'Strängdata är' << stringData << endl << endl ;
cout << 'Strängen konverteras till ByteArray här som är' << endl ;
byte ArrayOfBytes [ stringData. längd ( ) ] ;
memcpy ( ArrayOfBytes , stringData. data ( ) , stringData. längd ( ) ) ;
för ( konst byte & min_byte : ArrayOfBytes )
{
cout << till_heltal < int > ( min_byte ) << ', ' ;
}
lämna tillbaka 0 ;
}
Produktion:
Detta resultat återger den ursprungliga strängen och strängen som omvandlas till en byte-array. Vi använder vår kods 'memcpy()'-metod för att transformera denna sträng till byte-arrayen.
Slutsats
Vi lärde oss att byte-arrayer i C++ erbjuder en lågnivåmetod för att effektivt arbeta med binära data. Vi utforskade att de ger oss kontroll över minnet och en grund för uppgifter som serialisering, nätverk och lågnivådatabehandling. I den här artikeln utforskade vi konceptet med att deklarera och initiera byte-arrayen i C++ samt omvandlingen av strängen till byte-arrayen tillsammans med deras koder.