S ukazovateľmi môžeme vykonávať aritmetické operácie ako sčítanie, odčítanie atď. Keďže však vieme, že ukazovateľ obsahuje adresu, výsledkom aritmetickej operácie vykonanej na ukazovateli bude ukazovateľ, ak je druhý operand typu celé číslo. Pri odčítaní ukazovateľa od ukazovateľa bude výsledkom celočíselná hodnota. Na ukazovateli v jazyku C sú možné nasledujúce aritmetické operácie:

matice v programovaní v c

• Prírastok
• Dekrementovať
• Doplnenie
• Odčítanie
• Porovnanie

Zvyšujúci sa ukazovateľ v C

Ak zvýšime ukazovateľ o 1, ukazovateľ začne ukazovať na najbližšie nasledujúce miesto. Toto sa trochu líši od všeobecnej aritmetiky, pretože hodnota ukazovateľa sa zvýši o veľkosť typu údajov, na ktorý ukazovateľ ukazuje.

Pole môžeme prechádzať pomocou operácie prírastku na ukazovateli, ktorý bude stále ukazovať na každý prvok poľa, vykoná na ňom nejakú operáciu a aktualizuje sa v slučke.

Pravidlo na zvýšenie ukazovateľa je uvedené nižšie:

 new_address= current_address + i * size_of(data type) 

Kde i je číslo, o ktoré sa ukazovateľ zväčší.

32-bitový

V prípade 32-bitovej premennej int sa zvýši o 2 bajty.

64-bitový

V prípade 64-bitovej premennej int sa zvýši o 4 bajty.

Pozrime sa na príklad inkrementácie premennej ukazovateľa na 64-bitovej architektúre.

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

Výkon

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

Prechádzanie poľa pomocou ukazovateľa

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

Dekrementačný ukazovateľ v C

Rovnako ako inkrement, môžeme dekrementovať premennú ukazovateľa. Ak ukazovateľ znížime, začne ukazovať na predchádzajúce miesto. Vzorec na zníženie ukazovateľa je uvedený nižšie:

 new_address= current_address - i * size_of(data type) 

32-bitový

Pre 32-bitovú premennú int sa zníži o 2 bajty.

64-bitový

Pre 64-bitovú premennú int sa zníži o 4 bajty.

Pozrime sa na príklad znižovania premennej ukazovateľa na 64-bitovom 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. } 

Výkon

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

Pridanie ukazovateľa C

Do premennej pointer môžeme pridať hodnotu. Vzorec pridania hodnoty k ukazovateľu je uvedený nižšie:

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

32-bitový

Pre 32-bitovú premennú int pridá 2 * číslo.

64-bitový

Pre 64-bitovú premennú int pridá 4 * číslo.

Pozrime sa na príklad pridania hodnoty do premennej ukazovateľa na 64-bitovej architektúre.

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

Výkon

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

Ako vidíte, adresa p je 3214864300. Ale po pridaní 3 s premennou p je to 3214864312, t.j. prírastok 4*3=12. Keďže používame 64-bitovú architektúru, zvýši sa o 12. Ale ak použijeme 32-bitovú architektúru, zvýši sa iba na 6, t.j. 2*3=6. Ako celočíselná hodnota zaberá 2-bajtovú pamäť v 32-bitovom OS.

C Ukazovateľ Odčítanie

Rovnako ako sčítanie ukazovateľa môžeme odpočítať hodnotu od premennej ukazovateľa. Odčítaním ľubovoľného čísla od ukazovateľa získate adresu. Vzorec na odčítanie hodnoty od premennej ukazovateľa je uvedený nižšie:

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

32-bitový

Pre 32-bitovú premennú int sa odčíta 2 * číslo.

64-bitový

V prípade 64-bitovej premennej int sa odčíta 4 * číslo.

Pozrime sa na príklad odčítania hodnoty z premennej ukazovateľa na 64-bitovej architektúre.

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

Výkon

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

Po odčítaní 3 od premennej ukazovateľa vidíte, že je o 12 (4*3) menej ako predchádzajúca hodnota adresy.

Namiesto odčítania čísla však môžeme odčítať adresu aj od inej adresy (ukazovateľa). Výsledkom bude číslo. Nebude to jednoduchá aritmetická operácia, ale bude sa riadiť nasledujúcim pravidlom.

Ak sú dva ukazovatele rovnakého typu,

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

Zvážte nasledujúci príklad na odčítanie jedného ukazovateľa od druhého.

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

Výkon

 Pointer Subtraction: 1030585080 - 1030585068 = 3 

Nelegálna aritmetika s ukazovateľmi

Existujú rôzne operácie, ktoré nemožno vykonať s ukazovateľmi. Keďže ukazovateľ ukladá adresu, musíme ignorovať operácie, ktoré môžu viesť k nelegálnej adrese, napríklad sčítanie a násobenie. Zoznam takýchto operácií je uvedený nižšie.

• Adresa + Adresa = nezákonné
• Adresa * Adresa = nelegálne
• Adresa % Adresa = nelegálne
• Adresa / Adresa = nezákonné
• Adresa a adresa = nezákonné
• Adresa ^ Adresa = nezákonné
• Adresa | Adresa = nelegálne
• ~Adresa = nelegálne

Ukazovateľ na fungovanie v C

Ako sme hovorili v predchádzajúcej kapitole, ukazovateľ môže ukazovať na funkciu v jazyku C. Deklarácia premennej ukazovateľa však musí byť rovnaká ako funkcia. Zvážte nasledujúci príklad, aby ste vytvorili ukazovateľ ukazujúci na funkciu.

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

Výkon

 Enter two numbers?10 15 The sum is 25 

Ukazovateľ na pole funkcií v C

Aby sme pochopili pojem poľa funkcií, musíme pochopiť pole funkcií. Pole funkcie je v podstate pole, ktoré obsahuje adresy funkcií. Inými slovami, ukazovateľ na pole funkcií je ukazovateľ ukazujúci na pole, ktoré obsahuje ukazovatele na funkcie. Zvážte nasledujúci príklad.

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

Výkon

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