C ++ - Zeiger mit Beispielen

Inhaltsverzeichnis:

Anonim

Was sind Zeiger?

In C ++ bezieht sich ein Zeiger auf eine Variable, die die Adresse einer anderen Variablen enthält. Zeiger haben wie reguläre Variablen einen Datentyp. Beispielsweise kann ein Zeiger vom Typ Integer die Adresse einer Variablen vom Typ Integer enthalten. Ein Zeiger vom Zeichentyp kann die Adresse einer Variablen vom Zeichentyp enthalten.

Sie sollten einen Zeiger als symbolische Darstellung einer Speicheradresse sehen. Mit Zeigern können Programme Call-by-Reference simulieren. Sie können auch dynamische Datenstrukturen erstellen und bearbeiten. In C ++ bezieht sich eine Zeigervariable auf eine Variable, die auf eine bestimmte Adresse in einem Speicher zeigt, auf den eine andere Variable zeigt.

In diesem C ++ - Tutorial lernen Sie:

  • Was sind Zeiger?
  • Adressen in C ++
  • Zeigerdeklarationssyntax
  • Referenzoperator (&) und Referenzoperator (*)
  • Zeiger und Arrays
  • Null Zeiger
  • Zeiger von Variablen
  • Anwendung von Zeigern
  • Vorteile der Verwendung von Zeigern

Adressen in C ++

Um C ++ - Zeiger zu verstehen, müssen Sie verstehen, wie Computer Daten speichern.

Wenn Sie eine Variable in Ihrem C ++ - Programm erstellen, wird dem Computerspeicher ein gewisser Speicherplatz zugewiesen. Der Wert dieser Variablen wird am zugewiesenen Ort gespeichert.

Um den Speicherort im Computerspeicher zu ermitteln, an dem die Daten gespeichert sind, stellt C ++ den Operator & (Referenz) bereit . Der Operator gibt die Adresse zurück, die eine Variable belegt.

Wenn x beispielsweise eine Variable ist, gibt & x die Adresse der Variablen zurück.

Zeigerdeklarationssyntax

Die Deklaration von C ++ hat die folgende Syntax:

datatype *variable_name;
  • Der Datentyp ist der Basistyp des Zeigers, der ein gültiger C ++ - Datentyp sein muss.
  • Der Variablenname sollte der Name der Zeigervariable sein.
  • Das oben für die Zeigerdeklaration verwendete Sternchen ähnelt dem Sternchen, das zur Durchführung der Multiplikationsoperation verwendet wird. Es ist das Sternchen, das die Variable als Zeiger markiert.

Hier ist ein Beispiel für gültige Zeigerdeklarationen in C ++:

int *x; // a pointer to integerdouble *x; // a pointer to doublefloat *x; // a pointer to floatchar *ch // a pointer to a character

Referenzoperator (&) und Referenzoperator (*)

Der Referenzoperator (&) gibt die Adresse der Variablen zurück.

Der Dereferenzierungsoperator (*) hilft uns, den Wert zu erhalten, der in einer Speicheradresse gespeichert wurde.

Zum Beispiel:

Wenn wir eine Variable mit dem Namen num haben, die in der Adresse 0x234 gespeichert ist und den Wert 28 speichert.

Der Referenzoperator (&) gibt 0x234 zurück.

Der Dereferenzierungsoperator (*) gibt 5 zurück.

Beispiel 1:

#include using namespace std;int main() {int x = 27;int *ip;ip = &x;cout << "Value of x is : ";cout << x << endl;cout << "Value of ip is : ";cout << ip<< endl;cout << "Value of *ip is : ";cout << *ip << endl;return 0;}

Ausgabe:

So funktioniert das:

Hier ist ein Screenshot des Codes:

