Was sind die Zeiger in C ++?
Verweist auf das mächtigste Tool in c ++, hilft es dem Programmierer, direkt auf den Speicher zuzugreifen und diesen zu bearbeiten. Wenn zum Beispiel eine Variable erstellt wird, besteht die Aufgabe des Compilers darin, eine Speicherzuweisung vorzunehmen, um den Wert der Variablen zu speichern. Und dieser Wert wird unter Verwendung des den Daten zugewiesenen Variablennamens abgerufen. C ++ bietet die Kompatibilität zum Speichern und Abrufen der Daten aus dem Speicher unter Bezugnahme auf die Adresse des Speicherorts, an dem die Daten gespeichert sind. C ++ führt sogar Zeiger auf einen Zeiger aus.
Syntax
Das allgemeine Format der Zeigerdeklaration lautet:
Data_type * pointer -variable-name
Beachten Sie, dass der Zeigervariable ein Sternchen (*) vorangestellt werden muss.
Beispiel: int * xptr;
Die Variable xptr ist ein Zeiger auf eine Ganzzahl. Im Allgemeinen können Zeigervariablen auf Ganzzahlvariablen, Zeichenvariablen, Arrays, Dateien und Funktionen verweisen.
Warum brauchen wir Zeiger in C ++?
Die dynamische Speicherzuweisung wird in C ++ mithilfe von Zeigern vereinfacht. Das Wichtigste an Zeigern ist, dass sie die verschiedenen Datentypen effizient handhaben. Sie erhöhen die Ausführungsgeschwindigkeit, wenn die Funktion einen Wert zurückgibt, und geben Hand in den Zugriff auf eine Variable, die außerhalb der Funktion definiert ist. Die häufigste Verwendung umfasst die Datenverwaltung und den Zugriff auf Klassenmitgliederfunktionen.
Wie erstelle ich Zeiger in C ++?
Hier sind die folgenden Schritte zum Erstellen von Zeigern in C ++
Schritt 1 - Initialisierung der Zeiger
Es ist ratsam, Zeigervariablen zu initialisieren, sobald sie deklariert sind. Da Zeigervariablen Adressen speichern, können sie jeden Teil des Speichers adressieren.
int *a; // pointer to an integer
double *da; // pointer to a double
float *fa; // pointer to afloat
char *ch // character pointer
Betrachten Sie das folgende Beispiel:
int p, * pi; // Diese Anweisung weist den Compiler an, ein Leerzeichen für die Variable p im Speicher zu reservieren, um einen ganzzahligen Wert aufzunehmen.
pi = & a; // Weist der Zeigervariable die Adresse der Integer-Variablen p zu. Wenn zum Beispiel die Adresse von p 4581 ist, ist der Wert in * pi gleich 4581.
Schritt 2 - Zeiger ungültig
Hier darf die Zeigervariable auf einen beliebigen Datentyp verweisen, und dieser Typ wird beim Übergeben von Zeigern verwendet, um Funktionen auszuführen, die unabhängig vom Datentyp sind, auf den verwiesen wird.
Syntax: void * Zeigervariable;
Beispiel:
#include
#include
using namespace std;
int main ()
(
int x, *iv;
float f, *fv;
void *vp;
x=3;
f=45.2;
iv=&x;
fv=&f;
vp=&x;
cout<< "the value pointed by iv is "<<*iv<< endl;
cout<< "The address of x is "< cout<< "the value pointed by fv is "<<*fv<< endl;
cout<< "The address of f is "< cout<< "The address of x is "< vp= &f;
cout<< "the address of f is "< )#include
#include
using namespace std;
int main ()
(
int x, *iv;
float f, *fv;
void *vp;
x=3;
f=45.2;
iv=&x;
fv=&f;
vp=&x;
cout<< "the value pointed by iv is "<<*iv<< endl;
cout<< "The address of x is "< cout<< "the value pointed by fv is "<<*fv<< endl;
cout<< "The address of f is "< cout<< "The address of x is "< vp= &f;
cout<< "the address of f is "< )#include
#include
using namespace std;
int main ()
(
int x, *iv;
float f, *fv;
void *vp;
x=3;
f=45.2;
iv=&x;
fv=&f;
vp=&x;
cout<< "the value pointed by iv is "<<*iv<< endl;
cout<< "The address of x is "< cout<< "the value pointed by fv is "<<*fv<< endl;
cout<< "The address of f is "< cout<< "The address of x is "< vp= &f;
cout<< "the address of f is "< )#include
#include
using namespace std;
int main ()
(
int x, *iv;
float f, *fv;
void *vp;
x=3;
f=45.2;
iv=&x;
fv=&f;
vp=&x;
cout<< "the value pointed by iv is "<<*iv<< endl;
cout<< "The address of x is "< cout<< "the value pointed by fv is "<<*fv<< endl;
cout<< "The address of f is "< cout<< "The address of x is "< vp= &f;
cout<< "the address of f is "< )#include
#include
using namespace std;
int main ()
(
int x, *iv;
float f, *fv;
void *vp;
x=3;
f=45.2;
iv=&x;
fv=&f;
vp=&x;
cout<< "the value pointed by iv is "<<*iv<< endl;
cout<< "The address of x is "< cout<< "the value pointed by fv is "<<*fv<< endl;
cout<< "The address of f is "< cout<< "The address of x is "< vp= &f;
cout<< "the address of f is "< )
Ausgabe:
$ g ++ -o main * .cpp
$ main
Der Wert, auf den iv zeigt, ist 3
Die Adresse von x lautet 0x7ffefbbee6d4
Der Wert, auf den fv zeigt, ist 45, 2
Die Adresse von f lautet 0x7ffefbbee6d0
Die Adresse von x lautet 0x7ffefbbee6d4
Die Adresse von f lautet 0x7ffefbbee6d0
Schritt 3 - Zeiger Arithmetische Operationen in C ++
Die Zeigerarithmetik wird mit Arrays durchgeführt. Die folgenden Vorgänge können mit Zeigern ausgeführt werden. Sie sind:
- Inkrement (++)
- Dekrement (-)
- Zeigerzusatz
- Zeigersubtraktion
Wenn wir dem Zeiger eine 1 hinzufügen, wird die Größe des Zeigers angegeben, auf den der Zeiger zeigt.
Das folgende Programm gibt die Zeigerarithmetik an, die ausgeführt wird, bis das Ende des Arrays erreicht ist.
#include
#include
using namespace std;
void pointerarithmetic(int a(), int size)
(
int *e, *t; //Declaring two int pointers variables
e = a; //assigning e to point the arrays initial element a(0) t = a + size; // assigning variable t to the array last element
while(e != t)
(
cout << *e << endl; //displays the e
e++; // incrementing ( next element)
)
)
int main()
(
int a() = (2, 4, 6, 8, 10, 12, 14, 16, 18, 20);
pointerarithmetic (a, 20);
return 0;
)
Ausgabe:
$ g ++ -o main * .cpp
$ main
2
4
6
8
10
12
14
16
18
20
0
0
4196480
0
-1743362854
32686
1
0
153860328
32766
Schritt 4 - Zeiger auf Zeiger
float ** fpp;
Es kennzeichnet zwei Ebenen von Zeigern ( Multiple Indirektionen ). Es ist eine Variable, die auf einen anderen Zeiger zeigt, der weiter auf ein Objekt zeigt, das an einem Speicherort angegeben ist. Beispielsweise ist fpp ein Gleitkommazeiger, der aktuell auf die Speicheradresse 2001 zeigt, die Größe des Gleitkommas beträgt 8 Bytes und dann by
fpp ++;
Gibt an, dass fpp auf Adresse 2009 verweist. Wenn die Variable um 1 dekrementiert wird, verweist sie auf die vorherige Position ihres Basistyps unter Adresse 1993.
Schritt 5 - Zeiger auf Funktionen
Wenn Zeiger als Argumente an eine Funktion übergeben werden, werden die mit dieser Zeigervariablen verknüpften Datenelemente innerhalb der Funktion geändert und dann an das aufrufende Programm zurückgegeben. Die Änderungen werden im aufrufenden Programm beibehalten. Wenn ein Zeiger als Parameter übergeben wird, werden die entsprechenden Datenelemente innerhalb der aufgerufenen Funktion global geändert. Der Zeiger wird als Referenz übergeben. Funktionen können auf verschiedene Arten in Zeigern ausgeführt werden:
- Die Funktion, die durch die Übergabe der Referenz aufgerufen wird
- Die Funktion, die durch die Übergabe eines Zeigers aufgerufen wird
Die Funktion, die durch Übergabe der Referenz aufgerufen wird
Dabei wird die Adresse als Argument anstelle von Werten übergeben.
Beispiel:
#include
using namespace std;
void changefn(int*, int*);
int main()
(
int n = 5, m = 6;
cout << "Before change" << endl;
cout << "n = " << n << endl;
cout << "m = " << m << endl;
changefn(&n, &m);
cout << "\nAfter change" << endl;
cout << "n = " << n << endl;
cout << "m = " << m << endl;
return 0;
)
void changefn(int* x1, int* x2) (
int s1;
s1 = *x1;
*x1 = *x2;
*x2 = s1;
)
Ausgabe:
$ g ++ -o main * .cpp
$ main
Vor dem Wechsel
n = 5
m = 6
Nach der veränderung
n = 6
m = 5
Fazit
In diesem Artikel sollte anhand eines Beispiels das Wissen über die Verwendung von Zeigern in C ++ und ihre grundlegenden Themen auf einfache Weise aktualisiert werden. Zeiger wird auch als Locator bezeichnet und reduziert die Code-Anweisung, um eine höhere Leistung zu erzielen. Zeiger spielen eine wichtige Rolle bei der Implementierung von Datenstrukturen wie verknüpften Listen und Programmierung auf Systemebene. Sie sind die bevorzugte Sprache in eingebetteten Systemen, da sie eine gute Möglichkeit sind, mit Zeigern direkt auf den Speicher zuzugreifen.
Empfohlene Artikel
Dies ist eine Anleitung zu Zeigern in C ++. Hier besprechen wir, wie man Zeiger in C ++ mit den angegebenen Beispielen und Ausgaben erstellt und warum wir sie brauchen. Sie können sich auch den folgenden Kurs zur Datenanalyse ansehen, um mehr zu erfahren
- Zeiger in Python
- Datentypen in C
- Arrays in C ++
- Sternchenmuster In c ++
- Wie funktionieren Zeiger in C #?