Zeiger in c
Zeiger ist ein sehr wichtiges Konzept in der C -Sprache, da der Zeiger uns das Konzept der Adresse im Gedächtnis gibt. Alles, was von den anderen nicht zugänglich ist, kann Zeiger mit Hilfe der Adresse sehr einfach auf diese zugreifen.
Hier werden wir das grundlegende Konzept des Zeigers diskutieren.
Zielsetzung:
Das Hauptziel des Zeigers ist hauptsächlich:
- Erweitertes Zeigerkonzept
- Die Arithmetik des Zeigers
Erweitertes Konzept des Zeigers:
| X | P | Q | R |
|---|---|---|---|
| 1000 | 2000 | 3000 | 4000 |
Beispiel:
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | #enthalten Void main () Int x = 5, *p, ** q, *** r; p = & x; q = & p; r = & q; ** q = 7; *** r = 7; |
Erläuterung:
Hier ist P ein Zeiger. Aus der Zeile p = & x ist es verständlich, dass P ein Zeiger ist, der die Adresse von x hält .
** q ist auch eine Art Zeiger, dessen Indirektion 2 und R auch ein Zeiger ist, dessen Indirektionsstufe 3 beträgt. Wie viele * gibt es, die den Zeigerstufe sind??
Die Regel ist, dass die Zeigerebene so ist, dass er die Adresse einer anderen Variablen enthält.
Dafür hält Q die Adresse von p. P hält die Adresse von x.
Die Prozedur des Lesens der Zeile int x = 5,*p, ** q, *** r;
x ist ein int. p ist ein Zeiger auf ein int. q ist ein Zeiger, der zu einem int apointer ist. Wie viele sind es? Wir sagen genau das gleiche ohne Wortzeiger. Genau wie ** r bedeutet es, R ist ein Zeiger auf einen Zeiger, auf einen Zeiger auf einen int.
Wenn wir mit Hilfe von Q einen Wert setzen
| 1 | *q = p, *r = q, *p = x; |
Wenn wir einen Zeiger oder * vor einer Zeigervariablen schreiben, wird er zu einer solchen Variablen, die auf den variablen Mittelwert P Block hinweist.
Zeiger Arithmetik:
Wir können in zwei Adressen keine Multiplikum hinzufügen oder dividieren (Subtraktion ist möglich).
Wir können eine Ganzzahl nicht mit einer Adresse multiplizieren. In ähnlicher Weise können wir eine Adresse nicht mit einem Ganzzahlwert teilen.
Programmierbeispiel 1:
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 | #enthalten void main () int a, b; int *p, *q; p = & a; q = & b; printf (" %d", p + q); printf (" %d", p * q); printf (" %d", p / q); |
Ausgang:
Erläuterung:
Im oben genannten Programm versuchen wir, die beiden Adressen hinzuzufügen, zu multiplizieren und zu teilen, indem wir einige Aussagen schreiben.
| 1 2 3 4 5 | printf (" %d", p + q); printf (" %d", p * q); printf (" %d", p / q); |
Aber es ist nicht möglich, wie Sie aus der Ausgabe sehen können. Zeiger erteilt niemals die Erlaubnis, eine Adresse hinzuzufügen, zu multiplizieren und zu teilen.
Zeiger kann eine mathematische Berechnung ermöglichen. Sie werden unten erwähnt:
| 1 2 3 4 5 6 7 | P = 1000 P + 1 = 1002 P + 4 = 1008 P - 1 = 998 |
P ist ganzzahliger Zeiger 1000, der auf der Adresse von a basiert. "A" Variable hat zwei Bytes. Die Adresse des 1. Byte beträgt 1001 und die Adresse des 2. Byte 1002. Wenn wir einem Zeiger 1 hinzufügen, wird die Adresse des nächsten Blocks oder der nächsten Variablen anstelle der Adresse des nächsten Byte angezeigt.
| 1 2 3 4 5 | Zeiger + n = Zeiger + Größe von (Zeigertyp) * n = 1000 + 2 * 1 = 1002 |
Wir können zwei Adressen desselben Typs subtrahieren. Zeiger erlaubt es.
Programmierbeispiel 2:
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 | #enthalten void main () int a, b; int *p, *q; p = & a; q = & b; printf (" %d", p - q); |
Ausgang:
Erläuterung:
Hier versuchen wir, zwei Adressen abzuziehen. Glücklicherweise kann es durch den Zeiger unterstützen. Es ist nicht buchstäblich abzug. Es besteht aus einem Block, abhängig von seinem Datentyp.
Formel
| 1 | Zeiger 1 - Zeiger 2 = (wörtliche Subtraktion) / Größe von (Art des Zeigers) |
Wenn es sich um einen Char -Typ handelt, geteilt durch 4.
Wenn es sich um einen Schwimmertyp handelt, geteilt durch 4.
Wenn es int ist, typisch, geteilt durch 2.
Programmierbeispiel 3:
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 | #enthalten Hohlraumtausch (int *, int *); int main () int a, b; printf ("zwei Nummer eingeben"); scanf ("%d%d", & a, & b); Swap (& a, & b); printf ("a = %d b = %d", a, b); Hohlraumtausch (int *x, int *y) int t; t = *x; *x = *y; *y = t; |
Ausgang:
Erläuterung:
Hier kann ein Zeiger eine Funktion durchlaufen. Dies heißt Call von Referenzen. Wenn wir zwei Ganzzahlen tauschen wollen, indem wir die Werte zweier Ganzzahlen durch eine Funktion übergeben, ist dies nicht möglich.
Wir müssen die Adresse der Variablen t = & x übergeben. Wenn wir einer Zeigervariablen * * addieren, verwandelt sich * x in eine solche Variable, die den Wert der Variablen enthält, auf die die P -Variable angezeigt wird. Es bedeutet t = *x bedeutet, t den Wert einer indirekt.
Rufen Sie nach Referenzen an:
Anruf von Referenzen ist der gleiche wie der Anruf von Adresse. Wenn formale Argumente Zeigervariablen sind, wird es von Referenzen aufgerufen.
Referenz bedeutet Adresse. Rufen Sie mit Referenzen auf, wenn wir eine Funktion aufrufen, die Adressen der Variablen übergeben. Sie wird als Referenzaufruf bezeichnet.
Eine wichtige Frage kann sich auf die Adresse beziehen oder warum wir die Adresse von (&) in scanf () verwenden?
Scanf () ist eine vordefinierte Funktion in der C -Sprache. Main () ist auch eine Funktion in der C -Sprache. Wir verwenden Scanf () in Main (). Wenn wir also zwei Variablen in der Funktion main () deklarieren, greifen wir auf diese Variable in scanf () zugänglich zu. Wir können keine Variablen einer Funktion zu einer anderen Funktion verwenden. Die Funktion scanf () möchte also eine Variable und B -Variable einen gewissen Wert setzen, dann muss sie die Adresse von A und B kennenlernen.
Für diese Adresse wird (&) in scanf () verwendet.
Abschluss:
Wir können das grundlegende Konzept des Zeigers kennen. Aus dieser Diskussion sind wir zu dieser Schlussfolgerung gekommen, dass wir ohne Zeiger die Speicherverwaltung in der C -Sprache nicht visualisieren können. Die Adresse steuert das gesamte Speicherverwaltungsschema. Dafür müssen wir das Konzept des Zeigers kennen.