דוגמה 1:
ה-'iostream' כלול כאן שהוא קובץ הכותרת המסייע בניצול הפונקציות לקלט או פלט של הנתונים. מתחת לזה, אנו משתמשים במרחב השמות הסטנדרטי 'std' ומפעילים את 'main()'. כעת, ב-'main()', אנו מכריזים על מערך בתים בשם 'mybyteArray[]' עם סוג הנתונים 'char unsigned' וגם מאתחלים אותו עם חמישה אלמנטים.
לאחר מכן, אנו משתמשים ב-'cout' שעוזר לעבד את הנתונים הרצויים ולהציב את לולאת ה-'for'. לולאת 'for' זו מסייעת בקבלת האלמנטים של מערך הבתים, ו-'cout' מסייעת בעיבוד האלמנטים של מערך הבתים הזה יחד עם המספרים ההקסדצימליים שלהם כאשר אנו מציבים את 'My byteArray[' << i << ']' ו'הקס' ב-cout.
קוד 1:
#includeבאמצעות מרחב שמות std ;
int רָאשִׁי ( ) {
לא חתום לְהַשְׁחִיר mybyteArray [ ] = { 0x31 , 0x32 , 0x33 , 0x34 , 0x35 } ;
cout << 'הרכיבים של מערך הבתים הם:' << endl ;
ל ( int אני = 0 ; אני < מידה של ( mybyteArray ) ; אני ++ ) {
cout << 'My byteArray[' << אני << '] = ' << hex << ( int ) mybyteArray [ אני ] << endl ;
}
לַחֲזוֹר 0 ;
}
תְפוּקָה:
תוצאת הקוד מוצגת כאן ומערך הבתים שיצרנו בקוד הקודם מוצג כעת.
דוגמה 2:
קוד זה כולל את קובץ הכותרת 'iostream' שמקל על נתוני הקלט או הפלט באמצעות הפונקציות. מתחת לזה, אנו קוראים לפונקציה 'main()' ומשתמשים במרחב השמות הסטנדרטי 'std'. לאחר מכן אנו מכריזים ומאתחלים מערך בתים עם השם 'byteA[]' וסוג הנתונים 'char unsigned'. אנו מקצים שישה אלמנטים למערך בתים זה ולאחר מכן משתמשים בלולאת 'for' כדי לגשת לכל אלמנט. אנו משתמשים ב-'cout' כך שהמספרים ההקסדצימליים של הפריטים במערך בתים זה מוצגים למטה מכיוון שאנו כוללים בו גם 'hex' וגם 'byteArray[' << a << ']'.
כעת, אנו משנים את הרכיבים של מערך הבתים הזה על ידי הקצאת '0x11' ל-'byteA[0]'. לאחר מכן, אנו מקצים '0x46' ו-'0x77' ל-'byteA[2]' ו-'byteA[4]', בהתאמה. לאחר מכן, ערכים אלו משתנים ממערך הבתים שיצרנו. לאחר מכן, אנו משתמשים שוב בלולאת 'for' כדי לגשת לכל האלמנטים של מערך הבתים וה-'cout' שנוסף למטה. כעת, הערכים ששונו מוצגים כאן יחד עם המספרים ההקסדצימליים שלהם.
קוד 2:
#includeבאמצעות מרחב שמות std ;
int רָאשִׁי ( ) {
לא חתום לְהַשְׁחִיר byteA [ ] = { 0x21 , 0x22 , 0x23 , 0x24 , 0x25 , 0x26 } ;
cout << 'גישה לאלמנטים של מערך בתים' << endl ;
ל ( int א = 0 ; א < מידה של ( byteA ) ; א ++ ) {
cout << 'The byteArray[' << א << '] = ' << hex << ( int ) byteA [ א ] << endl ;
}
cout << ' \n שינוי אלמנטים של מערך הבתים:' << endl ;
byteA [ 0 ] = 0x11 ;
byteA [ 2 ] = 0x46 ;
byteA [ 4 ] = 0x77 ;
ל ( int א = 0 ; א < מידה של ( byteA ) ; א ++ ) {
cout << 'The byteArray[' << א << '] = ' << hex << ( int ) byteA [ א ] << endl ;
}
לַחֲזוֹר 0 ;
}
תְפוּקָה:
מערך הבתים שיצרנו והמערך המשתנה מוצגים. שינינו את הערכים של מערך הבתים הזה בקוד שלנו שמוצג גם בתוצאה זו.
דוגמה 3:
כאן, אנו משתמשים בשיטת 'transform()' כדי להמיר את נתוני המחרוזת שלנו למערך הבתים בקוד זה. קובצי הכותרת 'iostream', 'cstddef' ו-'algorithm' כלולים בקוד זה. קובצי כותרות אלו מיובאים כך שנוכל להשתמש בקלות בפונקציות המוגדרות בהם. מתחת לזה, אנו מניחים את מרחב השמות 'std' וקוראים לשיטת 'main()'. לאחר מכן, אנו מאתחלים את המשתנה 'myString' של סוג הנתונים 'מחרוזת' עם 'Hello World'.
כעת, אנו מוסיפים 'cout' כדי להציג את ההצהרה הנתונה. מתחת לזה, אנו יוצרים את מערך הבתים בגודל זהה ל-'myString.length()'. לאחר מכן, אנו משתמשים בפונקציית 'transform()' החוזרת על תווי המחרוזת וממקמים את 'const char& character' ו-'return byte(character)' הממיר את רכיב המחרוזת לבייטים ומעתיק אותם לבייט מַעֲרָך.
לאחר מכן, אנו משתמשים בלולאת 'for' שבה נוסיף את 'const byte& byt: byteArray' שחוזר על מערך הבתים. לאחר מכן, נוסיף את ה-'cout' המציג את כל האלמנטים שהומרו למערך הבתים.
קוד 3:
#include#include
#include <אלגוריתם>
באמצעות מרחב שמות std ;
int רָאשִׁי ( )
{
מחרוזת myString = 'שלום עולם' ;
cout << 'המחרוזת היא' << myString << endl << endl ;
cout << 'המחרוזת שהומרה ל-ByteArray היא' << endl ;
byte byteArray [ myString. אורך ( ) ] ;
שינוי צורה (
myString. התחל ( ) ,
myString. סוֹף ( ) ,
byteArray ,
[ ] ( const לְהַשְׁחִיר & אופי ) {
לַחֲזוֹר בייט ( אופי ) ;
} ) ;
ל ( const בייט & שטוח : byteArray )
{
cout << to_integer < int > ( שטוח ) << ',' ;
}
cout << endl ;
לַחֲזוֹר 0 ;
}
תְפוּקָה:
המחרוזת והמחרוזת שהומרה למערך הבתים מוצגות כעת בתוצאה זו. המרנו מחרוזת זו למערך הבתים באמצעות שיטת 'transform()' בקוד שלנו.
דוגמה 4:
בואו נהפוך את נתוני המחרוזת שלנו למערך בתים באמצעות שיטת 'memcpy()' בקוד זה. כעת, קוד זה כולל את קובצי הכותרת 'iostream', 'cstddef' ו'אלגוריתם'. אנו מייבאים את קובצי הכותרות הללו כדי שנוכל להשתמש בפונקציות המתוארות בהם בקלות. אנו ממקמים את מרחב השמות 'std' מתחת לזה ומפעילים את הפונקציה 'main()' ממיקום זה.
לאחר מכן, אנו מאתחלים את 'מערך הבתים' במשתנה 'stringData'. כדי להציג את ההצהרה שסופקה, אנו כוללים כעת את הפקודה 'cout'. מתחת לזה, נבנה מערך בתים באותו גודל כמו 'stringData.length()'. אנו משתמשים בשיטת 'memcpy()' ומעבירים שלושה פרמטרים בפונקציה הזו שהם 'ArrayOfBytes', 'stringData.data()', ו-'stringData.length()', בהתאמה. פונקציה זו מסייעת בהעתקת הזיכרון של תו המחרוזת למערך הבתים שהכרזנו עליו.
לאחר מכן, אנו משתמשים בלולאת 'for' בה אנו מוסיפים 'const byte& my_byte: ArrayOfBytes' כדי לעבור על מערך הבתים. לאחר מכן, אנחנו מוסיפים את הפונקציה 'cout' שמציגה כל אלמנט שעבר טרנספורמציה למערך הבתים.
קוד 4:
#include#include
#include
באמצעות מרחב שמות std ;
int רָאשִׁי ( )
{
string stringData = 'מערך בייטים' ;
cout << 'נתוני המחרוזת הם' << stringData << endl << endl ;
cout << 'המחרוזת הומרה ל-ByteArray כאן שהוא' << endl ;
byte ArrayOfBytes [ stringData. אורך ( ) ] ;
memcpy ( ArrayOfBytes , stringData. נתונים ( ) , stringData. אורך ( ) ) ;
ל ( const בייט & my_byte : ArrayOfBytes )
{
cout << to_integer < int > ( my_byte ) << ',' ;
}
לַחֲזוֹר 0 ;
}
תְפוּקָה:
תוצאה זו מעבדת את המחרוזת המקורית ואת המחרוזת שהופכת למערך בתים. אנו משתמשים בשיטת 'memcpy()' של הקוד שלנו כדי להפוך מחרוזת זו למערך הבתים.
סיכום
למדנו שמערכי בתים ב-C++ מציעים גישה ברמה נמוכה לעבודה יעילה עם נתונים בינאריים. בדקנו שהם מספקים לנו שליטה על הזיכרון ובסיס למשימות כמו סדרה, רשת ועיבוד נתונים ברמה נמוכה. במאמר זה חקרנו את הרעיון של הכרזה ואתחול של מערך הבתים ב-C++ וכן את ההמרה של המחרוזת למערך הבתים יחד עם הקודים שלהם.