אנחנו יכולים לבצע פעולות אריתמטיות על המצביעים כמו חיבור, חיסור וכו'. עם זאת, מכיוון שאנו יודעים שהמצביע מכיל את הכתובת, התוצאה של פעולת אריתמטית המבוצעת על המצביע תהיה גם מצביע אם האופרנד השני הוא מסוג מספר שלם. בחיסור מצביע מהמצביע, התוצאה תהיה ערך שלם. פעולות אריתמטיות הבאות אפשריות במצביע בשפת C:

• תוֹסֶפֶת
• ירידה
• חיבור
• חִסוּר
• השוואה

מצביע עולה ב-C

אם נעלה מצביע ב-1, המצביע יתחיל להצביע על המיקום הבא. זה שונה במקצת מהחשבון הכללי מכיוון שהערך של המצביע יגדל בגודל של סוג הנתונים שאליו מצביע המצביע.

פיבונאצי רצף java

אנחנו יכולים לעבור מערך על ידי שימוש בפעולת ההגדלה על מצביע שימשיך להצביע על כל אלמנט במערך, יבצע פעולה כלשהי על זה ויעדכן את עצמו בלולאה.

הכלל להגדלת המצביע ניתן להלן:

 new_address= current_address + i * size_of(data type) 

כאשר i הוא המספר שבו גדל המצביע.

32 סיביות

עבור משתנה int של 32 סיביות, הוא יוגדל ב-2 בתים.

64 סיביות

עבור משתנה int של 64 סיביות, הוא יוגדל ב-4 בתים.

בואו נראה את הדוגמה של משתנה מצביע הגדל בארכיטקטורת 64 סיביות.

 #include int main(){ int number=50; int *p;//pointer to int p=&number;//stores the address of number variable printf('Address of p variable is %u 
',p); p=p+1; printf('After increment: Address of p variable is %u 
',p); // in our case, p will get incremented by 4 bytes. return 0; } 

תְפוּקָה

 Address of p variable is 3214864300 After increment: Address of p variable is 3214864304 

מעבר של מערך באמצעות מצביע

 #include void main () { int arr[5] = {1, 2, 3, 4, 5}; int *p = arr; int i; printf('printing array elements...