Code Erläuterung:

  1. Importieren Sie die iostream-Headerdatei. Auf diese Weise können wir die in der Header-Datei definierten Funktionen verwenden, ohne Fehler zu erhalten.
  2. Fügen Sie den Standard-Namespace ein, um seine Klassen zu verwenden, ohne ihn aufzurufen.
  3. Rufen Sie die Funktion main () auf. Die Programmlogik sollte im Hauptteil dieser Funktion hinzugefügt werden. Das {markiert den Beginn des Funktionskörpers.
  4. Deklarieren Sie eine Ganzzahlvariable x und weisen Sie ihr den Wert 27 zu.
  5. Deklarieren Sie eine Zeigervariable * ip.
  6. Speichern Sie die Adresse der Variablen x in der Zeigervariablen.
  7. Drucken Sie Text auf der Konsole.
  8. Drucken Sie den Wert der Variablen x auf dem Bildschirm.
  9. Drucken Sie Text auf der Konsole.
  10. Drucken Sie die Adresse der Variablen x. Der Wert der Adresse wurde in der Variablen ip gespeichert.
  11. Drucken Sie Text auf der Konsole.
  12. Druckwert von an der Adresse des Zeigers gespeichert.
  13. Das Programm sollte nach erfolgreicher Ausführung einen Wert zurückgeben.
  14. Ende des Körpers der main () - Funktion.

Zeiger und Arrays

Arrays und Zeiger basieren auf einem verwandten Konzept. Bei der Arbeit mit Arrays mit Zeigern sind verschiedene Dinge zu beachten. Der Arrayname selbst bezeichnet die Basisadresse des Arrays. Dies bedeutet, dass Sie zum Zuweisen der Adresse eines Arrays zu einem Zeiger kein kaufmännisches Und (&) verwenden sollten.

Zum Beispiel:

p = arr;

Das Obige ist korrekt, da arr die Adresse der Arrays darstellt. Hier ist ein weiteres Beispiel:

p = &arr;

Das obige ist falsch.

Wir können ein Array implizit in einen Zeiger konvertieren. Zum Beispiel:

int arr [20];int * ip;

Unten ist eine gültige Operation:

ip = arr;

Nach der obigen Deklaration sind ip und arr gleichwertig und teilen sich Eigenschaften. IP kann jedoch eine andere Adresse zugewiesen werden, arr können wir jedoch nichts zuweisen.

Beispiel 2:

Dieses Beispiel zeigt, wie ein Array mithilfe von Zeigern durchlaufen wird:

#include using namespace std;int main() {int *ip;int arr[] = { 10, 34, 13, 76, 5, 46 };ip = arr;for (int x = 0; x < 6; x++) {cout << *ip << endl;ip++;}return 0;}

Ausgabe:

Hier ist ein Screenshot des Codes:

Code Erläuterung:

  1. Deklarieren Sie eine Ganzzahlzeigervariable ip.
  2. Deklarieren Sie ein Array mit dem Namen arr und speichern Sie 6 Ganzzahlen darin.
  3. Ordnen Sie arr ip zu. IP und arr werden gleichwertig.
  4. Erstellen Sie eine for-Schleife. Die Schleifenvariable x wurde erstellt, um die Array-Elemente von Index 0 bis 5 zu durchlaufen.
  5. Drucken Sie die an der Adresse der Zeiger-IP gespeicherten Werte. Pro Iteration wird ein Wert zurückgegeben, und es werden insgesamt 6 Wiederholungen durchgeführt. Das endl ist ein C ++ - Schlüsselwort, das die Endzeile bedeutet. Mit dieser Aktion können Sie den Cursor nach dem Drucken jedes Werts in die nächste Zeile bewegen. Jeder Wert wird in einer einzelnen Zeile gedruckt.
  6. Bewegen des Zeigers nach jeder Iteration zur nächsten int-Position.
  7. Ende der for-Schleife.
  8. Das Programm muss nach erfolgreicher Ausführung etwas zurückgeben.
  9. Ende des Hauptfunktionskörpers ().

Null Zeiger

Wenn es keine genaue Adresse gibt, die zugewiesen werden soll, kann der Zeigervariablen ein NULL zugewiesen werden. Dies sollte während der Erklärung erfolgen. Ein solcher Zeiger ist als Nullzeiger bekannt. Sein Wert ist Null und wird in vielen Standardbibliotheken wie iostream definiert.

Beispiel 3:

#include using namespace std;int main() {int *ip = NULL;cout << "Value of ip is: " << ip;return 0;}

Ausgabe:

Hier ist ein Screenshot des Codes:

Code Erläuterung:

  1. Deklarieren Sie eine Zeigervariable ip und weisen Sie ihr den Wert NULL zu.
  2. Drucken Sie den Wert der Zeigervariablen-IP neben Text auf der Konsole.
  3. Das Programm muss nach erfolgreichem Abschluss einen Wert zurückgeben.
  4. Ende des Körpers der main () - Funktion.

Zeiger von Variablen

Mit C ++ können Sie Daten direkt aus dem Arbeitsspeicher des Computers bearbeiten.

Der Speicherplatz kann nach Belieben zugewiesen oder neu zugewiesen werden. Dies wird durch Zeigervariablen ermöglicht.

Zeigervariablen verweisen auf eine bestimmte Adresse im Arbeitsspeicher des Computers, auf die eine andere Variable verweist.

Es kann wie folgt deklariert werden:

int *p;

Oder,

int* p;

In Ihrem Beispiel haben wir die Zeigervariable p deklariert.

Es wird eine Speicheradresse enthalten.

Das Sternchen ist der Dereferenzierungsoperator, der einen Zeiger auf bedeutet.

Der Zeiger p zeigt auf einen ganzzahligen Wert in der Speicheradresse.

Beispiel 4:

#include using namespace std;int main() {int *p, x = 30;p = &x;cout << "Value of x is: " << *p;return 0;}

Ausgabe:

Hier ist ein Screenshot des Codes:

Code Erläuterung:

  1. Deklarieren Sie eine Zeigervariable p und eine Variable x mit einem Wert von 30.
  2. Weisen Sie p die Adresse der Variablen x zu.
  3. Drucken Sie den Wert der Zeigervariablen p neben Text auf der Konsole.
  4. Das Programm muss nach erfolgreichem Abschluss einen Wert zurückgeben.
  5. Ende des Körpers der main () - Funktion.

Anwendung von Zeigern

Funktionen in C ++ können nur einen Wert zurückgeben. Ferner werden alle in einer Funktion deklarierten Variablen auf dem Funktionsaufrufstapel zugeordnet. Sobald die Funktion zurückkehrt, werden alle Stapelvariablen zerstört.

Zu funktionierende Argumente werden als Wert übergeben, und Änderungen an den Variablen ändern nicht den Wert der tatsächlich übergebenen Variablen. Das folgende Beispiel veranschaulicht dieses Konzept: -

Beispiel 5:

#include using namespace std;void test(int*, int*);int main() {int a = 5, b = 5;cout << "Before changing: << endl;cout << "a = " << a << endl;cout << "b = " << b << endl;test(&a, &b);cout << "\nAfter changing" << endl;cout << "a = " << a << endl;cout << "b = " << b << endl;return 0;}void test(int* n1, int* n2) {*n1 = 10;*n2 = 11;}

Ausgabe:

Hier ist ein Screenshot des Codes:

Code Erläuterung:

  1. Erstellen Sie einen Prototyp einer Funktion namens test, die zwei ganzzahlige Parameter akzeptiert.
  2. Rufen Sie die Funktion main () auf. Wir werden die Programmlogik in ihren Körper einfügen.
  3. Deklarieren Sie zwei ganzzahlige Variablen a und b mit dem Wert 5.
  4. Drucken Sie Text auf der Konsole. Das Ende (Endzeile) bewegt den Cursor, um mit dem Drucken in der nächsten Zeile zu beginnen.
  5. Drucken Sie den Wert der Variablen a neben anderem Text auf der Konsole aus. Das Ende (Endzeile) bewegt den Cursor, um mit dem Drucken in der nächsten Zeile zu beginnen.
  6. Drucken Sie den Wert der Variablen b neben anderem Text auf der Konsole aus. Das Ende (Endzeile) bewegt den Cursor, um mit dem Drucken in der nächsten Zeile zu beginnen.
  7. Erstellen Sie eine Funktion mit dem Namen test (), die die Adressen der Variablen a und b als Parameter verwendet.
  8. Drucken Sie Text auf der Konsole. Das \ n erstellt eine neue leere Zeile, bevor der Text gedruckt wird. Das Ende (Endzeile) bewegt den Cursor, um in der nächsten Zeile nach dem Drucken des Textes mit dem Drucken zu beginnen.
  9. Drucken Sie den Wert der Variablen a neben anderem Text auf der Konsole aus. Das Ende (Endzeile) bewegt den Cursor, um mit dem Drucken in der nächsten Zeile zu beginnen.
  10. Drucken Sie den Wert der Variablen b neben anderem Text auf der Konsole aus. Das Ende (Endzeile) bewegt den Cursor, um mit dem Drucken in der nächsten Zeile zu beginnen.
  11. Das Programm muss nach erfolgreichem Abschluss einen Wert zurückgeben.
  12. Ende des Körpers der main () - Funktion.
  13. Funktionstest definieren (). Die Funktion sollte zwei ganzzahlige Zeigervariablen * n1 und * n2 annehmen.
  14. Zuweisen der Zeigervariablen * n1 zu einem Wert von 10.
  15. Zuweisen der Zeigervariablen * n2 zu einem Wert von 11.
  16. Ende des Körpers des Funktionstests ().

Obwohl den Variablen a und b innerhalb des Funktionstests neue Werte zugewiesen werden, wird nach Abschluss des Funktionsaufrufs der äußere Funktionshaupt nicht gleich wiedergegeben.

Die Verwendung von Zeigern als Funktionsargumente hilft dabei, die tatsächliche Adresse der Variablen in der Funktion zu übergeben, und alle an der Variablen vorgenommenen Änderungen werden in der äußeren Funktion wiedergegeben.

Im obigen Fall hat die Funktion 'test' die Adresse der Variablen 'a' und 'b'. Auf diese beiden Variablen kann direkt über die Funktion 'test' zugegriffen werden. Daher werden alle an diesen Variablen vorgenommenen Änderungen in der Aufruferfunktion 'main' wiedergegeben.

Vorteile der Verwendung von Zeigern

Hier sind die Vor- und Vorteile der Verwendung von Zeigern

  • Zeiger sind Variablen, die die Adresse anderer Variablen in C ++ speichern.
  • Es kann mehr als eine Variable geändert und von der Funktion mithilfe von Zeigern zurückgegeben werden.
  • Der Speicher kann mithilfe von Zeigern dynamisch zugewiesen und freigegeben werden.
  • Zeiger helfen bei der Vereinfachung der Komplexität des Programms.
  • Die Ausführungsgeschwindigkeit eines Programms wird durch die Verwendung von Zeigern verbessert.

Zusammenfassung:

  • Ein Zeiger bezieht sich auf eine Variable, die die Adresse einer anderen Variablen enthält.
  • Jeder Zeiger hat einen gültigen Datentyp.
  • Ein Zeiger ist eine symbolische Darstellung einer Speicheradresse.
  • Mithilfe von Zeigern können Programme Call-by-Reference simulieren und dynamische Datenstrukturen erstellen und bearbeiten.
  • Arrays und Zeiger verwenden ein verwandtes Konzept.
  • Der Arrayname gibt die Basis des Arrays an.
  • Wenn Sie einem Zeiger die Adresse eines Arrays zuweisen möchten, verwenden Sie kein kaufmännisches Und (&).
  • Wenn es keine bestimmte Adresse zum Zuweisen einer Zeigervariable gibt, weisen Sie ihr NULL zu.