TechCodeview

Можемо да изводимо аритметичке операције над показивачима као што су сабирање, одузимање итд. Међутим, пошто знамо да показивач садржи адресу, резултат аритметичке операције извршене на показивачу ће такође бити показивач ако је други операнд типа цео број. У одузимању показивача од показивача, резултат ће бити целобројна вредност. Следеће аритметичке операције су могуће на показивачу у језику Ц:

• Повећање
• Декремент
• Додатак
• Одузимање
• Поређење

Повећавајући показивач у Ц

Ако повећамо показивач за 1, показивач ће почети да показује на следећу локацију. Ово се донекле разликује од опште аритметике јер ће се вредност показивача повећати за величину типа података на који показивач показује.

Можемо да пређемо низ користећи операцију повећања на показивачу који ће наставити да показује на сваки елемент низа, изврши неку операцију на томе и ажурира се у петљи.

Правило за повећање показивача је дато у наставку:

 new_address= current_address + i * size_of(data type) 

Где је и број за који се показивач повећава.

32-битни

За 32-битну инт променљиву, она ће бити увећана за 2 бајта.

64-битни

За 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;>

Смањење показивача у Ц

Као инкремент, можемо смањити променљиву показивача. Ако смањимо показивач, он ће почети да показује на претходну локацију. Формула за смањење показивача је дата у наставку:

 new_address= current_address - i * size_of(data type) 

32-битни

За 32-битну инт променљиву, она ће бити умањена за 2 бајта.

шта је линукс систем датотека

64-битни

За 64-битну инт променљиву, биће умањена за 4 бајта.

Погледајмо пример смањења променљиве показивача на 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 

Ц Поинтер Аддитион

Можемо додати вредност променљивој показивача. Формула додавања вредности показивачу је дата у наставку:

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

32-битни

За 32-битну инт променљиву, она ће додати 2 * број.

64-битни

За 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 

Као што видите, адреса п је 3214864300. Али након додавања 3 са п променљивом, то је 3214864312, тј. 4*3=12 инкремента. Пошто користимо 64-битну архитектуру, повећава се за 12. Али ако смо користили 32-битну архитектуру, повећавала се само на 6, тј. 2*3=6. Као целобројна вредност заузима 2-бајтну меморију у 32-битном ОС.

Ц Одузимање показивача

Као сабирање показивача, можемо одузети вредност од променљиве показивача. Одузимање било ког броја од показивача ће дати адресу. Формула за одузимање вредности од променљиве показивача је дата у наставку:

кампп алтернатива

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

32-битни

За 32-битну инт променљиву, одузеће 2 * број.

64-битни

За 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 

Недозвољена аритметика са показивачима

Постоје разне операције које се не могу извршити на показивачима. Пошто показивач чува адресу, морамо занемарити операције које могу довести до недозвољене адресе, на пример, сабирање и множење. Списак таквих операција је дат у наставку.

• Адреса + Адреса = незаконито
• Адреса * Адреса = илегално
• Адреса % Адреса = незаконито
• Адреса / Адреса = илегално
• Адреса и адреса = илегално
• Адреса ^ Адреса = нелегално
• Адреса | Адреса = илегално
• ~Адреса = илегално

Показивач на функцију у Ц

Као што смо расправљали у претходном поглављу, показивач може указивати на функцију у Ц. Међутим, декларација променљиве показивача мора бити иста као и функција. Размотрите следећи пример да бисте направили показивач који показује на функцију.

 #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 

Показивач на низ функција у Ц

Да бисмо разумели концепт низа функција, морамо разумети низ функција. У основи, низ функције је низ који садржи адресе функција. Другим речима, показивач на низ функција је показивач који показује на низ који садржи показиваче на функције. Размотрите следећи пример.

 #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