C ++ Zeiger und Referenz

In C ++ sind sowohl der Zeiger als auch die Referenz zwei leistungsstarke Konzepte. Mit Hilfe von Zeiger und Referenzvariablen können wir problemlos auf unsere normalen Variablen zugreifen. Jetzt diskutieren wir Details über das Konzept des Zeigers und der Referenz.

Zeiger

Zeiger ist eine spezielle Art von Variable. Es speichert die Adresse einer anderen Variablen. Es bedeutet, wenn ein variabler Speicher im Speicher eine bestimmte Adresse erhält. Der Zeiger speichert diese Adresse dieser bestimmten Variablen.

Programmierbeispiel 1

#enthalten
Verwenden von Namespace STD;
int main ()

int x = 15;
int *p; // einen Zeiger deklarieren
p = & x;
Cout<< &x << endl ; // address of x ;
Cout<< p << endl ; // pointing the address of x ;
Cout<< *p << endl ; // Dereferencing of a pointer;
Rückkehr 0;

Ausgang

Erläuterung
Hier deklarieren wir eine Ganzzahlvariable x und innerhalb von x weisen wir 15 zu. Jetzt haben wir eine Ganzzahl -Zeigervariable *p deklariert.

p = & x;

Hier in der Zeigervariablen p weisen wir die Adresse von x zu. Die Adresse von X hängt vollständig von unserem Betriebssystem ab.

Wenn wir & x drucken, wird die Ausgabe der Adresse der Variablen x angezeigt.

Wenn wir P -Variable drucken, wird auch die Ausgabe der Adresse der Variablen x ausgegeben.

Aber wenn wir das *p drucken. Es bedeutet, dass es die Ausgabe des Wertes der x -Variablen erhält.

Programmierbeispiel 2

#enthalten
Verwenden von Namespace STD;
int main ()

float x = 15;
float *p; // einen Zeiger deklarieren
p = & x;
Cout<< &x << endl ; // address of x ;
Cout<< p << endl ; // pointing the address of x ;
Cout<< *p << endl ; // Dereferencing of a pointer;
Rückkehr 0;

Ausgang

Erläuterung
Wenn wir die Schwimmertypvariable x nehmen und einen Wert 1 zuweisen 1.5, dann deklarieren wir einen Zeiger, um die Adresse von X zu halten. Wir müssen einen Schwimmertyp des Zeigers nehmen.

Jeder Zeiger hält die Adresse der Variablen; Beide haben den gleichen Datentyp. Andernfalls tritt ein Fehler auf.

Zeigerarithmetik

In C ++ mit Hilfe des Zeigers haben wir einige arithmetische Operationen wie Inkrement, Dekrement, Addition und Subtraktion durchgeführt.

Programmierbeispiel 3

#enthalten
Verwenden von Namespace STD;
int main ()

int x = 15;
int *p = & x;
Cout<< p << endl ; // address of x ;
P ++; // Erhöhung des Hinweises
Cout<< p << endl ;
Rückkehr 0;

Ausgang

Zeiger und Array

Array nimmt immer in zusammenhängender Weise das Gedächtnis. Wir können ein Array mit Hilfe des Zeigers implementieren. Denn wenn Zeiger inkrementiert ist, weist er immer auf den nächsten Block aus der Basisadresse des Arrays hin. Sowohl Zeiger als auch Array haben den gleichen Datentyp.

Programmierbeispiel 4

#enthalten
Verwenden von Namespace STD;
int main ()

int i;
int arr [] = 5, 10, 15; // ein Array deklarieren;
int *p = arr; // Initialisierung des Wertes von Array zu einem Zeiger;
Cout<< *arr << endl ;
für (i = 0; i < 3 ; i++)

Cout<< *p << endl ;

Rückkehr 0;

Ausgang

Erläuterung
Wir können auf ein Array auf einen Zeiger zugreifen. In diesem Beispiel deklarieren wir einfach ein Array und haben einige Werte initialisiert. Die Grundadresse des Arrays auf einen Zeiger p. Jetzt können wir den Wert jedes Elements des Arrays durch einen Zeiger drucken. Wenn wir den Wert von PTR erhöhen, geht es einfach zum nächsten Block aus der Basisadresse des Arrays.

Referenz

Mit Ausnahme der normalen Variablen und des Zeigers bietet C ++ einen speziellen Typ von Variablen, der als Referenzvariable bezeichnet wird. Jetzt lernen wir die Referenzvariable kennen.

Merkmale der Referenzvariablen

1. Bevor wir eine Referenzvariable deklarieren, schreiben wir einfach '&' Symbol. Viele von uns haben Missverständnisse, dass '&' als Ansprache des Operators behandelt wird. Aber tatsächlich wird es nicht so in Bezug auf die Referenzvariable behandelt.
2. Wenn wir die Referenzvariable zu diesem Zeitpunkt deklarieren, muss die Initialisierung durchgeführt werden. Andernfalls tritt ein Fehler auf.
3. Referenzvariable kann nicht aktualisiert werden.

Beispiel einer Referenzvariablen

int x = 5;

Wenn wir einen alternativen Namen der Variablen X beibehalten möchten, müssen wir dieses Verfahren befolgen.

int & y = a;

Es bedeutet, dass Referenzvariable nur erstellt wird, um die vorhandene Variable im Programm zu verweisen. Mit Hilfe der Referenzvariablen zugreifen wir auf die Variable X.

Programmierbeispiel 5

#enthalten
Verwenden von Namespace STD;
int main ()

int x = 15;
int & y = x;
Cout<< x << “ “ << y << endl ;
++y;
Cout<< x << “ “ << y << endl ;
Rückkehr 0;

Ausgang

Erläuterung
Hier führen wir eine Referenzvariable y ein, die sich auf die Variable x nach der Zeile & y = x bezieht. In x wird 5 zugewiesen. Wenn wir die Variable X und Y drucken möchten, zeigt beide das gleiche Ergebnis 5.

Wenn wir 1 zum Wert von y erhöhen und sowohl die Variable x als auch y drucken, zeigt es das gleiche Ergebnis 6.

Abschluss

Wir sind ausführlich über das Konzept von Zeiger und Referenz diskutiert, wir sind zu dieser Schlussfolgerung gekommen, dass die Adresse das mächtigste Konzept in C ist++. Mit Hilfe von Zeiger und Referenz können wir die Variablen, das Array, die Funktion, die Struktur usw. überwachen. leicht.