TechCodeview

Wir können an den Zeigern arithmetische Operationen wie Addition, Subtraktion usw. durchführen. Da wir jedoch wissen, dass der Zeiger die Adresse enthält, ist das Ergebnis einer am Zeiger durchgeführten arithmetischen Operation auch ein Zeiger, wenn der andere Operand vom Typ Integer ist. Bei der Zeiger-vom-Zeiger-Subtraktion ist das Ergebnis ein ganzzahliger Wert. Folgende arithmetische Operationen sind auf dem Zeiger in der Sprache C möglich:

• Zuwachs
• Dekrementieren
• Zusatz
• Subtraktion
• Vergleich

Inkrementierender Zeiger in C

Wenn wir einen Zeiger um 1 erhöhen, beginnt der Zeiger auf die unmittelbar nächste Position zu zeigen. Dies unterscheidet sich etwas von der allgemeinen Arithmetik, da der Wert des Zeigers um die Größe des Datentyps erhöht wird, auf den der Zeiger zeigt.

Wir können ein Array durchlaufen, indem wir die Inkrementierungsoperation für einen Zeiger verwenden, der weiterhin auf jedes Element des Arrays zeigt, eine Operation daran ausführt und sich in einer Schleife selbst aktualisiert.

Die Regel zum Erhöhen des Zeigers ist unten angegeben:

 new_address= current_address + i * size_of(data type) 

Wobei i die Zahl ist, um die der Zeiger erhöht wird.

32-Bit

Bei einer 32-Bit-Int-Variable wird sie um 2 Bytes erhöht.

Samen vs. Sporen

64-Bit

Bei einer 64-Bit-Int-Variable wird sie um 4 Bytes erhöht.

Sehen wir uns das Beispiel der Inkrementierung einer Zeigervariablen auf einer 64-Bit-Architektur an.

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

Ausgabe

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

Durchlaufen eines Arrays mithilfe eines Zeigers

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

Dekrementierender Zeiger in C

Wie beim Inkrementieren können wir eine Zeigervariable dekrementieren. Wenn wir einen Zeiger dekrementieren, beginnt er, auf die vorherige Position zu zeigen. Die Formel zum Dekrementieren des Zeigers ist unten angegeben:

 new_address= current_address - i * size_of(data type) 

32-Bit

Bei einer 32-Bit-Int-Variable wird sie um 2 Bytes dekrementiert.

64-Bit

Bei einer 64-Bit-Int-Variable wird sie um 4 Bytes dekrementiert.

Sehen wir uns das Beispiel der Dekrementierung einer Zeigervariablen auf einem 64-Bit-Betriebssystem an.

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

Ausgabe

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

C-Zeiger-Hinzufügung

Wir können der Zeigervariablen einen Wert hinzufügen. Die Formel zum Hinzufügen eines Werts zum Zeiger ist unten angegeben:

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

32-Bit

Für eine 32-Bit-Int-Variable wird 2 * Zahl hinzugefügt.

npm-Installationsbefehl

64-Bit

Für eine 64-Bit-Int-Variable werden 4 * Zahlen hinzugefügt.

Sehen wir uns das Beispiel des Hinzufügens eines Werts zu einer Zeigervariablen in einer 64-Bit-Architektur an.

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

Ausgabe

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

Wie Sie sehen können, lautet die Adresse von p 3214864300. Nach der Addition von 3 mit der p-Variablen beträgt sie jedoch 3214864312, d. h. 4*3=12 Inkremente. Da wir eine 64-Bit-Architektur verwenden, erhöht sich der Wert um 12. Wenn wir jedoch eine 32-Bit-Architektur verwenden, erhöht sich der Wert nur auf 6, d. h. 2*3=6. Als Ganzzahlwert belegt er im 32-Bit-Betriebssystem 2 Byte Speicher.

C-Zeiger-Subtraktion

Wie bei der Zeigeradaddition können wir einen Wert von der Zeigervariablen subtrahieren. Das Subtrahieren einer beliebigen Zahl von einem Zeiger ergibt eine Adresse. Die Formel zum Subtrahieren des Werts von der Zeigervariablen ist unten angegeben:

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

32-Bit

Für eine 32-Bit-Int-Variable wird 2 * Zahl subtrahiert.

64-Bit

Für eine 64-Bit-Int-Variable werden 4 * Zahlen subtrahiert.

Sehen wir uns das Beispiel der Subtraktion des Werts von der Zeigervariablen auf einer 64-Bit-Architektur an.

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

Ausgabe

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

Sie können sehen, dass nach dem Subtrahieren von 3 von der Zeigervariablen dieser 12 (4*3) kleiner ist als der vorherige Adresswert.

mvc Java

Anstatt jedoch eine Zahl zu subtrahieren, können wir eine Adresse auch von einer anderen Adresse (Zeiger) subtrahieren. Daraus ergibt sich eine Zahl. Es wird keine einfache arithmetische Operation sein, sondern sie wird der folgenden Regel folgen.

Wenn zwei Zeiger vom gleichen Typ sind,

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

Betrachten Sie das folgende Beispiel, um einen Zeiger von einem anderen zu subtrahieren.

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

Ausgabe

 Pointer Subtraction: 1030585080 - 1030585068 = 3 

Unzulässige Arithmetik mit Zeigern

Es gibt verschiedene Operationen, die nicht auf Zeiger ausgeführt werden können. Da der Zeiger die Adresse speichert, müssen wir die Operationen ignorieren, die zu einer ungültigen Adresse führen können, beispielsweise Addition und Multiplikation. Nachfolgend finden Sie eine Liste solcher Operationen.

• Adresse + Adresse = illegal
• Adresse * Adresse = illegal
• Adresse % Adresse = illegal
• Adresse / Adresse = illegal
• Adresse & Adresse = illegal
• Adresse ^ Adresse = illegal
• Adresse | Adresse = illegal
• ~Adresse = illegal

Zeiger auf Funktion in C

Wie wir im vorherigen Kapitel besprochen haben, kann ein Zeiger auf eine Funktion in C zeigen. Allerdings muss die Deklaration der Zeigervariablen mit der der Funktion identisch sein. Betrachten Sie das folgende Beispiel, um einen Zeiger zu erstellen, der auf die Funktion zeigt.

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

Ausgabe

 Enter two numbers?10 15 The sum is 25 

Zeiger auf Array von Funktionen in C

Um das Konzept eines Arrays von Funktionen zu verstehen, müssen wir das Array von Funktionen verstehen. Im Grunde ist ein Array der Funktion ein Array, das die Adressen von Funktionen enthält. Mit anderen Worten: Der Zeiger auf ein Array von Funktionen ist ein Zeiger, der auf ein Array zeigt, das die Zeiger auf die Funktionen enthält. Betrachten Sie das folgende Beispiel.

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

Ausgabe

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