Voorbeeld 1:
De 'iostream' is hier opgenomen, het headerbestand dat helpt bij het gebruik van de functies voor het invoeren of uitvoeren van de gegevens. Hieronder gebruiken we de standaard naamruimte “std” en roepen we “main()” aan. Nu declareren we in “main()” een byte-array met de naam “mybyteArray[]” met het datatype “unsigned char” en initialiseren we deze ook met vijf elementen.
Vervolgens gebruiken we ‘cout’, waarmee de gewenste gegevens worden weergegeven en de ‘for’-lus wordt geplaatst. Deze “for”-lus helpt bij het verkrijgen van de elementen van de byte-array, en “cout” helpt bij het weergeven van de elementen van deze byte-array samen met hun hexadecimale getallen terwijl we de “Mijn byteArray[” << i << “]” plaatsen en “hex” in cout.
Code1:
#includenamespace std; gebruiken ;
int voornaamst ( ) {
niet ondertekend verkoold mijnbyteArray [ ] = { 0x31 , 0x32 , 0x33 , 0x34 , 0x35 } ;
uit << 'De elementen van de byte-array zijn:' << eindl ;
voor ( int i = 0 ; i < De grootte van ( mijnbyteArray ) ; i ++ ) {
uit << 'Mijn byteArray[' << i << '] = ' << zeshoek << ( int ) mijnbyteArray [ i ] << eindl ;
}
opbrengst 0 ;
}
Uitgang:
Het resultaat van de code wordt hier weergegeven en de byte-array die we in de vorige code hebben gemaakt, wordt nu weergegeven.
Voorbeeld 2:
Deze code bevat het 'iostream'-headerbestand dat de invoer- of uitvoergegevens met behulp van de functies vergemakkelijkt. Hieronder noemen we de functie “main()” en gebruiken we de standaardnaamruimte “std”. Vervolgens declareren en initialiseren we een byte-array met de naam 'byteA[]' en het gegevenstype 'unsigned char'. We wijzen zes elementen toe aan deze byte-array en gebruiken vervolgens de “for”-lus om toegang te krijgen tot elk element. We gebruiken de “cout”, zodat de hexadecimale getallen van de items in deze byte-array hieronder worden weergegeven, omdat we zowel “hex” als “byteArray[” << a << “]” erin opnemen.
Nu veranderen we de elementen van deze byte-array door “0x11” toe te wijzen aan “byteA[0]”. Vervolgens wijzen we “0x46” en “0x77” toe aan respectievelijk “byteA[2]” en “byteA[4]”. Vervolgens worden deze waarden gewijzigd ten opzichte van de bytearray die we hebben gemaakt. Hierna gebruiken we opnieuw de “for”-lus om toegang te krijgen tot alle elementen van de byte-array en de toegevoegde “cout” hieronder. Nu worden de gewijzigde waarden hier weergegeven, samen met hun hexadecimale getallen.
Code2:
#includenamespace std; gebruiken ;
int voornaamst ( ) {
niet ondertekend verkoold byteA [ ] = { 0x21 , 0x22 , 0x23 , 0x24 , 0x25 , 0x26 } ;
uit << 'Toegang tot elementen van byte-array' << eindl ;
voor ( int A = 0 ; A < De grootte van ( byteA ) ; A ++ ) {
uit << 'De byteArray[' << A << '] = ' << zeshoek << ( int ) byteA [ A ] << eindl ;
}
uit << ' \N Elementen van de byte-array wijzigen:' << eindl ;
byteA [ 0 ] = 0x11 ;
byteA [ 2 ] = 0x46 ;
byteA [ 4 ] = 0x77 ;
voor ( int A = 0 ; A < De grootte van ( byteA ) ; A ++ ) {
uit << 'De byteArray[' << A << '] = ' << zeshoek << ( int ) byteA [ A ] << eindl ;
}
opbrengst 0 ;
}
Uitgang:
De byte-array die we hebben gemaakt en de gewijzigde array worden weergegeven. We hebben de waarden van deze byte-array in onze code aangepast, die ook in deze uitkomst wordt weergegeven.
Voorbeeld 3:
Hier gebruiken we de methode 'transform()' om onze stringgegevens naar de byte-array in deze code te converteren. De headerbestanden “iostream”, “cstddef” en “algorithm” zijn opgenomen in deze code. Deze headerbestanden worden geïmporteerd zodat we de functies die erin zijn gedefinieerd gemakkelijk kunnen gebruiken. Daaronder plaatsen we de naamruimte “std” en roepen de methode “main()” aan. Vervolgens initialiseren we de variabele “myString” van het gegevenstype “string” met “Hello World”.
Nu voegen we “cout” toe om de gegeven verklaring weer te geven. Hieronder maken we de byte-array van dezelfde grootte als de “myString.length()”. Hierna gebruiken we de functie “transform()” die de stringtekens herhaalt en de “const char& character” en “return byte(character)” plaatst die het element van de string naar de bytes converteert en deze naar de byte kopieert. reeks.
Hierna gebruiken we de “for” lus waar we de “const byte& byt: byteArray” toevoegen die de byte-array herhaalt. Vervolgens voegen we de 'cout' toe, die alle elementen weergeeft die naar de byte-array zijn geconverteerd.
Code 3:
#include#include
#include
namespace std; gebruiken ;
int voornaamst ( )
{
string mijnString = 'Hallo Wereld' ;
uit << 'De tekenreeks is' << mijnString << eindl << eindl ;
uit << 'De geconverteerde tekenreeks naar ByteArray is ' << eindl ;
byte byteArray [ mijnString. lengte ( ) ] ;
transformeren (
mijnString. beginnen ( ) ,
mijnString. einde ( ) ,
byteArray ,
[ ] ( const verkoold & karakter ) {
opbrengst byte ( karakter ) ;
} ) ;
voor ( const byte & een platte : byteArray )
{
uit << naar_geheel getal < int > ( een platte ) << ', ' ;
}
uit << eindl ;
opbrengst 0 ;
}
Uitgang:
De string en de geconverteerde string in de byte-array worden nu in deze uitkomst weergegeven. We hebben deze string omgezet in de byte-array met behulp van de “transform()” -methode in onze code.
Voorbeeld 4:
Laten we onze stringgegevens omzetten in een byte-array met behulp van de “memcpy()” -methode in deze code. Nu bevat deze code de headerbestanden “iostream”, “cstddef” en “algorithm”. Wij importeren deze headerbestanden zodat we de functies die daarin beschreven staan gemakkelijk kunnen gebruiken. We plaatsen de naamruimte “std” eronder en roepen vanaf deze locatie de functie “main()” aan.
Vervolgens initialiseren we de 'Byte Array' in de variabele 'stringData'. Om de verstrekte verklaring weer te geven, voegen we nu het commando “cout” toe. Daaronder wordt een byte-array met dezelfde grootte als “stringData.length()” geconstrueerd. We gebruiken de methode 'memcpy()' en geven drie parameters door in deze functie, namelijk 'ArrayOfBytes', 'stringData.data()' en 'stringData.length()', respectievelijk. Deze functie helpt bij het kopiëren van het geheugen van het teken van de string naar de byte-array die we hebben gedeclareerd.
Hierna gebruiken we de “for” lus waarin we “const byte& my_byte: ArrayOfBytes” toevoegen om de byte-array te doorlopen. Vervolgens voegen we de functie ‘cout’ toe, die elk element toont dat in de byte-array is getransformeerd.
Code 4:
#include#include
#include
namespace std; gebruiken ;
int voornaamst ( )
{
string stringData = 'Byte-array' ;
uit << 'De stringgegevens zijn ' << stringGegevens << eindl << eindl ;
uit << 'De string wordt hier omgezet in de ByteArray, namelijk ' << eindl ;
byte ArrayOfBytes [ stringGegevens. lengte ( ) ] ;
memcpy ( ArrayOfBytes , stringGegevens. gegevens ( ) , stringGegevens. lengte ( ) ) ;
voor ( const byte & mijn_byte : ArrayOfBytes )
{
uit << naar_geheel getal < int > ( mijn_byte ) << ', ' ;
}
opbrengst 0 ;
}
Uitgang:
Dit resultaat geeft de originele string weer en de string die is omgezet in een byte-array. We gebruiken de “memcpy()”-methode van onze code om deze string naar de byte-array te transformeren.
Conclusie
We hebben geleerd dat byte-arrays in C++ een laagdrempelige benadering bieden voor efficiënt werken met binaire gegevens. We hebben onderzocht dat ze ons controle geven over het geheugen en een basis bieden voor taken als serialisatie, netwerken en gegevensverwerking op laag niveau. In dit artikel hebben we het concept van het declareren en initialiseren van de byte-array in C++ onderzocht, evenals de conversie van de string naar de byte-array samen met hun codes.