TechCodeview

Voimme suorittaa osoittimille aritmeettisia operaatioita, kuten yhteen-, vähennys- jne. Koska tiedämme kuitenkin, että osoitin sisältää osoitteen, osoittimelle suoritetun aritmeettisen toiminnon tulos on myös osoitin, jos toinen operandi on tyyppiä kokonaisluku. Osoittimesta osoittimesta -vähennyksessä tulos on kokonaisluku. Seuraavat aritmeettiset toiminnot ovat mahdollisia osoittimella C-kielellä:

• Lisäys
• Vähennys
• Lisäys
• Vähennyslasku
• Vertailu

Kasvava osoitin C:ssä

Jos lisäämme osoitinta yhdellä, osoitin alkaa osoittaa välittömästi seuraavaan sijaintiin. Tämä eroaa jonkin verran yleisestä aritmetiikasta, koska osoittimen arvo kasvaa sen tietotyypin koolla, johon osoitin osoittaa.

Voimme kulkea taulukon läpi käyttämällä inkrementtioperaatiota osoittimessa, joka osoittaa jatkuvasti taulukon jokaiseen elementtiin, suorittaa sille jonkin toimenpiteen ja päivittää itsensä silmukassa.

kettu tai susi

Sääntö osoittimen kasvattamiseksi on annettu alla:

 new_address= current_address + i * size_of(data type) 

Missä i on luku, jolla osoitinta kasvatetaan.

32-bittinen

32-bittiselle int-muuttujalle sitä kasvatetaan 2 tavulla.

64-bittinen

64-bittiselle int-muuttujalle sitä kasvatetaan 4 tavulla.

Katsotaanpa esimerkkiä osoitinmuuttujan lisäämisestä 64-bittisessä arkkitehtuurissa.

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

Lähtö

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

Matriisin läpikulku osoittimen avulla

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

Vähentävä osoitin C:ssä

Kuten inkrementtiä, voimme pienentää osoitinmuuttujaa. Jos vähennämme osoitinta, se alkaa osoittaa edelliseen sijaintiin. Osoittimen pienentämisen kaava on annettu alla:

 new_address= current_address - i * size_of(data type) 

32-bittinen

32-bittisen int-muuttujan tapauksessa sitä pienennetään 2 tavulla.

64-bittinen

64-bittiselle int-muuttujalle sitä pienennetään 4 tavulla.

Katsotaanpa esimerkkiä osoitinmuuttujan pienentämisestä 64-bittisessä käyttöjärjestelmässä.

offset-korkeus

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

Lähtö

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

C Osoittimen lisäys

Voimme lisätä arvon osoitinmuuttujaan. Kaava arvon lisäämiseksi osoittimeen on annettu alla:

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

32-bittinen

32-bittiselle int-muuttujalle se lisää 2*-luvun.

java scan.nextstring

64-bittinen

64-bittiselle int-muuttujalle se lisää 4*-luvun.

Katsotaanpa esimerkkiä arvon lisäämisestä osoitinmuuttujaan 64-bittisessä arkkitehtuurissa.

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

Lähtö

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

Kuten näette, p:n osoite on 3214864300. Mutta kun 3 on lisätty p-muuttujaan, se on 3214864312, eli 4*3=12 askel. Koska käytämme 64-bittistä arkkitehtuuria, se kasvaa 12. Mutta jos käytimme 32-bittistä arkkitehtuuria, se kasvaa vain 6:een, eli 2*3=6. Kokonaislukuarvona vie 2-tavuinen muisti 32-bittisessä käyttöjärjestelmässä.

C Osoittimen vähennys

Kuten osoittimen lisääminen, voimme vähentää arvon osoitinmuuttujasta. Minkä tahansa luvun vähentäminen osoittimesta antaa osoitteen. Kaava arvon vähentämiseksi osoitinmuuttujasta on annettu alla:

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

32-bittinen

32-bittiselle int-muuttujalle se vähentää 2 * luvun.

enum tostring java

64-bittinen

64-bittiselle int-muuttujalle se vähentää 4 * luvun.

Katsotaanpa esimerkkiä arvon vähentämisestä osoitinmuuttujasta 64-bittisessä arkkitehtuurissa.

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

Lähtö

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

Näet, kun osoitinmuuttujasta on vähennetty 3, se on 12 (4*3) pienempi kuin edellinen osoitearvo.

Numeron vähentämisen sijaan voimme kuitenkin vähentää osoitteen myös toisesta osoitteesta (osoittimesta). Tämä johtaa numeroon. Se ei ole yksinkertainen aritmeettinen operaatio, vaan se noudattaa seuraavaa sääntöä.

Jos kaksi osoitinta ovat samaa tyyppiä,

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

Harkitse seuraavaa esimerkkiä yhden osoittimen vähentämiseksi toisesta.

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

Lähtö

 Pointer Subtraction: 1030585080 - 1030585068 = 3 

Laiton aritmetiikka osoittimilla

On olemassa erilaisia ​​toimintoja, joita ei voida suorittaa osoittimille. Koska osoitin tallentaa osoitteen, meidän on jätettävä huomiotta toiminnot, jotka voivat johtaa laittomaan osoitteeseen, kuten yhteen- ja kertolasku. Alla on luettelo tällaisista toiminnoista.

• Osoite + Osoite = laiton
• Osoite * Osoite = laiton
• Osoite % Osoite = laiton
• Osoite / Osoite = laiton
• Osoite ja osoite = laiton
• Osoite ^ Osoite = laiton
• Osoite | Osoite = laiton
• ~Osoite = laiton

Osoitin toimimaan C:ssä

Kuten edellisessä luvussa totesimme, osoitin voi osoittaa funktiota C:ssä. Osoitinmuuttujan määrityksen on kuitenkin oltava sama kuin funktion. Harkitse seuraavaa esimerkkiä tehdäksesi funktioon osoittavan osoittimen.

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

Lähtö

char tostring java

 Enter two numbers?10 15 The sum is 25 

Osoitin C:n funktioiden joukkoon

Ymmärtääksemme funktioiden joukon käsitteen meidän on ymmärrettävä funktioiden joukko. Periaatteessa funktion taulukko on taulukko, joka sisältää funktioiden osoitteet. Toisin sanoen osoitin funktioiden joukkoon on osoitin, joka osoittaa taulukkoon, joka sisältää funktioiden osoittimet. Harkitse seuraavaa esimerkkiä.

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

Lähtö

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