Beispiel 1:
Hier ist der „iostream“ enthalten, die Header-Datei, die bei der Verwendung der Funktionen zur Eingabe oder Ausgabe der Daten hilft. Darunter nutzen wir den Standard-Namespace „std“ und rufen „main()“ auf. Nun deklarieren wir in „main()“ ein Byte-Array mit dem Namen „mybyteArray[]“ mit dem Datentyp „unsigned char“ und initialisieren es ebenfalls mit fünf Elementen.
Dann verwenden wir „cout“, das dabei hilft, die gewünschten Daten zu rendern und die „for“-Schleife zu platzieren. Diese „for“-Schleife hilft dabei, die Elemente des Byte-Arrays abzurufen, und „cout“ hilft beim Rendern der Elemente dieses Byte-Arrays zusammen mit ihren Hexadezimalzahlen, wenn wir „My byteArray[“ << i << „]“ platzieren. und „hex“ in cout.
Code 1:
#includeVerwenden des Namensraums std ;
int hauptsächlich ( ) {
ohne Vorzeichen verkohlen mybyteArray [ ] = { 0x31 , 0x32 , 0x33 , 0x34 , 0x35 } ;
cout << „Die Elemente des Byte-Arrays sind:“ << endl ;
für ( int ich = 0 ; ich < Größe von ( mybyteArray ) ; ich ++ ) {
cout << „Mein byteArray[“ << ich << '] = ' << verhexen << ( int ) mybyteArray [ ich ] << endl ;
}
zurückkehren 0 ;
}
Ausgabe:
Das Ergebnis des Codes wird hier gerendert und das Byte-Array, das wir im vorherigen Code erstellt haben, wird jetzt angezeigt.
Beispiel 2:
Dieser Code enthält die Header-Datei „iostream“, die die Eingabe oder Ausgabe von Daten mithilfe der Funktionen erleichtert. Darunter rufen wir die Funktion „main()“ auf und verwenden den Standard-Namespace „std“. Anschließend deklarieren und initialisieren wir ein Byte-Array mit dem Namen „byteA[]“ und dem Datentyp „unsigned char“. Wir weisen diesem Byte-Array sechs Elemente zu und verwenden dann die „for“-Schleife, um auf jedes Element zuzugreifen. Wir verwenden „cout“, sodass die Hexadezimalzahlen der Elemente in diesem Byte-Array unten angezeigt werden, da wir sowohl „hex“ als auch „byteArray[“ << a << „]“ darin einschließen.
Jetzt ändern wir die Elemente dieses Byte-Arrays, indem wir „0x11“ „byteA[0]“ zuweisen. Dann weisen wir „byteA[2]“ bzw. „byteA[4]“ „0x46“ und „0x77“ zu. Anschließend werden diese Werte aus dem von uns erstellten Byte-Array geändert. Danach verwenden wir erneut die „for“-Schleife, um auf alle Elemente des Byte-Arrays und das unten hinzugefügte „cout“ zuzugreifen. Nun werden hier die geänderten Werte zusammen mit ihren Hexadezimalzahlen gerendert.
Code 2:
#includeVerwenden des Namensraums std ;
int hauptsächlich ( ) {
ohne Vorzeichen verkohlen ByteA [ ] = { 0x21 , 0x22 , 0x23 , 0x24 , 0x25 , 0x26 } ;
cout << „Zugriff auf Elemente eines Byte-Arrays“ << endl ;
für ( int A = 0 ; A < Größe von ( ByteA ) ; A ++ ) {
cout << „Das byteArray[“ << A << '] = ' << verhexen << ( int ) ByteA [ A ] << endl ;
}
cout << ' \N Elemente des Byte-Arrays ändern:' << endl ;
ByteA [ 0 ] = 0x11 ;
ByteA [ 2 ] = 0x46 ;
ByteA [ 4 ] = 0x77 ;
für ( int A = 0 ; A < Größe von ( ByteA ) ; A ++ ) {
cout << „Das byteArray[“ << A << '] = ' << verhexen << ( int ) ByteA [ A ] << endl ;
}
zurückkehren 0 ;
}
Ausgabe:
Das von uns erstellte Byte-Array und das geänderte Array werden gerendert. Wir haben die Werte dieses Byte-Arrays in unserem Code geändert, der auch in diesem Ergebnis gerendert wird.
Beispiel 3:
Hier verwenden wir die Methode „transform()“, um unsere String-Daten in das Byte-Array in diesem Code umzuwandeln. Die Header-Dateien „iostream“, „cstddef“ und „algorithm“ sind in diesem Code enthalten. Diese Header-Dateien werden importiert, damit wir die darin definierten Funktionen problemlos nutzen können. Darunter platzieren wir den Namensraum „std“ und rufen die Methode „main()“ auf. Anschließend initialisieren wir die Variable „myString“ des Datentyps „string“ mit „Hello World“.
Jetzt fügen wir „cout“ hinzu, um die angegebene Anweisung anzuzeigen. Darunter erstellen wir das Byte-Array mit der gleichen Größe wie „myString.length()“. Danach verwenden wir die Funktion „transform()“, die über die Zeichenfolgenzeichen iteriert und „const char& sign“ und „return byte(character)“ platziert, die das Element der Zeichenfolge in Bytes umwandeln und sie in das Byte kopieren Array.
Danach verwenden wir die „for“-Schleife, in der wir das „const byte& byt: byteArray“ hinzufügen, das über das Byte-Array iteriert. Dann fügen wir den „cout“ hinzu, der alle Elemente anzeigt, die in das Byte-Array konvertiert werden.
Code 3:
#include#include
#include
Verwenden des Namensraums std ;
int hauptsächlich ( )
{
string myString = 'Hallo Welt' ;
cout << „Die Zeichenfolge ist“ << meinString << endl << endl ;
cout << „Der in ByteArray konvertierte String ist „ << endl ;
Byte byteArray [ meinString. Länge ( ) ] ;
verwandeln (
meinString. beginnen ( ) ,
meinString. Ende ( ) ,
byteArray ,
[ ] ( const verkohlen & Charakter ) {
zurückkehren Byte ( Charakter ) ;
} ) ;
für ( const Byte & eine Wohnung : byteArray )
{
cout << to_integer < int > ( eine Wohnung ) << ',' ;
}
cout << endl ;
zurückkehren 0 ;
}
Ausgabe:
Der String und der in das Byte-Array konvertierte String werden nun in diesem Ergebnis gerendert. Wir haben diesen String mit der Methode „transform()“ in unserem Code in das Byte-Array umgewandelt.
Beispiel 4:
Lassen Sie uns unsere String-Daten mit der Methode „memcpy()“ in diesem Code in ein Byte-Array umwandeln. Dieser Code enthält nun die Header-Dateien „iostream“, „cstddef“ und „algorithm“. Wir importieren diese Header-Dateien, damit wir die darin beschriebenen Funktionen problemlos nutzen können. Darunter positionieren wir den Namensraum „std“ und rufen von dort aus die Funktion „main()“ auf.
Als nächstes initialisieren wir das „Byte Array“ in der Variablen „stringData“. Um die bereitgestellte Anweisung anzuzeigen, fügen wir jetzt den Befehl „cout“ ein. Darunter wird ein Byte-Array mit der gleichen Größe wie „stringData.length()“ aufgebaut. Wir verwenden die Methode „memcpy()“ und übergeben in dieser Funktion drei Parameter: „ArrayOfBytes“, „stringData.data()“ und „stringData.length()“. Diese Funktion hilft beim Kopieren des Speichers des Zeichens der Zeichenfolge in das von uns deklarierte Byte-Array.
Anschließend verwenden wir die „for“-Schleife, in der wir „const byte& my_byte: ArrayOfBytes“ hinzufügen, um das Byte-Array zu durchlaufen. Dann fügen wir die Funktion „cout“ hinzu, die jedes Element anzeigt, das in das Byte-Array umgewandelt wurde.
Code 4:
#include#include
#include
Verwenden des Namensraums std ;
int hauptsächlich ( )
{
string stringData = „Byte-Array“ ;
cout << „Die String-Daten sind“ << stringData << endl << endl ;
cout << „Der hier in das ByteArray konvertierte String ist „ << endl ;
Byte ArrayOfBytes [ stringData. Länge ( ) ] ;
memcpy ( Reihe von Bytes , stringData. Daten ( ) , stringData. Länge ( ) ) ;
für ( const Byte & mein_byte : Reihe von Bytes )
{
cout << to_integer < int > ( mein_byte ) << ',' ;
}
zurückkehren 0 ;
}
Ausgabe:
Dieses Ergebnis rendert die ursprüngliche Zeichenfolge und die Zeichenfolge, die in ein Byte-Array umgewandelt wird. Wir verwenden die „memcpy()“-Methode unseres Codes, um diesen String in das Byte-Array umzuwandeln.
Abschluss
Wir haben gelernt, dass Byte-Arrays in C++ einen Low-Level-Ansatz für die effiziente Arbeit mit Binärdaten bieten. Wir haben untersucht, dass sie uns die Kontrolle über den Speicher und eine Grundlage für Aufgaben wie Serialisierung, Vernetzung und Datenverarbeitung auf niedriger Ebene bieten. In diesem Artikel haben wir das Konzept der Deklaration und Initialisierung des Byte-Arrays in C++ sowie die Konvertierung des Strings in das Byte-Array zusammen mit ihren Codes untersucht.