Vi kan utföra aritmetiska operationer på pekarna som addition, subtraktion, etc. Men eftersom vi vet att pekaren innehåller adressen, kommer resultatet av en aritmetisk operation som utförs på pekaren också att vara en pekare om den andra operanden är av typen heltal. Vid subtraktion av pekare från pekare blir resultatet ett heltalsvärde. Följande aritmetiska operationer är möjliga på pekaren i C-språk:

• Ökning
• Minskning
• Tillägg
• Subtraktion
• Jämförelse

Inkrementerande pekare i C

Om vi ​​ökar en pekare med 1 kommer pekaren att börja peka på nästa plats. Detta skiljer sig något från den allmänna aritmetiken eftersom värdet på pekaren kommer att ökas med storleken på datatypen som pekaren pekar mot.

Vi kan korsa en array genom att använda inkrementoperationen på en pekare som fortsätter att peka på varje element i arrayen, utföra någon operation på det och uppdatera sig själv i en loop.

Regeln för att öka pekaren ges nedan:

 new_address= current_address + i * size_of(data type) 

Där i är talet med vilket pekaren ökas.

32-bitars

För 32-bitars int-variabel kommer den att ökas med 2 byte.

musrullning fungerar inte

64-bitars

För 64-bitars int-variabel kommer den att ökas med 4 byte.

Låt oss se exemplet med inkrementerande pekarvariabel på 64-bitars 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; } 

Produktion

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

Att korsa en array med hjälp av pekaren

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

Minskande pekare i C

Liksom inkrement kan vi minska en pekarvariabel. Om vi ​​minskar en pekare kommer den att börja peka på den föregående platsen. Formeln för att minska pekaren ges nedan:

 new_address= current_address - i * size_of(data type) 

32-bitars

För 32-bitars int-variabel kommer den att minskas med 2 byte.

64-bitars

För 64-bitars int-variabel kommer den att minskas med 4 byte.

Låt oss se exemplet med dekrementerande pekarvariabel på 64-bitars 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. } 

Produktion

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

C Pointer Tillägg

Vi kan lägga till ett värde till pekarvariabeln. Formeln för att lägga till värde till pekaren ges nedan:

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

32-bitars

För 32-bitars int-variabel kommer den att lägga till 2 * nummer.

gzip för linux

64-bitars

För 64-bitars int-variabel kommer den att lägga till 4 * nummer.

Låt oss se exemplet på att lägga till värde till pekarvariabel på 64-bitars 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; } 

Produktion

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

Som du kan se är adressen till p 3214864300. Men efter att ha lagt till 3 med variabel p är den 3214864312, dvs 4*3=12 steg. Eftersom vi använder 64-bitars arkitektur ökar den 12. Men om vi använde 32-bitars arkitektur ökade den till endast 6, dvs. 2*3=6. Eftersom ett heltalsvärde upptar 2-byte minne i 32-bitars OS.

C Pointer subtraktion

Liksom pekaraddition kan vi subtrahera ett värde från pekarvariabeln. Att subtrahera valfritt tal från en pekare kommer att ge en adress. Formeln för att subtrahera värde från pekarvariabeln ges nedan:

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

32-bitars

För 32-bitars int-variabel kommer den att subtrahera 2 * tal.

64-bitars

För 64-bitars int-variabel kommer den att subtrahera 4 * tal.

Låt oss se exemplet på att subtrahera värde från pekarvariabeln på 64-bitars arkitektur.

hur man anropar en metod i java

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

Produktion

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

Du kan se efter att ha subtraherat 3 från pekarvariabeln, det är 12 (4*3) mindre än det tidigare adressvärdet.

Men istället för att subtrahera ett tal kan vi också subtrahera en adress från en annan adress (pekare). Detta kommer att resultera i ett antal. Det kommer inte att vara en enkel aritmetisk operation, men den kommer att följa följande regel.

hur man blockerar YouTube-annonser på Android

Om två pekare är av samma typ,

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

Betrakta följande exempel för att subtrahera en pekare från en annan.

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

Produktion

 Pointer Subtraction: 1030585080 - 1030585068 = 3 

Olaglig aritmetik med pekare

Det finns olika operationer som inte kan utföras på pekare. Eftersom pekaren lagrar adresser måste vi därför ignorera de operationer som kan leda till en olaglig adress, till exempel addition och multiplikation. En lista över sådana operationer ges nedan.

• Adress + Adress = olagligt
• Adress * Adress = olagligt
• Adress % Adress = olagligt
• Adress / Adress = olagligt
• Adress & Adress = olagligt
• Adress ^ Adress = olagligt
• Adress | Adress = olagligt
• ~Adress = olagligt

Pekare för att fungera i C

Som vi diskuterade i föregående kapitel kan en pekare peka på en funktion i C. Dock måste deklarationen av pekarvariabeln vara densamma som funktionen. Betrakta följande exempel för att göra en pekare som pekar på funktionen.

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

Produktion

 Enter two numbers?10 15 The sum is 25 

Pekare till Array av funktioner i C

För att förstå konceptet med en uppsättning funktioner måste vi förstå uppsättningen av funktioner. I grund och botten är en array av funktionen en array som innehåller adresserna till funktioner. Med andra ord är pekaren till en array av funktioner en pekare som pekar på en array som innehåller pekarna till funktionerna. Betrakta följande exempel.

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

Produktion

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