Menü

Zeiger und Zeigeroperationen in C ++

pointers pointer operations c

Versuchen Sie Unser Instrument, Um Probleme Zu Beseitigen

Eine intensive Untersuchung der Zeiger und ihrer Verwendung in C ++.

Ein Zeiger ist eine der leistungsstärksten Funktionen der C ++ - Sprache. Ein Zeiger hilft, die Variablen über seine Adresse zu manipulieren.

So installieren Sie die BIN-Datei

In diesem Tutorial werden wir uns ausführlich mit Zeigern und ihrer Verwendung in C ++ befassen.

=> Sehen Sie sich hier die einfache C ++ - Schulungsserie an.

Zeiger in c ++

Was du lernen wirst:

Was ist ein Zeiger?

Ein Zeiger ist eine Variable, die die Adresse eines Speicherorts enthält. Wir wissen, dass alle Variablen, die wir deklarieren, eine bestimmte Adresse im Speicher haben. Wir deklarieren eine Zeigervariable, die auf diese Adressen im Speicher verweist.

Die allgemeine Syntax zum Deklarieren einer Zeigervariablen lautet:

datatype * variable_name;

Zum Beispiel, die Erklärung int * ptr;

Dies bedeutet, dass ptr ein Zeiger ist, der auf eine Variable vom Typ int zeigt. Daher enthält eine Zeigervariable immer einen Speicherort oder eine Adresse. Lassen Sie uns die Funktionsweise von Zeigervariablen unten sehen.

Bedenken Sie, dass wir die folgenden Erklärungen haben:

Int p, *ptr; //declare variable p and pointer variable ptr p = 4; //assign value 4 to variable p ptr = &p; //assign address of p to pointer variable ptr

Im Speicher werden diese Deklarationen wie folgt dargestellt:

Speicherzuordnung von Zeigern

Dies ist die interne Darstellung des Zeigers im Speicher. Wenn wir der Zeigervariablen die Adressvariable zuweisen, zeigt sie auf die Variable, wie in der obigen Darstellung gezeigt.

Da ptr eine Adresse der Variablen p hat, gibt * ptr den Wert der Variablen p an (Variable, auf die die Zeigervariable ptr zeigt).

Hinweis: Der Operator *, den wir mit dem Zeiger verwenden, wird verwendet, um anzuzeigen, dass es sich um eine Zeigervariable handelt.

Lassen Sie uns einige der Zeigerkonzepte sehen, die in C ++ verwendet werden.

Zeigerarithmetik

Wir wissen, dass eine Zeigervariable immer auf die Adresse im Speicher zeigt. Unter den Operationen, die wir ausführen können, haben wir die folgenden arithmetischen Operationen, die für Zeiger ausgeführt werden.

  • Inkrementoperator (++)
  • Dekrementierungsoperator (-)
  • Zugabe (+)
  • Subtraktion (-)

Lassen Sie uns die Verwendung dieser Operationen in einem Beispielprogramm sehen.

#include #include using namespace std; int main() { int myarray(5) = {2, 4,6, 8,10}; int* myptr; myptr = myarray; cout<<'First element in the array :'<<*myptr<

Ausgabe:

Erstes Element im Array: 2
nächstes Element im Array: 4
nächstes Element im Array: 6
nächstes Element im Array: 4
nächstes Element im Array: 2

Wir haben die arithmetischen Operationen gesehen, die an Zeigern ausgeführt wurden. Beachten Sie, dass der Inkrementierungsoperator ++ den Zeiger inkrementiert und auf das nächste Element im Array zeigt. In ähnlicher Weise dekrementiert der Dekrementierungsoperator die Zeigervariable um 1, sodass sie auf das vorherige Element im Array zeigt.

Wir verwenden auch + und - Operatoren. Zuerst haben wir der Zeigervariablen 1 hinzugefügt. Das Ergebnis zeigt, dass es auf das nächste Element im Array zeigt. In ähnlicher Weise bewirkt der Operator -, dass die Zeigervariable auf das vorherige Element im Array zeigt.

Neben diesen arithmetischen Operatoren können wir auch Vergleichsoperatoren wie == ,.

Null- und Leerezeiger

Wenn einer Zeigervariablen keine Adresse einer Variablen zugewiesen wird, empfiehlt es sich, der Zeigervariablen einen NULL-Wert zuzuweisen. Eine Zeigervariable mit einem NULL-Wert wird als NULL-Zeiger bezeichnet.

