C++ Hinweise mit Beispielen

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

Adressen in C++

Verstehen C++ Zeiger müssen Sie verstehen, wie Computer Daten speichern.

Wenn Sie eine Variable in Ihrem C++ Programm wird ihm ein Speicherplatz im Computerspeicher zugewiesen. Der Wert dieser Variable wird am zugewiesenen Speicherort gespeichert.

Um den Speicherort der Daten im Computerspeicher zu kennen, C++ bietet die & (Referenz-)Operator. Der Operator gibt die Adresse zurück, die eine Variable einnimmt.

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

Syntax der Zeigerdeklaration

Die Erklärung von C++ hat die folgende Syntax:

datatype *variable_name; 

• Der Datentyp ist der Basistyp des Zeigers, der ein gültiger C++ Datentyp.
• Der Variablenname sollte der Name der Zeigervariablen sein.
• Das oben zur Zeigerdeklaration verwendete Sternchen ähnelt dem Sternchen, das zur Durchführung einer Multiplikationsoperation verwendet wird. Es ist das Sternchen, das die Variable als Zeiger kennzeichnet.

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

int    *x;    // a pointer to integer
double *x;    // a pointer to double
float  *x;    // a pointer to float
char   *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.

Beispielsweise:

Wenn wir eine Variable mit dem Namen num haben, wird sie an der Adresse 0x234 gespeichert und speichert den Wert 28.

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

Der Dereferenzierungsoperator (*) gibt 5 zurück.

Beispiel 1:

#include <iostream>
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;
}

Ausgang:

Wie das funktioniert:

Hier ist ein Screenshot des Codes:

Code-Erklärung:

1. Importieren Sie die iostream-Headerdatei. Dadurch können wir die in der Header-Datei definierten Funktionen verwenden, ohne dass Fehler auftreten.
2. Schließen Sie den std-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 Anfang des Funktionskörpers.
4. Deklarieren Sie eine ganzzahlige Variable 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 einen Text auf der Konsole.
8. Geben Sie den Wert der Variablen x auf dem Bildschirm aus.
9. Drucken Sie einen Text auf der Konsole.
10. Geben Sie die Adresse der Variablen x aus. Der Wert der Adresse wurde in der Variablen ip gespeichert.
11. Drucken Sie einen Text auf der Konsole.
12. Druckwert, der an der Adresse des Zeigers gespeichert ist.
13. Das Programm sollte bei erfolgreicher Ausführung einen Wert zurückgeben.
14. Ende des Hauptteils 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 Array-Name selbst bezeichnet die Basisadresse des Arrays. Das bedeutet, dass Sie zum Zuweisen der Adresse eines Arrays zu einem Zeiger kein kaufmännisches Und-Zeichen (&) verwenden sollten.

Beispielsweise:

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 umwandeln. Zum Beispiel:

int arr [20];
int * ip;

Unten sehen Sie eine gültige Operation:

ip = arr;

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

Beispiel 2:

Dieses Beispiel zeigt, wie man ein Array mithilfe von Zeigern durchläuft:

#include <iostream>
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;
}

Ausgang:

Hier ist ein Screenshot des Codes:

Code-Erklärung:

1. Deklarieren Sie eine ganzzahlige Zeigervariable ip.
2. Deklarieren Sie ein Array mit dem Namen arr und speichern Sie darin 6 Ganzzahlen.
3. Weisen Sie arr der 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. Druckt die Werte, die an der Adresse des Zeigers IP gespeichert sind. Pro Iteration wird ein Wert zurückgegeben und insgesamt werden 6 Wiederholungen durchgeführt. Das Endl ist ein C++ Schlüsselwort, das die Endzeile bezeichnet. Mit dieser Aktion können Sie den Cursor nach dem Drucken jedes Werts in die nächste Zeile verschieben. Jeder Wert wird in einer eigenen Zeile gedruckt.
6. Um den Zeiger nach jeder Iteration auf die nächste int-Position zu bewegen.
7. Ende der for-Schleife.
8. Das Programm muss bei erfolgreicher Ausführung etwas zurückgeben.
9. Ende des main()-Funktionskö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 wird als Nullzeiger bezeichnet. Sein Wert ist Null und ist in vielen Standardbibliotheken wie iostream definiert.

Beispiel 3:

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

Ausgang:

Hier ist ein Screenshot des Codes:

Code-Erklärung:

1. Deklarieren Sie eine Zeigervariable ip und weisen Sie ihr den Wert NULL zu.
2. Gibt den Wert der Zeigervariablen „ip“ zusammen mit etwas Text auf der Konsole aus.
3. Das Programm muss bei erfolgreichem Abschluss einen Wert zurückgeben.
4. Ende des Hauptteils der main()-Funktion.

Zeiger von Variablen

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

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

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

Es kann wie folgt deklariert werden:

int *p;

Oder,

int* p;

Im you-Beispiel haben wir die Zeigervariable p deklariert.

Es enthält eine Speicheradresse.

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

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

