Пример 1:
Тук е включен „iostream“, който е заглавният файл, който помага при използването на функциите за въвеждане или извеждане на данните. Под това ние използваме стандартното пространство от имена „std“ и извикваме „main()“. Сега в “main()” декларираме байтов масив с името “mybyteArray[]” с типа данни “unsigned char” и също го инициализираме с пет елемента.
След това използваме „cout“, което помага за изобразяването на желаните данни и поставянето на цикъла „for“. Този цикъл „for“ помага за получаване на елементите на масива от байтове, а „cout“ помага за изобразяването на елементите от този масив от байтове заедно с техните шестнадесетични числа, докато поставяме „My byteArray[“ << i << „]“ и 'hex' в cout.
Код 1:
#includeизползване на пространство от имена std ;
вътр основен ( ) {
неподписан въглен mybyteArray [ ] = { 0x31 , 0x32 , 0x33 , 0x34 , 0x35 } ;
cout << „Елементите на байтовия масив са:“ << endl ;
за ( вътр аз = 0 ; аз < размер на ( mybyteArray ) ; аз ++ ) {
cout << 'Моят byteArray[' << аз << '] = ' << шестнадесетичен << ( вътр ) mybyteArray [ аз ] << endl ;
}
връщане 0 ;
}
Изход:
Резултатът от кода се изобразява тук и масивът от байтове, който създадохме в предишния код, вече се показва.
Пример 2:
Този код включва заглавния файл „iostream“, който улеснява въвеждането или изхода на данни с помощта на функциите. Под това извикваме функцията „main()“ и използваме стандартното пространство от имена „std“. След това декларираме и инициализираме байтов масив с името “byteA[]” и типа данни “unsigned char”. Присвояваме шест елемента на този байтов масив и след това използваме цикъла „for“ за достъп до всеки елемент. Ние използваме „cout“, така че шестнадесетичните числа на елементите в този масив от байтове се показват по-долу, тъй като включваме и „hex“, и „byteArray[” << a << „]” в него.
Сега променяме елементите на този масив от байтове, като присвояваме “0x11” на “byteA[0]”. След това присвояваме “0x46” и “0x77” съответно на “byteA[2]” и “byteA[4]”. След това тези стойности се променят от байтовия масив, който създадохме. След това отново използваме цикъла „for“ за достъп до всички елементи на байтовия масив и добавения „cout“ по-долу. Сега модифицираните стойности се изобразяват тук заедно с техните шестнадесетични числа.
Код 2:
#includeизползване на пространство от имена std ;
вътр основен ( ) {
неподписан въглен байтА [ ] = { 0x21 , 0x22 , 0x23 , 0x24 , 0x25 , 0x26 } ;
cout << „Достъп до елементи от байтов масив“ << endl ;
за ( вътр а = 0 ; а < размер на ( байтА ) ; а ++ ) {
cout << 'The byteArray[' << а << '] = ' << шестнадесетичен << ( вътр ) байтА [ а ] << endl ;
}
cout << ' \н Промяна на елементи от байтовия масив:' << endl ;
байтА [ 0 ] = 0x11 ;
байтА [ 2 ] = 0x46 ;
байтА [ 4 ] = 0x77 ;
за ( вътр а = 0 ; а < размер на ( байтА ) ; а ++ ) {
cout << 'The byteArray[' << а << '] = ' << шестнадесетичен << ( вътр ) байтА [ а ] << endl ;
}
връщане 0 ;
}
Изход:
Масивът от байтове, който създадохме, и модифицираният масив се изобразяват. Променихме стойностите на този масив от байтове в нашия код, който също се изобразява в този резултат.
Пример 3:
Тук използваме метода „transform()“, за да конвертираме нашите низови данни в байтовия масив в този код. Заглавните файлове „iostream“, „cstddef“ и „algorithm“ са включени в този код. Тези заглавни файлове се импортират, за да можем лесно да използваме функциите, които са дефинирани в тях. Под това поставяме пространството от имена „std“ и извикваме метода „main()“. След това инициализираме променливата “myString” от типа данни “string” с “Hello World”.
Сега добавяме „cout“, за да покажем дадения оператор. Под това създаваме масив от байтове със същия размер като „myString.length()“. След това използваме функцията „transform()“, която итерира символите на низа и поставя „const char& character“ и „return byte(character)“, която преобразува елемента на низа в байтове и ги копира в байт масив.
След това използваме цикъла „for“, където добавяме „const byte& byt: byteArray“, който обхожда масива от байтове. След това добавяме „cout“, който показва всички елементи, които са преобразувани в байтовия масив.
Код 3:
#include#include
#include <алгоритъм>
използване на пространство от имена std ;
вътр основен ( )
{
низ myString = 'Здравей свят' ;
cout << 'Низът е' << myString << endl << endl ;
cout << 'Преобразуваният низ в ByteArray е ' << endl ;
байт byteArray [ myString. дължина ( ) ] ;
трансформирам (
myString. започвам ( ) ,
myString. край ( ) ,
byteArray ,
[ ] ( конст въглен и характер ) {
връщане байт ( характер ) ;
} ) ;
за ( конст байт и апартамент : byteArray )
{
cout << към_цяло число < вътр > ( апартамент ) << ', ' ;
}
cout << endl ;
връщане 0 ;
}
Изход:
Низът и преобразуваният низ в байтовия масив вече се изобразяват в този резултат. Преобразувахме този низ в масив от байтове, използвайки метода „transform()“ в нашия код.
Пример 4:
Нека превърнем нашите низови данни в байтов масив, използвайки метода „memcpy()“ в този код. Сега този код включва заглавните файлове „iostream“, „cstddef“ и „algorithm“. Ние импортираме тези заглавни файлове, за да можем да използваме функциите, които са описани в тях с лекота. Позиционираме пространството от имена „std“ под това и извикваме функцията „main()“ от това място.
След това инициализираме „Byte Array“ в променливата „stringData“. За да покажем предоставения оператор, сега включваме командата “cout”. Под това се конструира байтов масив със същия размер като „stringData.length()“. Ние използваме метода “memcpy()” и предаваме три параметъра в тази функция, които са съответно “ArrayOfBytes”, “stringData.data()” и “stringData.length()”. Тази функция помага при копирането на паметта на символа на низа в байтовия масив, който сме декларирали.
След това използваме цикъла „for“, в който добавяме „const byte& my_byte: ArrayOfBytes“, за да преминем през масива от байтове. След това добавяме функцията „cout“, която показва всеки елемент, който е бил трансформиран в байтовия масив.
Код 4:
#include#include
#include
използване на пространство от имена std ;
вътр основен ( )
{
низ stringData = 'Байтов масив' ;
cout << 'Данните за низа са ' << stringData << endl << endl ;
cout << 'Низът се преобразува в ByteArray тук, който е ' << endl ;
байт ArrayOfBytes [ stringData. дължина ( ) ] ;
memcpy ( ArrayOfBytes , stringData. данни ( ) , stringData. дължина ( ) ) ;
за ( конст байт и my_byte : ArrayOfBytes )
{
cout << към_цяло число < вътр > ( my_byte ) << ', ' ;
}
връщане 0 ;
}
Изход:
Този резултат изобразява оригиналния низ и низа, който се трансформира в байтов масив. Използваме метода „memcpy()“ на нашия код, за да преобразуваме този низ в байтовия масив.
Заключение
Научихме, че байтовите масиви в C++ предлагат подход на ниско ниво за ефективна работа с двоични данни. Проучихме, че те ни осигуряват контрол върху паметта и основа за задачи като сериализиране, работа в мрежа и обработка на данни на ниско ниво. В тази статия изследвахме концепцията за деклариране и инициализиране на байтовия масив в C++, както и преобразуването на низа в байтовия масив заедно с техните кодове.