Vi kan utføre aritmetiske operasjoner på pekerne som addisjon, subtraksjon osv. Men siden vi vet at pekeren inneholder adressen, vil resultatet av en aritmetisk operasjon utført på pekeren også være en peker hvis den andre operanden er av typen heltall. Ved subtraksjon av peker-fra-peker vil resultatet være en heltallsverdi. Følgende aritmetiske operasjoner er mulig på pekeren i C-språk:

• Øke
• Redusere
• Addisjon
• Subtraksjon
• Sammenligning

Inkrementerende peker i C

Hvis vi øker en peker med 1, vil pekeren begynne å peke til den umiddelbare neste plasseringen. Dette er noe forskjellig fra den generelle aritmetikken siden verdien av pekeren vil øke med størrelsen på datatypen som pekeren peker til.

Vi kan krysse en matrise ved å bruke inkrementoperasjonen på en peker som vil fortsette å peke til hvert element i matrisen, utføre en operasjon på det og oppdatere seg selv i en løkke.

Regelen for å øke pekeren er gitt nedenfor:

 new_address= current_address + i * size_of(data type) 

Hvor i er tallet som pekeren økes med.

32-bit

For 32-biters int-variabel vil den økes med 2 byte.

64-bit

For 64-bits int-variabel vil den økes med 4 byte.

hvordan slette kolonne i postgresql

La oss se eksemplet med inkrementerende pekervariabel på 64-bits arkitektur.

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

Produksjon

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

Å krysse en matrise ved å bruke pekeren

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

Dekrementerende peker i C

Som inkrement kan vi redusere en pekervariabel. Hvis vi reduserer en peker, vil den begynne å peke til forrige plassering. Formelen for å redusere pekeren er gitt nedenfor:

 new_address= current_address - i * size_of(data type) 

32-bit

For 32-bits int-variabel vil den reduseres med 2 byte.

64-bit

For 64-bits int-variabel vil den reduseres med 4 byte.

La oss se eksemplet med dekrementerende pekervariabel på 64-biters 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. } 

Produksjon

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

C Pointer Addisjon

Vi kan legge til en verdi til pekervariabelen. Formelen for å legge til verdi til pekeren er gitt nedenfor:

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

32-bit

For 32-biters int-variabel vil den legge til 2 * tall.

64-bit

For 64-bits int-variabel vil den legge til 4 * tall.

La oss se eksempelet på å legge til verdi til pekervariabel på 64-bits arkitektur.

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

Produksjon

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

Som du kan se, er adressen til p 3214864300. Men etter å ha lagt til 3 med p-variabelen, er den 3214864312, dvs. 4*3=12 inkrement. Siden vi bruker 64-bits arkitektur, øker den 12. Men hvis vi brukte 32-bits arkitektur, økte den til kun 6, dvs. 2*3=6. Som heltallsverdi opptar 2-byte minne i 32-bits OS.

C Pointer subtraksjon

Som pekeraddisjon kan vi trekke en verdi fra pekervariabelen. Å trekke et hvilket som helst tall fra en peker vil gi en adresse. Formelen for å trekke verdi fra pekervariabelen er gitt nedenfor:

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

32-bit

For 32-biters int-variabel vil den trekke fra 2 * tall.

stabel i java

64-bit

For 64-bits int-variabel vil den trekke fra 4 * tall.

La oss se eksempelet på å trekke verdi fra pekervariabelen på 64-bits arkitektur.

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

Produksjon

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

Du kan se etter å ha trukket 3 fra pekervariabelen, at den er 12 (4*3) mindre enn den forrige adresseverdien.

Men i stedet for å trekke fra et tall, kan vi også trekke en adresse fra en annen adresse (peker). Dette vil resultere i et tall. Det vil ikke være en enkel aritmetisk operasjon, men den vil følge følgende regel.

Hvis to pekere er av samme type,

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

Tenk på følgende eksempel for å trekke en peker fra en annen.

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

Produksjon

 Pointer Subtraction: 1030585080 - 1030585068 = 3 

Ulovlig regning med pekere

Det er forskjellige operasjoner som ikke kan utføres på pekere. Siden pekeren lagrer adresse, må vi derfor ignorere operasjonene som kan føre til en ulovlig adresse, for eksempel addisjon og multiplikasjon. En liste over slike operasjoner er gitt nedenfor.

• Adresse + Adresse = ulovlig
• Adresse * Adresse = ulovlig
• Adresse % Adresse = ulovlig
• Adresse / Adresse = ulovlig
• Adresse og adresse = ulovlig
• Adresse ^ Adresse = ulovlig
• Adresse | Adresse = ulovlig
• ~Adresse = ulovlig

Peker til funksjon i C

Som vi diskuterte i forrige kapittel, kan en peker peke på en funksjon i C. Men deklarasjonen av pekervariabelen må være den samme som funksjonen. Tenk på følgende eksempel for å lage en peker som peker på funksjonen.

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

Produksjon

 Enter two numbers?10 15 The sum is 25 

Peker til en rekke funksjoner i C

For å forstå konseptet med en rekke funksjoner, må vi forstå funksjonsutvalget. I utgangspunktet er en matrise av funksjonen en matrise som inneholder adressene til funksjoner. Med andre ord er pekeren til en rekke funksjoner en peker som peker til en matrise som inneholder pekerne til funksjonene. Tenk på følgende eksempel.

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

Produksjon

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