Die Verbindung und der Unterschied zwischen Referenz und Zeiger in C / C ++
Warum sollten Zeiger in C / C ++ verwendet werden?
1. Jede Programmiersprache verwendet Zeiger. C ++ macht Zeiger für Benutzer (Programmierer) verfügbar, während Sprachen wie JAVA und C # Zeiger ausblenden.
2. Der Zeiger kann die Datenstruktur effektiv darstellen.
3. Kann dynamisch Speicher zuweisen, um eine freie Speicherverwaltung zu erreichen.
4. Bequeme Verwendung von Zeichenfolgen und effiziente Verwendung von Arrays.
5. Der Zeiger steht in direktem Zusammenhang mit der Speicheradresse der Daten, z. B.: Die Wertübertragung ist nicht so gut wie die Adressübertragung Effizient, da bei der Wertübertragung zuerst der Wert von der Adresse des Aktualparameters übernommen und dann der Wert dem Formalparameter in die Funktionsberechnung zugewiesen wird und der Zeiger die Adresse des Formalparameters direkt auf die Aktualparameteradresse verweist und die Daten bei Verwendung direkt abruft, wird die Effizienz verbessert, insbesondere bei häufiger Zuweisung In anderen Fällen (Hinweis: Die Änderung der formalen Parameter wirkt sich auf die tatsächlichen Parameter aus!)
Der Unterschied zwischen Referenz und Zeiger?
Zuerst mit den klaren Worten der Einleitung:
Zeiger - für einen Typ T, T ein Zeigertyp T ist, das ein T ist vom Typ Variable kann die Adresse eines Objekts T halten, und T ist der Typ Sie einige Qualifier hinzufügen können, Wie const, flüchtig usw. In der folgenden Abbildung ist die Bedeutung des Zeigers dargestellt:
Referenz - Referenz ist ein Alias eines Objekts, der hauptsächlich für Funktionsparameter und Rückgabewerttypen verwendet wird. Das Symbol X & gibt eine Referenz vom Typ X an. Siehe die folgende Abbildung, die Bedeutung der angezeigten Anführungszeichen:
- Der Zeiger kann den Wert ändern, auf den die Adresse zeigt, er kann auch auf andere Adressen verweisen, und die Referenz zeigt immer auf das bei der Initialisierung angegebene Objekt , kann jedoch den Wert des Objekts ändern
- Unter dem Gesichtspunkt der Speicherzuweisung weist das Programm den Speicherbereich für die Zeigervariable zu, jedoch nicht für die Referenz , da die Referenz bei der Deklaration initialisiert werden muss, um auf ein vorhandenes Objekt zu verweisen. Referenzen können nicht auf Nullwerte verweisen.
- Aus Sicht der Kompilierung fügt das Programm während der Kompilierung Zeiger und Verweise auf die Symboltabelle hinzu, und die Symboltabelle zeichnet den Variablennamen und die der Variablen entsprechende Adresse auf. Der entsprechende Adresswert der Zeigervariable in der Symboltabelle ist der Adresswert der Zeigervariable , und der entsprechende Adresswert der Referenz in der Symboltabelle ist der Adresswert des Referenzobjekts . Nachdem die Symboltabelle generiert wurde, wird sie nicht mehr geändert, sodass der Zeiger das Objekt ändern kann, auf das verwiesen wird (der Wert in der Zeigervariable kann geändert werden), und das referenzierte Objekt kann nicht geändert werden. Dies ist der Hauptgrund, warum die Verwendung von Zeigern unsicher ist und die Referenzsicherheit verwendet wird. In gewissem Sinne kann eine Referenz als Zeiger betrachtet werden, der die Adresse nicht ändern kann.
- Die Tatsache, dass es keine Verweise auf Nullwerte gibt, bedeutet, dass der Code, der Verweise verwendet, effizienter ist als die Verwendung von Zeigern. Weil Sie die Gültigkeit der Referenz nicht testen müssen, bevor Sie sie verwenden. Stattdessen sollten Zeiger immer getestet werden, um zu verhindern, dass sie leer sind.
- Theoretisch gibt es keine Begrenzung für die Anzahl der Zeigerebenen, aber die Referenz kann nur eine Ebene sein . Wie folgt:
int ** p1; // legal. Zeiger auf Zeiger
int * & p2; // legal. Verweis auf Zeiger
int & * p3; // Illegal. Der Zeiger auf die Referenz ist unzulässig
int && p4; // unzulässig. Verweise auf Verweise sind unzulässig.
Beachten Sie, dass die obige Lesart von links nach rechts erfolgt .
Kurz gesagt kann geschlossen werden, dass "ein Zeiger auf ein Stück Speicher zeigt und sein Inhalt die Adresse des Speichers ist, auf den verwiesen wird; und eine Referenz ein Alias eines bestimmten Gedächtnisses ist und die Referenz das Zeigen nicht ändert ."
Spezielle Konst
int main()
{
int i= 0;
int j=1;
//常量引用，指向的地址的内容是个常量，不可以修改，即i的值不可以修改
const int &r = i ;
//常量指针,p指针的地址可修改，但无法修改指向地址的内容，*p不可修改，即p指针不可以修改j的值，但可以指向i的地址
const int* p=&j;
p = &i;
//指针常量，q指向的地址不可修改，可以修改指向地址的内容，*q可以修改，即q指针只能指向j的地址，但可以修改j的值
int* const q = &j;
*q=5;
//常量指针常量，w指向的地址和内容都不可修改，即w和*w均不可修改
const int* const w = &j;
cout<<j<<endl;
cout<<i<<endl;
return 0;
}
Zeigerübergabe und Referenzübergabe
- Der Zeigerübertragungsparameter ist im Wesentlichen eine Art der Wertübertragung, was er übergibt, ist ein Adresswert. Bei der Wertübertragung werden die formalen Parameter der aufgerufenen Funktion als lokale Variablen der aufgerufenen Funktion behandelt, dh der Speicherplatz auf dem Stapel wird geöffnet, um den Wert des von der Hauptaufruffunktion eingegebenen Aktualparameters zu speichern, wodurch eine Kopie des Aktualparameters wird . Das Merkmal der Wertübertragung ist, dass jede Operation der aufgerufenen Funktion an den formalen Parametern als lokale Variable ausgeführt wird , die den Wert der tatsächlichen Parametervariablen der aufrufenden Funktion nicht beeinflusst.
- Während der Referenzübergabe öffnen die formalen Parameter der aufgerufenen Funktion auch Speicherplatz auf dem Stapel als lokale Variablen, aber zu diesem Zeitpunkt wird die Adresse der tatsächlichen Parametervariablen gespeichert, die von der aufrufenden Funktion eingegeben wird. Ist ein beliebiger Betriebsparameter der Modulationsfunktionen behandelt wird als indirekte Adressierung , das hieß durch die Variable - Adresse in dem Stapel abgelegt das Argument in der rufenden Funktion zuzugreifen . Aus diesem Grund wirkt sich jede Operation der aufgerufenen Funktion auf die formalen Parameter auf die tatsächlichen Parametervariablen in der aufrufenden Funktion aus .
Referenzübergabe und Zeigerübergabe sind unterschiedlich. Obwohl es sich bei allen um lokale Variablen im Stapelbereich der aufgerufenen Funktion handelt, wird die Verarbeitung von Referenzparametern für die zugehörigen Variablen in der aufrufenden Funktion über eine indirekte Adressierungsmethode ausgeführt. Wenn für die vom Zeiger übergebenen Parameter die Zeigeradresse in der aufgerufenen Funktion geändert wird, hat dies keine Auswirkungen auf die zugehörigen Variablen der aufrufenden Funktion. Wenn Sie die relevanten Variablen in der aufrufenden Funktion durch Übergabe von Zeigerparametern ändern möchten, müssen Sie einen Zeiger auf einen Zeiger oder eine Zeigerreferenz verwenden .
Zusammenfassung
Fassen Sie abschließend die Ähnlichkeiten und Unterschiede zwischen Zeigern und Referenzen zusammen:
★ Ähnlichkeiten:
- Alle sind Konzepte von Adressen, ein
Zeiger zeigt auf ein Stück Gedächtnis, und sein Inhalt ist die Adresse des Speichers, auf das verwiesen wird, und eine Referenz ist ein Alias eines Stückes Gedächtnis.
★ Unterschiede: - Der Zeiger ist eine Entität, und die Referenz ist nur ein einzelner Name.
- Referenzen können zum Zeitpunkt der Definition nur einmal initialisiert und dann unveränderlich sein; Zeiger sind variabel; Referenzen "von einem zum anderen", Zeiger können "anders denken";
- Referenzen haben keine const, Zeiger haben const und const-Zeiger sind unveränderlich,
insbesondere gibt es keine Form wie int & const a, und const int & a existiert. In dieser Form kann der Wert der letztgenannten Richtlinie nicht geändert werden. - Die Referenz kann nicht null sein, der Zeiger kann null sein;
- "Referenzgröße" ist die Größe der Variablen (Objekt), auf die gezeigt wird, und "Zeigergröße" ist die Größe des Zeigers selbst 4
- Die Bedeutung der Zeiger- und Referenzinkrementoperation (++) ist unterschiedlich.
- Referenzen sind typsicher und Zeiger nicht (Referenzen haben mehr Typprüfungen als Zeiger)
