מאמר זה עוסק באריתמטיקה מצביע ב-C++. מצביעים הם משתנים המאחסנים את כתובת הזיכרון של הנתונים. אריתמטיקה מצביע היא סימן היכר רב עוצמה בעולם של שפת התכנות C++ המאפשרת לנו להתמודד עם פעולות אריתמטיות שונות שבהן החיבור, הכפל, החלוקה, ההגדלה, הקטנה והחיסור כרוכים במצביע לפיתוח כתובת הזיכרון החדשה במאגרי הזיכרון שלנו. . אריתמטיקה מצביע יוצרת בקלות את הקצאת הזיכרון הדינמית. במאמר C++ זה, נלמד כיצד לתפעל את כתובת הזיכרון בדרכים שונות בעזרת מצביעים ולספק הנחיות ודוגמאות מתאימות.
תרחיש 1: המצביע מבצע את פעולות ההגדלה וההפחתה
כאן, נלמד על מניפולציה של מצביע כדי לייצר כתובות זיכרון שונות שיש להן מטרות שונות. מצביעי ההגדלה והירידה הם גם אריתמטיקה של מצביעי המינוף שמגדילים או מקטינים את הכתובת בפקטור אחד כפול גודל סוג הנתונים שאליו הם מצביעים. קטע הקוד הקשור לתרחיש זה מצורף בקטע הבא:
#include
שימוש במרחב שמות std;
const int Arr_Max = 5 ;
int main ( ) {
int היכן [ Arr_Max ] = { עשרים , 150 , 270 } ;
int * ptr; // לְהַכרִיז מַצבִּיעַ
ptr = var;
ל ( int i = 0 ; אני < Arr_Max; i++ ) {
std::cout << 'כתובת הזיכרון של האלמנט היא: [' << אני << '] = ' ;
std::cout << ptr << endl;
cout << 'הערך מול הכתובת הוא [' << אני << '] = ' ;
cout << * ptr << endl;
std::cout << 'המצביע הוגדל בהצלחה' << endl;
ptr++;
}
std::cout << 'כתובת מצביע לפני ירידה' << ptr << endl;
ptr--;
std::cout << 'כתובת מצביע לאחר ירידה' << ptr << endl;
לַחֲזוֹר 0 ;
}
כאן, אנו מגדירים ספרייה נדרשת בקוד ממש בהתחלה: '
אנחנו מעבירים את המערך למצביע כדי לגשת לכתובת. כפי שכולנו יודעים, מערכים תמיד מכילים פריטים מרובים במיקומים שונים. אז, היינו צריכים לולאה עם מצביע 'עזרה' כדי לגשת לכל אלמנט של מערך. בכל פעם שהלולאה מבוצעת, אנו מקבלים את כתובת הזיכרון והערכים מול הכתובת הזו בעזרת אופרטור ההגדלה 'ptr++' של המצביע האריתמטי שמעביר את כתובת הזיכרון לכתובת הבאה של הזיכרון. מחזור ביצוע הלולאה תלוי בגודל של מערך. מחוץ ללולאה, אנו רוצים להחזיר את המצביע לכתובת הזיכרון הקודמת על ידי שימוש במצביע ההפחתה 'ptr- -' .
הפעל את הקוד הזה על ידי לחיצה על האפשרות בצע> הידור והפעל ותקבל את הפלט הבא:
אני מקווה שהפלט הזה קל להבנה. כתובת הזיכרון והערך משתנים. הזזת המצביע ממיקום אחד אפשרי רק מאריתמטיקה של מצביע ההגדלה ב-C++.
תרחיש 2: חיסור של שני מצביעים ב-C++
בתרחיש זה, נלמד כיצד להחסיר שניים או יותר מצביעים ב-C++. כל הפעולות האריתמטיות שבהן מגיעה החיסור הן תהליכים חיוניים שכן אנו יכולים להחסיר שני מצביעים בו זמנית רק אם ורק אם יש להם אותו סוג נתונים.
הפעולות האחרות כמו חיבור, כפל וחילוק אינן אפשריות במצביע מכיוון שאין להן משמעות בכתובת זיכרון. קטע הקוד מצורף בקטע הבא:
#includeint main ( ) {
הוא קורץ [ ] = { 23 , 36 , 42 , 51 , 62 , 77 , 89 , 96 , 100 } ;
int * ptrr1 = & לזה [ 3 ] ; // מצביע על האלמנט השלישי ( 42 )
int * ptrr2 = & לזה [ 6 ] ; // מצביע על האלמנט השישי ( 89 )
ptrdiff_t ptrsubtract = ptrr2 - ptrr1;
std::cout << 'ההבדל בין הכתובות הללו הוא:' << ptrsubtract << ' אלמנטים' << std::endl;
לַחֲזוֹר 0 ;
}
פעולת החיסור היא מציאת ההבדל בין כתובת הזיכרון ב-C++. בפונקציה הראשית, אנחנו לוקחים מערך שמכיל ערכים שונים באינדקסים שונים. במערך, לכל אינדקס יש מיקום זיכרון שונה. אנו יכולים למצוא את ההבדל בין שני מצביעים רק בעזרת אריתמטיקה מצביע. כאן, אנו משתמשים בסוג מצביע מיוחד 'ptrdiff_t' שיש להשתמש בו כדי למצוא את ההבדלים בין שני מצביעים או יותר ב-C++.
הפלט של קוד זה מצורף בקטע הבא:
ההבדל בין הכתובות הללו הוא לפי אלמנט מלחיץ שהוא 3.
תרחיש 3: השווה שני מצביעים או יותר ב-C++
בתרחיש זה, נלמד כיצד להשוות בין המצביעים השונים ב-C++ באמצעות אופרטורים יחסיים שונים כמו '==', '<=', '>=', '<', '>'. נוכל להשוות את המצביעים רק אם הם מצביעים על הכתובת של אלמנטים מאותו מערך. זכור שהשוואת שני מצביעים עם סוגים שונים עלולה לגרום להתנהגות לא מוגדרת. קטע הקוד שקשור להשוואת המצביע מוזכר בהמשך:
#includeשימוש במרחב שמות std;
int main ( )
{
int arr1 [ 10 ] = { 4 , 7 , 9 , אחד עשר , 14 , 16 , 18 , עשרים , 22 , 25 } ;
int * ptr1 = & arr1 [ 3 ] ;
int * ptr2 = & arr1 [ 6 ] ;
int * ptr3 = & arr1 [ 8 ] ;
int * ptr4 = & arr1 [ 9 ] ;
אם ( ptr1 ==ptr2 )
{
std::cout << 'המצביעים שווים' << endl;
}
אַחֵר אם ( ptr3 < =ptr4 )
{
std::cout << 'ptr3 קטן או שווה מ-ptr4' << endl ;;
}
אַחֵר
{
std::cout << 'מצביעים לא מושווים בשום שלב' << endl;
}
לַחֲזוֹר 0 ;
}
כאן, אנחנו לוקחים מערך עם 10 אלמנטים. אנו מכריזים על ארבעה מצביעים המצביעים על אינדקס שונה של המערך. לאחר מכן, אנו משווים את ארבעת המצביעים הללו בתנאים שונים כפי שניתן לראות בקוד הנתון. במצב 'אם', בדוק אם מצביע 'ptr1' שווה למצביע 'ptr2', ולאחר מכן הדפס את 'המצביעים שווים'. כאשר יש לנו מספר תנאים שבהם אנו משתמשים בתנאי 'else if' כדי לבדוק אם מצביע 'ptr3' קטן משווה למצביע 'ptr4'. אחרי כל זה, לחץ על ביצוע > הידור והפעל אוֹפְּצִיָה.
הפלט של קוד זה מצורף בקטע הבא:
הוא מציג תנאי חוקי במסך המסוף ויוצא מהקומפילציה. המצביע 'ptr3' מכיל ערך הקטן או שווה לערך ההצבעה 'ptr4'.
תרחיש 4: הצג מספר אי זוגי עם אריתמטיקה מצביע
כאן, נראה כיצד נוכל להקצות באופן דינמי את הזיכרון עבור מערך של מספר שלם. קטע הקוד הקשור למקרה זה ניתן בקטע הבא:
#includeint main ( ) {
מספרים int [ ] = { 1 , 12 , 33 , 24 , חֲמֵשׁ עֶשׂרֵה , 776 , 71 , 18 , 29 , חמישים } ;
int * ptrr = מספרים;
std::cout << 'מספרים אי-זוגיים במערכים:' ;
ל ( int i = 0 ; אני < 10 ; ++i ) {
אם ( * ptrr % 2 ! = 0 ) {
std::cout << * ptrr << '' ;
}
ptrr++;
}
std::cout << std::endl;
לַחֲזוֹר 0 ;
}
בפונקציה הראשית, אנחנו לוקחים מערך שמכיל 10 אלמנטים. אנחנו צריכים מצביע שמצביע על כל האלמנטים במערך כדי לבדוק את המספר האי-זוגי במערך. בלולאת 'עבור', בדוק את המספר האי-זוגי על ידי חלוקת האלמנט הנוכחי של מערך. מונה המצביע מוגדל לאחר בדיקת אלמנט אחד של מערך.
לאחר ביצוע הקוד, הפלט מוצג במסך המסוף המופיע בהמשך:
בדרך זו, נוכל להציג את המספרים האי-זוגיים באמצעות אריתמטיקה של המצביע על מסך המסוף.
סיכום
אנו מסיקים כאן כי אריתמטיקה המצביע היא הכלי היעיל ביותר שמבצע פעולות שונות ב-C++. ודא שהמצביע מגדיל או מקטין את הערך של מערך בעל אותו סוג נתונים. אנו יכולים להשוות את הערכים של מערך לפי כתובות הזיכרון שלהם בעזרת אריתמטיקה מצביע בשפת התכנות C++. אנחנו יכולים לעבור את המערך ולנהל את הזיכרון בקלות בעזרת אריתמטיקה מצביע.