Ein Nullzeiger ist ein konstanter Zeiger mit dem im iostream-Header definierten Wert Null. Der Speicher an Adresse 0 ist vom Betriebssystem reserviert und wir können nicht auf diesen Speicherort zugreifen.

Mit dem Nullzeiger können wir den Missbrauch nicht verwendeter Zeiger vermeiden und verhindern, dass Zeigervariablen einige Müllwerte zugewiesen werden.

Leere Zeiger sind die speziellen Zeiger, die auf Werte ohne Typ verweisen. Die Hohlraumzeiger sind flexibler, da sie auf jeden Typ zeigen können. Sie können jedoch nicht direkt dereferenziert werden. Für die Dereferenzierung muss der void-Zeiger in einen Zeiger konvertiert werden, der auf einen Wert mit dem konkreten Datentyp zeigt.

Wir haben die Funktionsweise des NULL-Zeigers und des Void-Zeigers im folgenden Codebeispiel gezeigt.

#include #include using namespace std; int main() { int intvar = 10; char c = 'A'; void* vptr; int* myptr = NULL; cout<<'NULL pointer value :'<

Ausgabe:

beste MP3-Download-App für Android

NULL Zeigerwert: 0
Void-Zeiger vptr zeigt auf: A.
Void-Zeiger vptr zeigt auf: 10

Im obigen Programm deklarieren wir zunächst einen Ganzzahlzeiger, dem der Wert NULL zugewiesen ist. Wenn wir diesen Zeiger drucken, sehen wir, dass der Wert 0 ist, wie wir zuvor besprochen haben.

Als nächstes deklarieren wir einen ungültigen Zeiger. Zuerst weisen wir diesem leeren Zeiger eine Adresse der Zeichenvariablen zu. Dann weisen wir einem Zeichenzeiger einen ungültigen Zeiger zu und geben ihn mit char * ein. Als nächstes drucken wir den charptr-Wert, der auf char A zeigt, eine Zeichenvariable, die wir zuvor deklariert haben und auf die der void-Zeiger zeigt.

Als nächstes haben wir dem Void-Zeiger eine Integer-Variable zugewiesen und führen dann die gleichen Schritte zum Dereferenzieren dieses Void-Zeigers mithilfe eines Integer-Zeigers aus.

Arrays und Zeiger

Arrays und Zeiger sind stark miteinander verbunden. Wir wissen, dass der Name des Arrays auf das erste Element im Array verweist und dies ein konstanter Zeiger ist.

Wir können diesen Zeiger einer Zeigervariablen zuweisen und dann auf das Array zugreifen, indem wir entweder den Zeiger dekrementieren oder den Indexoperator verwenden.

Wir werden diese Zuordnung zwischen der Zeigervariablen und dem Array im folgenden Codebeispiel sehen.

#include #include using namespace std; int main() { int myarray(5) = {1, 1, 2, 3, 5}; int* ptrvar; ptrvar = myarray; for(int i=0;i<5;i++) { cout<<*ptrvar<<' '; ptrvar++; } return 0; }

Ausgabe:

1 1 2 3 5

Im obigen Programm weisen wir den Array-Namen einer Zeigervariablen zu. Da der Arrayname auf das erste Element im Array verweist, können wir den Inhalt des gesamten Arrays mithilfe einer Zeigervariable drucken und mit dem Operator ++ inkrementieren. Dies wird in der Ausgabe angezeigt.

Array von Zeigern

Manchmal benötigen wir mehr als eine Zeigervariable in einem Programm. Anstatt jede einzelne Zeigervariable zu deklarieren, können wir ein Array von Zeigern deklarieren.

Nehmen wir gleich ein Beispiel, um ein Array von Zeigern zu demonstrieren.

#include #include using namespace std; int main() { int myarray(5) = {2,4,6,8,10}; int *ptr(5); //array of pointers for(int i=0;i<5;i++){ ptr(i) = &myarray(i); } for (int i = 0; i < 5; i++) { cout << 'Value of myarray(' << i << ') = '; cout << *ptr(i) << endl; } return 0; }

Ausgabe:

Wert von myarray (0) = 2
Wert von Myarray (1) = 4
Wert von Myarray (2) = 6
Wert von Myarray (3) = 8
Wert von Myarray (4) = 10

In der obigen Erklärung

int * ptr (5);

