TechCodeview

Su rodyklėmis galime atlikti aritmetines operacijas, pvz., sudėtį, atimtį ir tt Tačiau, kadangi žinome, kad žymeklyje yra adresas, aritmetinės operacijos su žymekliu rezultatas taip pat bus rodyklė, jei kitas operandas yra sveikojo tipo. Atimant žymeklį nuo žymeklio, rezultatas bus sveikasis skaičius. C kalba žymekliu galimos šios aritmetinės operacijos:

• Prieaugis
• Sumažėjimas
• Papildymas
• Atimtis
• Palyginimas

Rodyklės didinimas C

Jei padidinsime žymeklį 1, rodyklė pradės rodyti artimiausią kitą vietą. Tai šiek tiek skiriasi nuo bendrosios aritmetikos, nes rodyklės reikšmė padidės duomenų tipo, į kurį nukreipia žymeklis, dydžiu.

Mes galime pereiti per masyvą naudodami žymeklio didinimo operaciją, kuri nuolat nukreips į kiekvieną masyvo elementą, atliks tam tikrą operaciją ir atnaujins save cikle.

Rodyklės didinimo taisyklė pateikta žemiau:

 new_address= current_address + i * size_of(data type) 

Kur i yra skaičius, kuriuo žymeklis padidinamas.

32 bitų

32 bitų int kintamajam jis bus padidintas 2 baitais.

64 bitų

64 bitų int kintamajam jis bus padidintas 4 baitais.

Pažiūrėkime 64 bitų architektūros rodyklės kintamojo didinimo pavyzdį.

Java indeksas

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

Išvestis

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

Perėjimas per masyvą naudojant žymeklį

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

Mažėjanti rodyklė C

Kaip ir prieaugis, mes galime sumažinti rodyklės kintamąjį. Jei sumažinsime žymeklį, jis pradės rodyti į ankstesnę vietą. Rodyklės mažinimo formulė pateikta žemiau:

 new_address= current_address - i * size_of(data type) 

32 bitų

32 bitų int kintamajam jis bus sumažintas 2 baitais.

64 bitų

64 bitų int kintamasis bus sumažintas 4 baitais.

Pažiūrėkime, kaip sumažinti žymeklio kintamąjį 64 bitų 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. } 

Išvestis

sąrašo eilutė java

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

C žymeklio papildymas

Prie žymeklio kintamojo galime pridėti reikšmę. Žemiau pateikta vertės pridėjimo prie rodyklės formulė:

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

32 bitų

32 bitų int kintamajam pridės 2 * skaičių.

64 bitų

64 bitų int kintamajam bus pridėtas 4 * skaičius.

Pažiūrėkime, kaip pridėti vertės žymeklio kintamajam 64 bitų architektūroje.

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

Išvestis

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

Kaip matote, p adresas yra 3214864300. Bet pridėjus 3 su kintamuoju p, tai yra 3214864312, ty 4*3=12 prieaugis. Kadangi naudojame 64 bitų architektūrą, ji padidinama 12. Bet jei naudojome 32 bitų architektūrą, ji didėjo tik iki 6, ty 2*3=6. Kaip sveikasis skaičius užima 2 baitų atmintį 32 bitų OS.

C Rodyklės atėmimas

Kaip ir žymeklio pridėjimas, mes galime atimti reikšmę iš žymeklio kintamojo. Atėmus bet kurį skaičių iš žymeklio, gausite adresą. Žemiau pateikta vertės atėmimo iš rodyklės kintamojo formulė:

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

32 bitų

32 bitų int kintamasis atims 2 * skaičių.

iteratorius java žemėlapis

64 bitų

64 bitų int kintamasis atims 4 * skaičių.

Pažiūrėkime vertės atėmimo iš žymeklio kintamojo 64 bitų architektūroje pavyzdį.

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

Išvestis

kaip sujungti eilutes Java

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

Iš rodyklės kintamojo atėmus 3 matote, kad tai yra 12 (4*3) mažiau nei ankstesnė adreso reikšmė.

Tačiau užuot atėmę skaičių, galime atimti adresą ir iš kito adreso (rodiklio). Taip bus gautas skaičius. Tai nebus paprastas aritmetinis veiksmas, bet bus laikomasi šios taisyklės.

Jei dvi tos pačios rūšies rodyklės,

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

Apsvarstykite šį pavyzdį, kaip atimti vieną žymeklį iš kito.

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

Išvestis

 Pointer Subtraction: 1030585080 - 1030585068 = 3 

Neteisėta aritmetika su rodyklėmis

Yra įvairių operacijų, kurių negalima atlikti su rodyklėmis. Kadangi rodyklė išsaugo adresą, turime nekreipti dėmesio į operacijas, kurios gali sukelti neteisėtą adresą, pavyzdžiui, sudėties ir daugybos. Tokių operacijų sąrašas pateikiamas žemiau.

• Adresas + Adresas = neteisėtas
• Adresas * Adresas = neteisėtas
• Adresas % Adresas = neteisėtas
• Adresas / Adresas = neteisėtas
• Adresas ir adresas = neteisėtas
• Adresas ^ Adresas = neteisėtas
• Adresas | Adresas = neteisėtas
• ~ Adresas = neteisėtas

Rodyklė, kad veiktų C

Kaip aptarėme ankstesniame skyriuje, rodyklė gali nurodyti funkciją C. Tačiau rodyklės kintamojo deklaracija turi būti tokia pati kaip ir funkcija. Apsvarstykite toliau pateiktą pavyzdį, kad žymeklis nukreiptų į funkciją.

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

Išvestis

 Enter two numbers?10 15 The sum is 25 

Žymiklis į funkcijų masyvą C

Norėdami suprasti funkcijų masyvo sąvoką, turime suprasti funkcijų masyvą. Iš esmės funkcijos masyvas yra masyvas, kuriame yra funkcijų adresai. Kitaip tariant, rodyklė į funkcijų masyvą yra rodyklė, nukreipianti į masyvą, kuriame yra funkcijų rodyklės. Apsvarstykite toliau pateiktą pavyzdį.

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

Išvestis

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