Na kazalcih lahko izvajamo aritmetične operacije, kot so seštevanje, odštevanje itd. Ker pa vemo, da kazalec vsebuje naslov, bo rezultat aritmetične operacije, izvedene na kazalcu, prav tako kazalec, če je drugi operand tipa celo število. Pri odštevanju kazalec od kazalca bo rezultat celoštevilska vrednost. Na kazalcu v jeziku C so možne naslednje aritmetične operacije:

• Prirastek
• Zmanjšaj
• Dodatek
• Odštevanje
• Primerjava

Povečanje kazalca v C

Če kazalec povečamo za 1, bo kazalec začel kazati na takojšnjo naslednjo lokacijo. To se nekoliko razlikuje od splošne aritmetike, saj se bo vrednost kazalca povečala za velikost podatkovnega tipa, na katerega kaže kazalec.

Matriko lahko prečkamo z uporabo operacije povečanja na kazalcu, ki bo še naprej kazal na vsak element matrike, izvedel neko operacijo na tem in se posodobil v zanki.

Pravilo za povečanje kazalca je navedeno spodaj:

 new_address= current_address + i * size_of(data type) 

Kjer je i številka, za katero se poveča kazalec.

js globalna spremenljivka

32-bitni

Za 32-bitno spremenljivko int se bo povečala za 2 bajta.

64-bitni

Za 64-bitno spremenljivko int se bo povečala za 4 bajte.

Oglejmo si primer povečevanja spremenljivke kazalca na 64-bitni arhitekturi.

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

Izhod

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

Prehod po nizu z uporabo kazalca

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

Zmanjšanje kazalca v C

Tako kot pri povečanju lahko tudi spremenljivko kazalca zmanjšamo. Če kazalec zmanjšamo, bo začel kazati na prejšnjo lokacijo. Formula za zmanjšanje kazalca je podana spodaj:

 new_address= current_address - i * size_of(data type) 

32-bitni

Za 32-bitno spremenljivko int se bo zmanjšala za 2 bajta.

64-bitni

Za 64-bitno spremenljivko int se bo zmanjšala za 4 bajte.

povratni tip v Javi

Oglejmo si primer dekrementiranja spremenljivke kazalca v 64-bitnem OS.

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

Izhod

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

Dodajanje kazalca C

Spremenljivki kazalca lahko dodamo vrednost. Formula za dodajanje vrednosti kazalcu je podana spodaj:

bash preveri, ali je spremenljivka okolja nastavljena

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

32-bitni

Za 32-bitno spremenljivko int bo dodala številko 2 *.

64-bitni

Za 64-bitno spremenljivko int bo dodala številko 4 *.

Oglejmo si primer dodajanja vrednosti spremenljivki kazalca na 64-bitni arhitekturi.

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

Izhod

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

Kot lahko vidite, je naslov p 3214864300. Toda po dodajanju 3 s spremenljivko p je 3214864312, tj. prirast 4*3=12. Ker uporabljamo 64-bitno arhitekturo, se poveča za 12. Če pa uporabljamo 32-bitno arhitekturo, se poveča le na 6, tj. 2*3=6. Kot celoštevilska vrednost zaseda 2-bajtni pomnilnik v 32-bitnem OS.

C Odštevanje kazalca

Tako kot seštevanje kazalca lahko od spremenljivke kazalca odštejemo vrednost. Če od kazalca odštejemo poljubno število, dobimo naslov. Spodaj je podana formula za odštevanje vrednosti od spremenljivke kazalca:

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

32-bitni

Za 32-bitno spremenljivko int bo odštela 2 * število.

64-bitni

Za 64-bitno spremenljivko int bo odštela 4 * število.

Oglejmo si primer odštevanja vrednosti od spremenljivke kazalca na 64-bitni arhitekturi.

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

Izhod

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

Po odštevanju 3 od spremenljivke kazalca lahko vidite, da je 12 (4*3) manj od prejšnje vrednosti naslova.

Vendar pa lahko namesto števila odštejemo naslov od drugega naslova (kazalec). To bo povzročilo številko. To ne bo preprosta aritmetična operacija, ampak bo sledila naslednjemu pravilu.

Če sta dva kazalca iste vrste,

regularni izraz v Javi

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

Razmislite o naslednjem primeru, da odštejete en kazalec od drugega.

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

Izhod

 Pointer Subtraction: 1030585080 - 1030585068 = 3 

Nedovoljena aritmetika s kazalci

Obstajajo različne operacije, ki jih ni mogoče izvesti na kazalcih. Ker kazalec shranjuje naslov, moramo zanemariti operacije, ki lahko vodijo do nedovoljenega naslova, na primer seštevanje in množenje. Spodaj je naveden seznam takšnih operacij.

• Naslov + naslov = nezakonito
• Naslov * Naslov = nezakonito
• Naslov % Naslov = nezakonito
• Naslov / Naslov = nezakonito
• Naslov in naslov = nezakonito
• Naslov ^ Naslov = nezakonito
• Naslov | Naslov = ilegalen
• ~Naslov = nezakonito

Kazalec za delovanje v C

Kot smo razpravljali v prejšnjem poglavju, lahko kazalec kaže na funkcijo v C. Vendar pa mora biti deklaracija spremenljivke kazalca enaka funkciji. Razmislite o naslednjem primeru, da naredite kazalec, ki kaže na funkcijo.

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

Izhod

powershell manjše ali enako

 Enter two numbers?10 15 The sum is 25 

Kazalec na niz funkcij v C

Da bi razumeli koncept niza funkcij, moramo razumeti niz funkcij. V bistvu je matrika funkcije matrika, ki vsebuje naslove funkcij. Z drugimi besedami, kazalec na niz funkcij je kazalec, ki kaže na niz, ki vsebuje kazalce na funkcije. Razmislite o naslednjem primeru.

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

Izhod

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