&apos;); for(i = 0; i<5; i++) { printf('%d ',*(p+i)); } < pre> <p> <strong>Output</strong> </p> <pre> printing array elements... 1 2 3 4 5 </pre> <h2>Decrementing Pointer in C</h2> <p>Like increment, we can decrement a pointer variable. If we decrement a pointer, it will start pointing to the previous location. The formula of decrementing the pointer is given below:</p> <pre> new_address= current_address - i * size_of(data type) </pre> <h3>32-bit</h3> <p>For 32-bit int variable, it will be decremented by 2 bytes.</p> <h3>64-bit</h3> <p>For 64-bit int variable, it will be decremented by 4 bytes.</p> <p>Let&apos;s see the example of decrementing pointer variable on 64-bit OS.</p> <pre> #include void main(){ int number=50; int *p;//pointer to int p=&amp;number;//stores the address of number variable printf(&apos;Address of p variable is %u 
&apos;,p); p=p-1; printf(&apos;After decrement: Address of p variable is %u 
&apos;,p); // P will now point to the immidiate previous location. } </pre> <p> <strong>Output</strong> </p> <pre> Address of p variable is 3214864300 After decrement: Address of p variable is 3214864296 </pre> <h2>C Pointer Addition</h2> <p>We can add a value to the pointer variable. The formula of adding value to pointer is given below:</p> <pre> new_address= current_address + (number * size_of(data type)) </pre> <h3>32-bit</h3> <p>For 32-bit int variable, it will add 2 * number.</p> <h3>64-bit</h3> <p>For 64-bit int variable, it will add 4 * number.</p> <p>Let&apos;s see the example of adding value to pointer variable on 64-bit architecture.</p> <pre> #include int main(){ int number=50; int *p;//pointer to int p=&amp;number;//stores the address of number variable printf(&apos;Address of p variable is %u 
&apos;,p); p=p+3; //adding 3 to pointer variable printf(&apos;After adding 3: Address of p variable is %u 
&apos;,p); return 0; } </pre> <p> <strong>Output</strong> </p> <pre> Address of p variable is 3214864300 After adding 3: Address of p variable is 3214864312 </pre> <p>As you can see, the address of p is 3214864300. But after adding 3 with p variable, it is 3214864312, i.e., 4*3=12 increment. Since we are using 64-bit architecture, it increments 12. But if we were using 32-bit architecture, it was incrementing to 6 only, i.e., 2*3=6. As integer value occupies 2-byte memory in 32-bit OS.</p> <h2>C Pointer Subtraction</h2> <p>Like pointer addition, we can subtract a value from the pointer variable. Subtracting any number from a pointer will give an address. The formula of subtracting value from the pointer variable is given below:</p> <pre> new_address= current_address - (number * size_of(data type)) </pre> <h3>32-bit</h3> <p>For 32-bit int variable, it will subtract 2 * number.</p> <h3>64-bit</h3> <p>For 64-bit int variable, it will subtract 4 * number.</p> <p>Let&apos;s see the example of subtracting value from the pointer variable on 64-bit architecture.</p> <pre> #include int main(){ int number=50; int *p;//pointer to int p=&amp;number;//stores the address of number variable printf(&apos;Address of p variable is %u 
&apos;,p); p=p-3; //subtracting 3 from pointer variable printf(&apos;After subtracting 3: Address of p variable is %u 
&apos;,p); return 0; } </pre> <p> <strong>Output</strong> </p> <pre> Address of p variable is 3214864300 After subtracting 3: Address of p variable is 3214864288 </pre> <p>You can see after subtracting 3 from the pointer variable, it is 12 (4*3) less than the previous address value.</p> <p>However, instead of subtracting a number, we can also subtract an address from another address (pointer). This will result in a number. It will not be a simple arithmetic operation, but it will follow the following rule.</p> <p>If two pointers are of the same type,</p> <pre> Address2 - Address1 = (Subtraction of two addresses)/size of data type which pointer points </pre> <p>Consider the following example to subtract one pointer from an another.</p> <pre> #include void main () { int i = 100; int *p = &amp;i; int *temp; temp = p; p = p + 3; printf(&apos;Pointer Subtraction: %d - %d = %d&apos;,p, temp, p-temp); } </pre> <p> <strong>Output</strong> </p> <pre> Pointer Subtraction: 1030585080 - 1030585068 = 3 </pre> <h2>Illegal arithmetic with pointers</h2> <p>There are various operations which can not be performed on pointers. Since, pointer stores address hence we must ignore the operations which may lead to an illegal address, for example, addition, and multiplication. A list of such operations is given below.</p> <ul> <li>Address + Address = illegal</li> <li>Address * Address = illegal </li> <li>Address % Address = illegal</li> <li>Address / Address = illegal</li> <li>Address &amp; Address = illegal</li> <li>Address ^ Address = illegal</li> <li>Address | Address = illegal</li> <li> ~Address = illegal</li> </ul> <h2>Pointer to function in C</h2> <p>As we discussed in the previous chapter, a pointer can point to a function in C. However, the declaration of the pointer variable must be the same as the function. Consider the following example to make a pointer pointing to the function. <pre> #include int addition (); int main () { int result; int (*ptr)(); ptr = &amp;addition; result = (*ptr)(); printf(&apos;The sum is %d&apos;,result); } int addition() { int a, b; printf(&apos;Enter two numbers?&apos;); scanf(&apos;%d %d&apos;,&amp;a,&amp;b); return a+b; } </pre> </p><p> <strong>Output</strong> </p> <pre> Enter two numbers?10 15 The sum is 25 </pre> <h2>Pointer to Array of functions in C</h2> <p>To understand the concept of an array of functions, we must understand the array of function. Basically, an array of the function is an array which contains the addresses of functions. In other words, the pointer to an array of functions is a pointer pointing to an array which contains the pointers to the functions. Consider the following example.</p> <pre> #include int show(); int showadd(int); int (*arr[3])(); int (*(*ptr)[3])(); int main () { int result1; arr[0] = show; arr[1] = showadd; ptr = &amp;arr; result1 = (**ptr)(); printf(&apos;printing the value returned by show : %d&apos;,result1); (*(*ptr+1))(result1); } int show() { int a = 65; return a++; } int showadd(int b) { printf(&apos;
Adding 90 to the value returned by show: %d&apos;,b+90); } </pre> <p> <strong>Output</strong> </p> <pre> printing the value returned by show : 65 Adding 90 to the value returned by show: 155 </pre> <hr></5;>

