Пример 1:
Сюда включен «iostream», который представляет собой заголовочный файл, который помогает использовать функции для ввода или вывода данных. При этом мы используем стандартное пространство имен «std» и вызываем «main()». Теперь в «main()» мы объявляем массив байтов с именем «mybyteArray[]» с типом данных «unsigned char», а также инициализируем его пятью элементами.
Затем мы используем «cout», который помогает визуализировать нужные данные, и размещаем цикл «for». Этот цикл «for» помогает получить элементы байтового массива, а «cout» помогает визуализировать элементы этого байтового массива вместе с их шестнадцатеричными числами, когда мы помещаем «My byteArray[» << i << «]» и «шестнадцатеричный» в cout.
Код 1:
#includeиспользование пространства имен std ;
интервал основной ( ) {
без подписи голец mybyteArray [ ] '=' { 0x31 , 0x32 , 0x33 , 0x34 , 0x35 } ;
расчет << «Элементы байтового массива:» << конец ;
для ( интервал я '=' 0 ; я < размер ( mybyteArray ) ; я ++ ) {
расчет << 'Мой байтовый массив[' << я << '=' << шестигранник << ( интервал ) mybyteArray [ я ] << конец ;
}
возвращаться 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 } ;
расчет << «Доступ к элементам байтового массива» << конец ;
для ( интервал а '=' 0 ; а < размер ( байтА ) ; а ++ ) {
расчет << 'Байтовый массив[' << а << '=' << шестигранник << ( интервал ) байтА [ а ] << конец ;
}
расчет << ' \п Изменение элементов байтового массива:' << конец ;
байтА [ 0 ] '=' 0x11 ;
байтА [ 2 ] '=' 0x46 ;
байтА [ 4 ] '=' 0x77 ;
для ( интервал а '=' 0 ; а < размер ( байтА ) ; а ++ ) {
расчет << 'Байтовый массив[' << а << '=' << шестигранник << ( интервал ) байтА [ а ] << конец ;
}
возвращаться 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 ;
интервал основной ( )
{
строка '=' 'Привет, мир' ;
расчет << 'Строка есть' << мояСтрока << конец << конец ;
расчет << 'Преобразованная строка в ByteArray: ' << конец ;
байт байтмассив [ мояСтрока. длина ( ) ] ;
трансформировать (
мояСтрока. начинать ( ) ,
мояСтрока. конец ( ) ,
байтовый массив ,
[ ] ( константа голец & характер ) {
возвращаться байт ( характер ) ;
} ) ;
для ( константа байт & Квартира : байтовый массив )
{
расчет << to_integer < интервал > ( Квартира ) << ', ' ;
}
расчет << конец ;
возвращаться 0 ;
}
Выход:
Строка и преобразованная строка в массив байтов теперь отображаются в этом результате. Мы преобразовали эту строку в массив байтов, используя метод «transform()» в нашем коде.
Пример 4:
Давайте превратим наши строковые данные в массив байтов, используя метод memcpy() в этом коде. Теперь этот код включает в себя заголовочные файлы «iostream», «cstddef» и «algorithm». Мы импортируем эти заголовочные файлы, чтобы можно было легко использовать описанные в них функции. Мы размещаем пространство имен «std» под ним и вызываем функцию «main()» из этого места.
Далее мы инициализируем «Байтовый массив» в переменной «stringData». Чтобы отобразить предоставленный оператор, мы теперь включаем команду «cout». Под этим создается массив байтов того же размера, что и «stringData.length()». Мы используем метод «memcpy()» и передаем в эту функцию три параметра: «ArrayOfBytes», «stringData.data()» и «stringData.length()» соответственно. Эта функция помогает скопировать из памяти символ строки в объявленный нами байтовый массив.
После этого мы используем цикл «for», в котором добавляем «const byte& my_byte: ArrayOfBytes» для обхода массива байтов. Затем мы добавляем функцию «cout», которая показывает каждый элемент, преобразованный в массив байтов.
Код 4:
#include#include
#include
использование пространства имен std ;
интервал основной ( )
{
строка stringData '=' «Байтовый массив» ;
расчет << «Строковые данные» << строковые данные << конец << конец ;
расчет << 'Здесь строка преобразована в ByteArray, которая ' << конец ;
байтовый массив ArrayOfBytes [ строковые данные. длина ( ) ] ;
память ( МассивOfBytes , строковые данные. данные ( ) , строковые данные. длина ( ) ) ;
для ( константа байт & мой_байт : МассивOfBytes )
{
расчет << to_integer < интервал > ( мой_байт ) << ', ' ;
}
возвращаться 0 ;
}
Выход:
Этот результат отображает исходную строку и строку, преобразованную в массив байтов. Мы используем метод memcpy() нашего кода для преобразования этой строки в массив байтов.
Заключение
Мы узнали, что байтовые массивы в C++ предлагают низкоуровневый подход к эффективной работе с двоичными данными. Мы выяснили, что они предоставляют нам контроль над памятью и основу для таких задач, как сериализация, работа в сети и низкоуровневая обработка данных. В этой статье мы исследовали концепцию объявления и инициализации массива байтов в C++, а также преобразования строк в массив байтов вместе с их кодами.