TechCodeview

S ukazateli můžeme provádět aritmetické operace jako sčítání, odčítání atd. Protože však víme, že ukazatel obsahuje adresu, výsledkem aritmetické operace provedené s ukazatelem bude ukazatel, pokud je druhý operand typu celé číslo. Při odečítání ukazatele od ukazatele bude výsledkem celočíselná hodnota. V jazyce C jsou na ukazateli možné následující aritmetické operace:

• Přírůstek
• Dekrementovat
• Přidání
• Odčítání
• Srovnání

Zvyšující se ukazatel v C

Pokud zvýšíme ukazatel o 1, ukazatel začne ukazovat na nejbližší další místo. To se poněkud liší od obecné aritmetiky, protože hodnota ukazatele se zvýší o velikost datového typu, na který ukazatel ukazuje.

Pole můžeme procházet pomocí operace inkrementace na ukazateli, který bude neustále ukazovat na každý prvek pole, provést na něm nějakou operaci a aktualizovat se ve smyčce.

ubuntu který příkaz

Pravidlo pro zvýšení ukazatele je uvedeno níže:

 new_address= current_address + i * size_of(data type) 

Kde i je číslo, o které se ukazatel zvýšil.

32bitový

U 32bitové proměnné int se zvýší o 2 bajty.

64bitový

U 64bitové proměnné int se zvýší o 4 bajty.

Podívejme se na příklad inkrementace proměnné ukazatele na 64bitové architektuře.

 #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ýstup

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

Procházení pole pomocí ukazatele

 #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í ukazatel v C

Stejně jako inkrementaci můžeme dekrementovat proměnnou ukazatele. Pokud ukazatel snížíme, začne ukazovat na předchozí místo. Vzorec pro dekrementaci ukazatele je uveden níže:

 new_address= current_address - i * size_of(data type) 

32bitový

U 32bitové proměnné int bude snížena o 2 bajty.

64bitový

U 64bitové proměnné int bude snížena o 4 bajty.

Podívejme se na příklad dekrementování proměnné ukazatele na 64bitovém 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ýstup

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

Přidání ukazatele C

K proměnné ukazatel můžeme přidat hodnotu. Vzorec pro přidání hodnoty k ukazateli je uveden níže:

pandy lok

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

32bitový

Pro 32bitovou proměnnou int přidá 2 * číslo.

64bitový

Pro 64bitovou proměnnou int přidá 4 * číslo.

Podívejme se na příklad přidání hodnoty do proměnné ukazatele na 64bitové architektuře.

 #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ýstup

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

Jak můžete vidět, adresa p je 3214864300. Ale po přidání 3 s proměnnou p je to 3214864312, tj. 4*3=12 přírůstek. Protože používáme 64bitovou architekturu, zvýší se 12. Ale pokud bychom použili 32bitovou architekturu, zvýšilo se pouze na 6, tj. 2*3=6. Jako celočíselná hodnota zabírá 2bajtovou paměť v 32bitovém OS.

C Ukazatel Odečítání

Stejně jako sčítání ukazatele můžeme odečíst hodnotu od proměnné ukazatele. Odečtením libovolného čísla od ukazatele získáte adresu. Vzorec pro odečítání hodnoty od proměnné ukazatele je uveden níže:

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

32bitový

U 32bitové proměnné int se odečte 2 * číslo.

64bitový

Pro 64bitovou proměnnou int odečte 4 * číslo.

nejlepší úsměv na světě

Podívejme se na příklad odečítání hodnoty z proměnné ukazatele na 64bitové architektuře.

 #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ýstup

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

Po odečtení 3 od proměnné ukazatele vidíte, že je o 12 (4*3) menší než předchozí hodnota adresy.

nahradit řetězec v řetězci java

Místo odečítání čísla však můžeme odečíst i adresu od jiné adresy (ukazatele). Výsledkem bude číslo. Nepůjde o jednoduchou aritmetickou operaci, ale bude se řídit následujícím pravidlem.

Pokud jsou dva ukazatele stejného typu,

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

Zvažte následující příklad, abyste odečetli jeden ukazatel 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ýstup

 Pointer Subtraction: 1030585080 - 1030585068 = 3 

Nelegální aritmetika s ukazateli

Existují různé operace, které nelze provádět s ukazateli. Protože ukazatel ukládá adresu, musíme ignorovat operace, které mohou vést k nelegální adrese, například sčítání a násobení. Seznam takových operací je uveden níže.

• Adresa + Adresa = nelegální
• Adresa * Adresa = nelegální
• Adresa % Adresa = nelegální
• Adresa / Adresa = nelegální
• Adresa a adresa = nelegální
• Adresa ^ Adresa = nelegální
• Adresa | Adresa = nelegální
• ~Adresa = nelegální

Ukazatel fungovat v C

Jak jsme probrali v předchozí kapitole, ukazatel může ukazovat na funkci v C. Deklarace proměnné ukazatele však musí být stejná jako funkce. Zvažte následující příklad, abyste vytvořili ukazatel ukazující na funkci.

 #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ýstup

 Enter two numbers?10 15 The sum is 25 

Ukazatel na pole funkcí v C

Abychom pochopili pojem pole funkcí, musíme porozumět poli funkcí. Pole funkce je v podstatě pole, které obsahuje adresy funkcí. Jinými slovy, ukazatel na pole funkcí je ukazatel ukazující na pole, které obsahuje ukazatele na funkce. Zvažte následující pří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ýstup

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