מצביע מופחת ב-C

כמו תוספת, אנו יכולים להקטין משתנה מצביע. אם נפחית מצביע, הוא יתחיל להצביע על המיקום הקודם. הנוסחה של הפחתת המצביע ניתנת להלן:

 new_address= current_address - i * size_of(data type) 

32 סיביות

עבור משתנה int של 32 סיביות, הוא יופחת ב-2 בתים.

64 סיביות

עבור משתנה int של 64 סיביות, הוא יופחת ב-4 בתים.

ממוין tuple python

בואו נראה את הדוגמה של הורדת משתנה מצביע במערכת הפעלה של 64 סיביות.

 #include void main(){ int number=50; int *p;//pointer to int p=&number;//stores the address of number variable printf('Address of p variable is %u 
',p); p=p-1; printf('After decrement: Address of p variable is %u 
',p); // P will now point to the immidiate previous location. } 

תְפוּקָה

 Address of p variable is 3214864300 After decrement: Address of p variable is 3214864296 

תוספת C Pointer

נוכל להוסיף ערך למשתנה המצביע. הנוסחה של הוספת ערך למצביע ניתנת להלן:

 new_address= current_address + (number * size_of(data type)) 

32 סיביות

עבור משתנה int של 32 סיביות, הוא יוסיף מספר 2 *.

64 סיביות

עבור משתנה int של 64 סיביות, הוא יוסיף מספר 4*.

בואו נראה את הדוגמה של הוספת ערך למשתנה מצביע בארכיטקטורת 64 סיביות.

 #include int main(){ int number=50; int *p;//pointer to int p=&number;//stores the address of number variable printf('Address of p variable is %u 
',p); p=p+3; //adding 3 to pointer variable printf('After adding 3: Address of p variable is %u 
',p); return 0; } 

תְפוּקָה

 Address of p variable is 3214864300 After adding 3: Address of p variable is 3214864312 

כפי שאתה יכול לראות, הכתובת של p היא 3214864300. אבל לאחר הוספת 3 עם משתנה p, היא 3214864312, כלומר, 4*3=12 תוספת. מכיוון שאנו משתמשים בארכיטקטורת 64 סיביות, זה מגדיל 12. אבל אם היינו משתמשים בארכיטקטורת 32 סיביות, זה היה עולה ל-6 בלבד, כלומר, 2*3=6. כערך מספר שלם תופס זיכרון של 2 בתים במערכת הפעלה של 32 סיביות.

הרכב יחסים

חיסור מצביע C

כמו הוספת מצביע, אנו יכולים להחסיר ערך ממשתנה המצביע. הפחתת מספר כלשהו מהמצביע ייתן כתובת. הנוסחה של הפחתת ערך ממשתנה המצביע ניתנת להלן:

 new_address= current_address - (number * size_of(data type)) 

32 סיביות

עבור משתנה int של 32 סיביות, הוא יחסוך מספר 2*.