Beispiel 4:

#include <iostream>

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

Ausgang:

Hier ist ein Screenshot des Codes:

Code-Erklärung:

1. Deklarieren Sie eine Zeigervariable p und eine Variable x mit dem Wert 30.
2. Weisen Sie p die Adresse der Variablen x zu.
3. Geben Sie den Wert der Zeigervariablen p zusammen mit etwas Text auf der Konsole aus.
4. Das Programm muss bei erfolgreichem Abschluss einen Wert zurückgeben.
5. Ende des Hauptteils der main()-Funktion.

Anwendung von Zeigern

Funktionen in C++ kann nur einen Wert zurückgeben. Außerdem werden alle in einer Funktion deklarierten Variablen auf dem Funktionsaufrufstapel zugewiesen. Sobald die Funktion zurückkehrt, werden alle Stapelvariablen zerstört.

Argumente an Funktionen werden als Wert übergeben, und jede Änderung an den Variablen ändert nicht den Wert der tatsächlich übergebenen Variablen. Das folgende Beispiel veranschaulicht dieses Konzept:

Beispiel 5:

#include <iostream>

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;
}

Ausgang:

Hier ist ein Screenshot des Codes:

Code-Erklärung:

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 seinen Körper einfügen.
3. Deklarieren Sie zwei ganzzahlige Variablen a und b mit jeweils dem Wert 5.
4. Drucken Sie einen Text auf der Konsole. Mit endl (Endzeile) wird der Cursor bewegt, um mit dem Drucken in der nächsten Zeile zu beginnen.
5. Geben Sie den Wert der Variablen a zusammen mit anderem Text auf der Konsole aus. Mit endl (Endzeile) wird der Cursor bewegt, um mit dem Drucken in der nächsten Zeile zu beginnen.
6. Geben Sie den Wert der Variablen b zusammen mit anderem Text auf der Konsole aus. Mit endl (Endzeile) wird der Cursor bewegt, um mit dem Drucken in der nächsten Zeile zu beginnen.
7. Erstellen Sie eine Funktion namens test(), die die Adressen der Variablen a und b als Parameter übernimmt.
8. Drucken Sie einen Text auf der Konsole. Das \n erstellt eine neue Leerzeile, bevor der Text gedruckt wird. Mit endl (Endzeile) wird der Cursor bewegt, um in der nächsten Zeile nach dem Drucken des Textes mit dem Drucken zu beginnen.
9. Geben Sie den Wert der Variablen a zusammen mit anderem Text auf der Konsole aus. Mit endl (Endzeile) wird der Cursor bewegt, um mit dem Drucken in der nächsten Zeile zu beginnen.
10. Geben Sie den Wert der Variablen b zusammen mit anderem Text auf der Konsole aus. Mit endl (Endzeile) wird der Cursor bewegt, um mit dem Drucken in der nächsten Zeile zu beginnen.
11. Das Programm muss bei erfolgreichem Abschluss einen Wert zurückgeben.
12. Ende des Hauptteils der main()-Funktion.
13. Definieren der Funktion test(). Die Funktion sollte zwei ganzzahlige Zeigervariablen *n1 und *n2 annehmen.
14. Weisen Sie der Zeigervariablen *n1 den Wert 10 zu.
15. Weisen Sie der Zeigervariablen *n2 den Wert 11 zu.
16. Ende des Hauptteils der Funktion test().

Obwohl den Variablen a und b innerhalb des Funktionstests neue Werte zugewiesen werden, werden diese nach Abschluss des Funktionsaufrufs nicht in der äußeren Funktion main widergespiegelt.

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 widergespiegelt.

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, und daher werden alle an diesen Variablen vorgenommenen Änderungen in der aufrufenden Funktion „main“ widergespiegelt.

Vorteile der Verwendung von Zeigern

Hier sind die Vorteile/Vorteile der Verwendung von Zeigern aufgeführt

• Zeiger sind Variablen, die die Adresse anderer speichern Variablen in C++.
• Mithilfe von Zeigern kann eine Funktion mehrere Variablen ändern und zurückgeben.
• Speicher kann mithilfe von Zeigern dynamisch zugewiesen und freigegeben werden.
• Zeiger helfen dabei, die Komplexität des Programms zu vereinfachen.
• Die Ausführungsgeschwindigkeit eines Programms verbessert sich durch die Verwendung von Zeigern.

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.
• Zeiger ermöglichen es Programmen, Call-by-Reference zu simulieren und dynamische Datenstrukturen zu erstellen und zu manipulieren.
• Arrays und Zeiger verwenden ein verwandtes Konzept.
• Der Array-Name bezeichnet die Basis des Arrays.
• Wenn Sie die Adresse eines Arrays einem Zeiger zuweisen möchten, verwenden Sie kein kaufmännisches Und (&).
• Wenn es keine spezifische Adresse zum Zuweisen einer Zeigervariablen gibt, weisen Sie ihr einen NULL-Wert zu.