Mēs varam veikt aritmētiskas darbības ar rādītājiem, piemēram, saskaitīšanu, atņemšanu utt. Tomēr, tā kā mēs zinām, ka rādītājs satur adresi, aritmētiskās darbības rezultāts, kas tiek veikts ar rādītāju, būs arī rādītājs, ja otrs operanda tips ir vesels skaitlis. Atņemot rādītāju no rādītāja, rezultāts būs vesela skaitļa vērtība. C valodā ar rādītāju ir iespējamas šādas aritmētiskās darbības:

• Pieaugums
• Samazinājums
• Papildinājums
• Atņemšana
• Salīdzinājums

Rādītāja palielināšana C

Ja mēs palielinām rādītāju par 1, rādītājs sāks norādīt uz tuvāko nākamo atrašanās vietu. Tas nedaudz atšķiras no vispārējās aritmētikas, jo rādītāja vērtība tiks palielināta par datu tipa lielumu, uz kuru rādītājs norāda.

Mēs varam šķērsot masīvu, izmantojot rādītāja palielināšanas darbību, kas turpinās norādīt uz katru masīva elementu, veikt ar to dažas darbības un atjaunināt sevi cilpas veidā.

atlasiet vairāku tabulu sql

Noteikums rādītāja palielināšanai ir norādīts zemāk:

 new_address= current_address + i * size_of(data type) 

Kur i ir skaitlis, par kuru rādītājs tiek palielināts.

32 bitu

32 bitu int mainīgajam tas tiks palielināts par 2 baitiem.

64 bitu

64 bitu int mainīgajam tas tiks palielināts par 4 baitiem.

Apskatīsim piemēru par rādītāja mainīgā palielināšanu 64 bitu arhitektūrā.

 #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; } 

Izvade

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

Masīva šķērsošana, izmantojot rādītāju

 #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;>

Rādītāja samazināšana C

Tāpat kā pieaugumu, mēs varam samazināt rādītāja mainīgo. Ja mēs samazinām rādītāju, tas sāks norādīt uz iepriekšējo atrašanās vietu. Rādītāja samazināšanas formula ir dota zemāk:

 new_address= current_address - i * size_of(data type) 

32 bitu

32 bitu int mainīgajam tas tiks samazināts par 2 baitiem.

64 bitu

64 bitu int mainīgajam tas tiks samazināts par 4 baitiem.

Apskatīsim piemēru par rādītāja mainīgā samazināšanu 64 bitu operētājsistēmā.

sakārtots tuple python

 #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. } 

Izvade

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

C rādītāja pievienošana

Mēs varam pievienot vērtību rādītāja mainīgajam. Formula vērtības pievienošanai rādītājam ir dota zemāk:

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

32 bitu

32 bitu int mainīgajam tas pievienos 2 * skaitli.

peldēt pie auklas

64 bitu

64 bitu int mainīgajam tas pievienos 4 * skaitli.

Apskatīsim piemēru, kā pievienot vērtību rādītāja mainīgajam 64 bitu arhitektūrā.

 #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; } 

Izvade

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

Kā redzat, p adrese ir 3214864300. Bet pēc 3 pievienošanas ar mainīgo p tas ir 3214864312, t.i., 4*3=12 pieaugums. Tā kā mēs izmantojam 64 bitu arhitektūru, tas palielinās par 12. Bet, ja mēs izmantojām 32 bitu arhitektūru, tas pieauga tikai līdz 6, t.i., 2*3=6. Tā kā vesela skaitļa vērtība aizņem 2 baitu atmiņu 32 bitu operētājsistēmā.

C Rādītāja atņemšana

Tāpat kā rādītāja pievienošana, mēs varam atņemt vērtību no rādītāja mainīgā. Atņemot jebkuru skaitli no rādītāja, tiks iegūta adrese. Formula vērtības atņemšanai no rādītāja mainīgā ir dota zemāk:

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

32 bitu

32 bitu int mainīgajam tas atņems 2 * skaitli.

gada mēnesis

64 bitu

64 bitu int mainīgajam tas atņems 4 * skaitli.

Apskatīsim piemēru vērtības atņemšanai no rādītāja mainīgā 64 bitu arhitektūrā.

 #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; } 

Izvade

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

Pēc 3 atņemšanas no rādītāja mainīgā var redzēt, ka tas ir par 12 (4*3) mazāks nekā iepriekšējā adreses vērtība.

Tomēr tā vietā, lai atņemtu skaitli, mēs varam arī atņemt adresi no citas adreses (rādītāja). Tā rezultātā tiks iegūts skaitlis. Tā nebūs vienkārša aritmētiska darbība, bet tā ievēros šādu noteikumu.

Ja divi rādītāji ir viena veida,

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

Apsveriet šo piemēru, lai atņemtu vienu rādītāju no cita.

 #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); } 

Izvade

 Pointer Subtraction: 1030585080 - 1030585068 = 3 

Nelikumīga aritmētika ar rādītājiem

Ir dažādas darbības, kuras nevar veikt ar rādītājiem. Tā kā rādītājs saglabā adresi, mums ir jāignorē darbības, kas var novest pie nelegālas adreses, piemēram, saskaitīšana un reizināšana. Šādu darbību saraksts ir sniegts zemāk.

• Adrese + Adrese = nelikumīga
• Adrese * Adrese = nelikumīga
• Adrese % Adrese = nelikumīga
• Adrese / Adrese = nelikumīga
• Adrese un adrese = nelikumīga
• Adrese ^ Adrese = nelikumīga
• Adrese | Adrese = nelegāla
• ~ Adrese = nelikumīga

Rādītājs, lai darbotos C

Kā mēs runājām iepriekšējā nodaļā, rādītājs var norādīt uz funkciju C. Tomēr rādītāja mainīgā deklarācijai ir jābūt tādai pašai kā funkcijai. Apsveriet šo piemēru, lai rādītājs norādītu uz funkciju.

 #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; } 

Izvade

Charat virknē

 Enter two numbers?10 15 The sum is 25 

Rādītājs uz funkciju masīvu C

Lai saprastu funkciju masīva jēdzienu, mums ir jāsaprot funkciju masīvs. Būtībā funkcijas masīvs ir masīvs, kas satur funkciju adreses. Citiem vārdiem sakot, rādītājs uz funkciju masīvu ir rādītājs, kas norāda uz masīvu, kurā ir norādes uz funkcijām. Apsveriet šādu piemēru.

 #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); } 

Izvade

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