A mutatókon aritmetikai műveleteket hajthatunk végre, pl. összeadás, kivonás stb. Mivel azonban tudjuk, hogy a mutató tartalmazza a címet, a mutatón végrehajtott aritmetikai művelet eredménye is mutató lesz, ha a másik operandus egész típusú. A mutatótól a mutatótól való kivonás során az eredmény egy egész szám lesz. A következő aritmetikai műveletek lehetségesek a mutatón C nyelven:

• Növekedés
• Csökkenés
• Kiegészítés
• Kivonás
• Összehasonlítás

Növekvő mutató C-ben

Ha egy mutatót 1-gyel növelünk, a mutató a közvetlenül következő helyre kezd mutatni. Ez némileg eltér az általános aritmetikától, mivel a mutató értéke annak az adattípusnak a méretével nő, amelyre a mutató mutat.

kapja meg a tömb hosszát c-ben

Bejárhatunk egy tömböt úgy, hogy egy mutatón a növelési műveletet használjuk, amely folyamatosan a tömb minden elemére mutat, végrehajtunk rajta valamilyen műveletet, és ciklusban frissítjük magát.

A mutató növelésének szabálya az alábbiakban található:

 new_address= current_address + i * size_of(data type) 

Ahol i az a szám, amellyel a mutató megnő.

32 bites

A 32 bites int változó esetén ez 2 bájttal növekszik.

64 bites

64 bites int változó esetén 4 bájttal növekszik.

Lássuk a 64 bites architektúra mutatóváltozójának növelésének példáját.

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

Kimenet

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

Tömb bejárása mutató használatával

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

Csökkenő mutató C-ben

A növekményhez hasonlóan a mutatóváltozót is csökkenthetjük. Ha csökkentjük a mutatót, akkor az az előző helyre kezd mutatni. A mutató csökkentésének képlete a következő:

 new_address= current_address - i * size_of(data type) 

32 bites

32 bites int változó esetén 2 bájttal csökken.

64 bites

64 bites int változó esetén 4 bájttal csökken.

Lássuk a mutatóváltozó csökkentésének példáját 64 bites operációs rendszeren.

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

Kimenet

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

C Mutató hozzáadása

A mutatóváltozóhoz értéket adhatunk. A mutató értékének hozzáadásának képlete az alábbi:

konvertálja a karakterláncot int-vé

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

32 bites

A 32 bites int változóhoz 2 * számot ad hozzá.

64 bites

A 64 bites int változóhoz 4 * számot ad hozzá.

Nézzük meg a 64 bites architektúra mutatóváltozójának érték hozzáadásának példáját.

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

Kimenet

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

Amint látja, p címe 3214864300. De miután hozzáadtuk a 3-at p változóval, ez 3214864312, azaz 4*3=12 növekmény. Mivel 64 bites architektúrát használunk, 12-vel nő. De ha 32 bites architektúrát használunk, akkor csak 6-ra nőtt, azaz 2*3=6. Az egész érték 2 bájtos memóriát foglal el 32 bites operációs rendszerben.

C Mutató kivonás

A mutatóösszeadáshoz hasonlóan a mutatóváltozóból kivonhatunk egy értéket. Bármely szám kivonása egy mutatóból címet kap. A mutatóváltozóból való érték kivonásának képlete az alábbiakban látható:

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

32 bites

32 bites int változó esetén 2 * számot von le.

64 bites

64 bites int változó esetén 4 * számot von le.

Nézzük meg a példát az érték kivonására a mutatóváltozóból 64 bites architektúrán.

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

Kimenet

python nyomtatás 2 tizedesjegyig

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

Látható, hogy a mutatóváltozóból kivonva a 3-at, ez 12-vel (4*3) kisebb, mint az előző címérték.

Egy szám kivonása helyett azonban kivonhatunk egy címet egy másik címből (mutatóból is). Ez egy számot eredményez. Ez nem egy egyszerű aritmetikai művelet, hanem a következő szabályt követi.

Ha két mutató azonos típusú,

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

Tekintsük a következő példát, hogy kivonjunk egy mutatót a másikból.

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

Kimenet

 Pointer Subtraction: 1030585080 - 1030585068 = 3 

Illegális aritmetika mutatókkal

Vannak különféle műveletek, amelyeket nem lehet végrehajtani a mutatókon. Mivel a mutató a címet tárolja, figyelmen kívül kell hagynunk azokat a műveleteket, amelyek illegális címhez vezethetnek, például összeadás és szorzás. Az alábbiakban felsoroljuk az ilyen műveleteket.

• Cím + Cím = illegális
• Cím * Cím = illegális
• Cím % Cím = illegális
• Cím / Cím = illegális
• Cím és cím = illegális
• Cím ^ Cím = illegális
• Cím | Cím = illegális
• ~Cím = illegális

Mutató a C-ben való működéshez

Amint azt az előző fejezetben tárgyaltuk, a mutató mutathat egy függvényt C-ben. A mutatóváltozó deklarációjának azonban meg kell egyeznie a függvényével. Tekintsük a következő példát a függvényre mutató mutató létrehozásához.

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

Kimenet

 Enter two numbers?10 15 The sum is 25 

Mutató a C-beli függvények tömbjére

Ahhoz, hogy megértsük a függvénytömb fogalmát, meg kell értenünk a függvénytömböt. Alapvetően a függvény tömbje olyan tömb, amely a függvények címeit tartalmazza. Más szavakkal, a függvénytömbre mutató mutató egy olyan tömbre mutat, amely tartalmazza a függvényekre mutató mutatókat. Tekintsük a következő példát.

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

Kimenet

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