64 סיביות

עבור משתנה int של 64 סיביות, הוא יחסוך מספר 4*.

בואו נראה את הדוגמה של הפחתת ערך ממשתנה המצביע בארכיטקטורת 64 סיביות.

 #include int main(){ int number=50; int *p;//pointer to int p=&number;//stores the address of number variable printf('Address of p variable is %u 
',p); p=p-3; //subtracting 3 from pointer variable printf('After subtracting 3: Address of p variable is %u 
',p); return 0; } 

תְפוּקָה

 Address of p variable is 3214864300 After subtracting 3: Address of p variable is 3214864288 

אתה יכול לראות לאחר הפחתת 3 מהמשתנה המצביע, הוא קטן ב-12 (4*3) מערך הכתובת הקודם.

עם זאת, במקום לגרוע מספר, נוכל להחסיר כתובת גם מכתובת אחרת (מצביע). זה יביא למספר. זו לא תהיה פעולה אריתמטית פשוטה, אבל היא תפעל לפי הכלל הבא.

אם שני מצביעים הם מאותו סוג,

 Address2 - Address1 = (Subtraction of two addresses)/size of data type which pointer points 

שקול את הדוגמה הבאה כדי להחסיר מצביע אחד מהאחר.

 #include void main () { int i = 100; int *p = &i; int *temp; temp = p; p = p + 3; printf('Pointer Subtraction: %d - %d = %d',p, temp, p-temp); } 

תְפוּקָה

 Pointer Subtraction: 1030585080 - 1030585068 = 3 

חשבון לא חוקי עם מצביעים

ישנן פעולות שונות שלא ניתן לבצע על מצביעים. מכיוון שמצביע מאחסן כתובת ולכן עלינו להתעלם מהפעולות שעלולות להוביל לכתובת לא חוקית, למשל, חיבור וכפל. רשימה של פעולות כאלה מובאת להלן.

גיל הסלמאן חאן חאן

• כתובת + כתובת = לא חוקי
• כתובת * כתובת = לא חוקי
• כתובת % כתובת = לא חוקי
• כתובת / כתובת = לא חוקי
• כתובת וכתובת = לא חוקי
• כתובת ^ כתובת = לא חוקי
• כתובת | כתובת = לא חוקי
• ~כתובת = לא חוקי

מצביע לתפקוד ב-C

כפי שדיברנו בפרק הקודם, מצביע יכול להצביע על פונקציה ב-C. עם זאת, ההכרזה על משתנה המצביע חייבת להיות זהה לפונקציה. שקול את הדוגמה הבאה כדי ליצור מצביע המצביע על הפונקציה.

 #include int addition (); int main () { int result; int (*ptr)(); ptr = &addition; result = (*ptr)(); printf('The sum is %d',result); } int addition() { int a, b; printf('Enter two numbers?'); scanf('%d %d',&a,&b); return a+b; } 

תְפוּקָה

 Enter two numbers?10 15 The sum is 25 

מצביע למערך של פונקציות ב-C

כדי להבין את הרעיון של מערך פונקציות, עלינו להבין את מערך הפונקציות. בעיקרון, מערך של הפונקציה הוא מערך המכיל את הכתובות של הפונקציות. במילים אחרות, המצביע למערך של פונקציות הוא מצביע המצביע על מערך המכיל את המצביעים לפונקציות. שקול את הדוגמה הבאה.

 #include int show(); int showadd(int); int (*arr[3])(); int (*(*ptr)[3])(); int main () { int result1; arr[0] = show; arr[1] = showadd; ptr = &arr; result1 = (**ptr)(); printf('printing the value returned by show : %d',result1); (*(*ptr+1))(result1); } int show() { int a = 65; return a++; } int showadd(int b) { printf('
Adding 90 to the value returned by show: %d',b+90); } 

תְפוּקָה

 printing the value returned by show : 65 Adding 90 to the value returned by show: 155