Wir können interpretieren als; ptr ist ein Array von 5 ganzzahligen Zeigern. Daher zeigt jedes Element von ptr auf eine Variable vom Typ Integer.

Wir verwenden ein ganzzahliges Array und weisen jedem der ptr-Elemente die Adresse jedes Elements des Arrays zu. Dann zeigen wir den Inhalt des ptr-Arrays an, indem wir '* ptr (i)' ausgeben.

Zeiger der Zeiger

Der Zeiger von Zeigern ist nichts anderes als mehrere Indirektionen. Es ist eine Art Zeigerkette. Wenn wir einen Zeiger von Zeigern definieren, hat der erste Zeiger eine Adresse des zweiten Zeigers, der wiederum die Adresse der Variablen hat, auf die er zeigt.

Im Speicher wird dies dargestellt als:

Zeiger der Zeiger Speicherzuordnung

Ein Zeiger von Zeigern wird wie folgt deklariert:

int** intptr;

Wir nehmen direkt ein Codebeispiel, um den Zeiger der Zeiger besser zu verstehen.

#include #include using namespace std; int main() { int *vptr; int ** intptr; int var = 10; vptr = &var; intptr = &vptr; cout<<'Variable var: '<

Ausgabe:

Variable var: 10
Zeiger auf Variable: 10
Zeiger auf Zeiger auf eine Variable: 10

Im obigen Programm deklarieren wir eine Ganzzahlvariable, einen Ganzzahlzeiger und einen Zeiger eines Zeigers auf eine Ganzzahl. Wie im Programm gezeigt, wird der Zeigervariablen der Wert einer Variablen zugewiesen. Dem Zeiger der Zeigervariablen wird die Adresse der Zeigervariable zugewiesen.

Am Ende drucken wir die drei Variablen, die den gleichen Wert 10 anzeigen, der einer ganzzahligen Variablen entspricht.

Zeiger an Funktionen übergeben

Das Übergeben von Zeigern an die Funktion ist dasselbe wie bei anderen Techniken zum Übergeben von Parametern, bei denen Zeigervariablen an die Funktion übergeben werden.

Wir überprüfen unsere beiden Werte erneut und ändern sie, um Zeigervariablen als Parameter zu übergeben.

#include #include using namespace std; void swap(int* a, int* b) { int temp; temp = *a; *a = *b; *b = temp; } int main() { int a, b; cout<>a>>b; cout<<'a = '< Funktionszeiger

Ebenso wie wir Zeiger auf Variablen, Arrays usw. haben, können wir auch Zeiger auf Funktionen haben. Der Unterschied besteht jedoch darin, dass der Funktionszeiger auf den ausführbaren Code und nicht auf Daten wie Variablen oder Arrays zeigt.

Wir nehmen ein Beispiel, um Funktionszeiger zu demonstrieren.

#include #include using namespace std; void displayVal(int a) { printf('Value of a is %d ', a); } int main() { void (*func_ptr)(int) = &displayVal; (*func_ptr)(100); return 0; }

Ausgabe:

Der Wert von a ist 100

beste Website, um kostenlosen Anime zu sehen

Im obigen Programm haben wir eine Funktion 'displayVal', die nur einen an sie übergebenen ganzzahligen Wert druckt. In der Hauptfunktion haben wir einen Funktionszeiger 'func_ptr' definiert, der ein int als Argument verwendet und einen void-Typ zurückgibt.

void (* func_ptr) (int)

Hinweis: Wir müssen den Funktionszeiger in () einschließen. Wenn wir es weglassen, wird es ein Funktionsprototyp.

Wir haben diesem Funktionszeiger die Adresse der Funktion 'displayVal' zugewiesen. Mit diesem Funktionszeiger 'func_ptr' übergeben wir dann den Argumentwert 100, der dem Aufruf von displayVal mit dem Argument 100 entspricht.

Wenn wir nun eine andere Funktion mit demselben Prototyp haben, können wir denselben Funktionszeiger verwenden, indem wir ihm die Adresse der Funktion zuweisen. Dies ist die Hauptverwendung von Funktionszeigern.

Fazit

Hier geht es um die Zeiger, ihre Definitionen und Verwendungen in C ++.

In unserem nächsten Tutorial erfahren Sie mehr über Referenzen in C ++. Referenzen haben auch eine besondere Verwendung in C ++ und werden häufig als Aliase für Variablen verwendet.

=> Klicken Sie hier für die Absolute C ++ - Schulungsserie.

Literatur-Empfehlungen

^