Eksempel 1:
'iostream' er inkluderet her, som er header-filen, der hjælper med at bruge funktionerne til at indtaste eller udlæse dataene. Under dette bruger vi standardnavnerummet 'std' og kalder 'main()'. Nu, i 'main()', erklærer vi en byte-array med navnet 'mybyteArray[]' med datatypen 'unsigned char' og initialiserer den også med fem elementer.
Derefter bruger vi 'cout', som hjælper med at gengive de ønskede data og placere 'for'-løkken. Denne 'for'-løkke hjælper med at få elementerne i byte-arrayet, og 'cout' hjælper med at gengive elementerne i denne byte-array sammen med deres hexadecimale tal, når vi placerer 'My byteArray[' << i << ']' og 'hex' i cout.
Kode 1:
#includebruger navneområde std ;
int vigtigste ( ) {
usigneret char mybyteArray [ ] = { 0x31 , 0x32 , 0x33 , 0x34 , 0x35 } ;
cout << 'Elementerne i byte-arrayet er:' << endl ;
til ( int jeg = 0 ; jeg < størrelse af ( mybyteArray ) ; jeg ++ ) {
cout << 'Min byteArray[' << jeg << '] = ' << hex << ( int ) mybyteArray [ jeg ] << endl ;
}
Vend tilbage 0 ;
}
Produktion:
Resultatet af koden gengives her, og byte-arrayet, som vi oprettede i den forrige kode, vises nu.
Eksempel 2:
Denne kode inkluderer 'iostream'-headerfilen, som letter input- eller outputdata ved hjælp af funktionerne. Herunder kalder vi funktionen 'main()' og bruger standardnavneområdet 'std'. Vi erklærer og initialiserer derefter et byte-array med 'byteA[]'-navnet og datatypen 'unsigned char'. Vi tildeler seks elementer til denne byte-array og bruger derefter 'for'-løkken til at få adgang til hvert element. Vi bruger 'cout', så de hexadecimale tal for elementerne i denne byte-array vises nedenfor, da vi inkluderer både 'hex' og 'byteArray[' << a << ']' i den.
Nu ændrer vi elementerne i denne byte-array ved at tildele '0x11' til 'byteA[0]'. Derefter tildeler vi '0x46' og '0x77' til henholdsvis 'byteA[2]' og 'byteA[4]'. Derefter modificeres disse værdier fra byte-arrayet, som vi oprettede. Efter dette bruger vi 'for'-løkken igen for at få adgang til alle elementerne i byte-arrayet og den tilføjede 'cout' nedenfor. Nu gengives de ændrede værdier her sammen med deres hexadecimale tal.
Kode 2:
#includebruger navneområde std ;
int vigtigste ( ) {
usigneret char byteA [ ] = { 0x21 , 0x22 , 0x23 , 0x24 , 0x25 , 0x26 } ;
cout << 'Adgang til elementer i byte-array' << endl ;
til ( int -en = 0 ; -en < størrelse af ( byteA ) ; -en ++ ) {
cout << 'The byteArray[' << -en << '] = ' << hex << ( int ) byteA [ -en ] << endl ;
}
cout << ' \n Ændring af elementer i byte-arrayet:' << endl ;
byteA [ 0 ] = 0x11 ;
byteA [ 2 ] = 0x46 ;
byteA [ 4 ] = 0x77 ;
til ( int -en = 0 ; -en < størrelse af ( byteA ) ; -en ++ ) {
cout << 'The byteArray[' << -en << '] = ' << hex << ( int ) byteA [ -en ] << endl ;
}
Vend tilbage 0 ;
}
Produktion:
Byte-arrayet, som vi oprettede, og det modificerede array gengives. Vi ændrede værdierne for denne byte-array i vores kode, som også gengives i dette resultat.
Eksempel 3:
Her bruger vi 'transform()'-metoden til at konvertere vores strengdata til byte-arrayet i denne kode. 'iostream', 'cstddef' og 'algorithm' header-filer er inkluderet i denne kode. Disse header-filer importeres, så vi nemt kan bruge de funktioner, der er defineret i dem. Under dette placerer vi 'std'-navnerummet og kalder 'main()'-metoden. Derefter initialiserer vi 'myString'-variablen af 'streng'-datatypen med 'Hello World'.
Nu tilføjer vi 'cout' for at vise den givne erklæring. Herunder opretter vi byte-arrayet af samme størrelse som 'myString.length()'. Efter dette bruger vi 'transform()'-funktionen, som itererer over strengtegnene og placerer 'const char&-tegnet' og 'return byte(character)', der konverterer strengens element til bytes og kopierer dem til byten array.
Efter dette bruger vi 'for'-løkken, hvor vi tilføjer 'const byte& byt: byteArray', som itererer over byte-arrayet. Derefter tilføjer vi 'cout', som viser alle de elementer, der er konverteret til byte-arrayet.
Kode 3:
#include#include
#include
bruger navneområde std ;
int vigtigste ( )
{
streng myString = 'Hej Verden' ;
cout << 'Snoren er' << myString << endl << endl ;
cout << 'Den konverterede streng til ByteArray er' << endl ;
byte byteArray [ myString. længde ( ) ] ;
transformere (
myString. begynde ( ) ,
myString. ende ( ) ,
byteArray ,
[ ] ( konst char & Karakter ) {
Vend tilbage byte ( Karakter ) ;
} ) ;
til ( konst byte & en lejlighed : byteArray )
{
cout << til_heltal < int > ( en lejlighed ) << ', ' ;
}
cout << endl ;
Vend tilbage 0 ;
}
Produktion:
Strengen og den konverterede streng til byte-arrayet gengives nu i dette resultat. Vi konverterede denne streng til byte-arrayet ved hjælp af 'transform()'-metoden i vores kode.
Eksempel 4:
Lad os omdanne vores strengdata til et byte-array ved hjælp af 'memcpy()'-metoden i denne kode. Nu inkluderer denne kode 'iostream', 'cstddef' og 'algoritme' header-filer. Vi importerer disse header-filer, så vi nemt kan bruge de funktioner, der er beskrevet i dem. Vi placerer 'std'-navnerummet under dette og kalder 'main()'-funktionen fra denne placering.
Dernæst initialiserer vi 'Byte Array' i variablen 'stringData'. For at vise den angivne erklæring inkluderer vi nu kommandoen 'cout'. Under det er et byte-array med samme størrelse som 'stringData.length()' konstrueret. Vi bruger metoden 'memcpy()' og videregiver tre parametre i denne funktion, som er henholdsvis 'ArrayOfBytes', 'stringData.data()' og 'stringData.length()'. Denne funktion hjælper med at kopiere hukommelsen af strengens karakter til den byte-array, som vi har erklæret.
Efter dette bruger vi 'for'-løkken, hvor vi tilføjer 'const byte& my_byte: ArrayOfBytes' for at krydse byte-arrayet. Derefter tilføjer vi funktionen 'cout', som viser hvert element, der er blevet transformeret til byte-arrayet.
Kode 4:
#include#include
#include
bruger navneområde std ;
int vigtigste ( )
{
string stringData = 'Byte Array' ;
cout << 'Strengen data er' << stringData << endl << endl ;
cout << 'Strengen konverteret til ByteArray her, som er' << endl ;
byte ArrayOfBytes [ stringData. længde ( ) ] ;
memcpy ( ArrayOfBytes , stringData. data ( ) , stringData. længde ( ) ) ;
til ( konst byte & min_byte : ArrayOfBytes )
{
cout << til_heltal < int > ( min_byte ) << ', ' ;
}
Vend tilbage 0 ;
}
Produktion:
Dette resultat gengiver den oprindelige streng og strengen, der er transformeret til en byte-array. Vi bruger vores kodes 'memcpy()'-metode til at transformere denne streng til byte-arrayet.
Konklusion
Vi lærte, at byte-arrays i C++ tilbyder en tilgang på lavt niveau til at arbejde med binære data effektivt. Vi undersøgte, at de giver os kontrol over hukommelsen og et grundlag for opgaver som serialisering, netværk og databehandling på lavt niveau. I denne artikel undersøgte vi konceptet med at deklarere og initialisere byte-arrayet i C++ samt konverteringen af strengen til byte-arrayet sammen med deres koder.