Der unäre Präfixoperator & liefert, wenn er auf ein Objekt angewendet wird, die Adresse von Objekt: &obj .
Der Modifizierer type & ändert den Typ der Variablen, wenn sie auf eine deklarierte Variable angewendet wird, als Referenztyp : int& .
Dasselbe gilt für * : Wird es als unärer Präfixoperator auf einen Zeiger angewendet, wird dereferenziert Der Zeiger, der das Objekt liefert, auf das verwiesen wird: *ptr .
Bei Verwendung als Typ-Modifizierer für eine Variable, die deklariert werden soll, ändert * den Typ als -Zeiger : int* .
Auf ähnliche Weise wird der Modifizierer type [] , der auf eine deklarierte Variable angewendet wird, den Typ der Variablen in ein Array ändern, während < em> binärer Infixoperator [] wird auf ein Objekt vom Typ Array angewendet und greift auf eines der Unterobjekte des Arrays zu.
Es ist nicht hilfreich, dass type-Modifizierer auf die Variable angewendet werden, die deklariert ist, und nicht auf den Typ, mit dem sie deklariert werden. Zum Beispiel das
%Vor% definiert einen int -Zeiger, einen Zeiger auf einen Zeiger auf ein int , ein vanilla int , ein Array von 10 int und ein int reference. (Letzteres wird sofort initialisiert, da Sie keinen nicht initialisierten Verweis haben können.) Beachten Sie, dass die -Typ-Modifikatoren syntaktisch zu der deklarierten Variablen gehören, deren Typ sie ändern, nicht zu Typ der angegebenen Variablen Die Modifikatoren type ( * und & ) ändern jedoch den -Typ der Variablen.
Im folgenden Fall wird jedoch mit p , i und a angenommen, dass es sich um Variablen handelt, die bereits deklariert wurden
* und & sind unäre Präfixoperatoren, die den Wert von pp dereferenzieren und die Adresse von i liefern, während [] das erste int -Objekt im Array a liefert.
Die Tatsache, dass C und C ++ die Whitespaces um Typ-Modifikatoren nicht kümmern und das führte zu verschiedenen Lagern, wenn es dazu kommt sie zu platzieren, macht die Dinge nicht wirklich einfacher Einige Leute platzieren die Typ-Modifikatoren nahe am Typ. Sie argumentieren, dass es den Typ ändert und so sollte es gehen:
%Vor%Der Nachteil ist, dass dies beim Deklarieren mehrerer Objekte verwirrend wird. Das
%Vor% definiert a als einen Zeiger auf int , aber b als int . Deshalb schreiben manche Leute lieber
Ich schlage vor, einfach niemals mehrere Objekte in derselben Anweisung zu deklarieren. IMO, das den Code leichter lesbar macht. Außerdem lässt es Sie frei, um eine Konvention auszuwählen.
Um die Dinge noch weiter zu komplizieren, gibt es neben den Typ-Modifikatoren und den unären Präfixoperatoren & und * auch die binäre Infixoperatoren & und * , was "bitweise UND" und "Multiplikation" bedeutet. Und um die Verletzung zu beleidigen, können Sie in C ++ überladen sowohl die unäre Präfix und die binäre Infix Varianten dieser Operatoren (und die binäre Infix [] ) für benutzerdefinierte Typen und bezüglich ihrer Semantik völlig frei sein.
MyType & amp; stellt eine / Referenz /, ein ganz anderes Biest zu Zeigern. Wenn dein Funktionsprototyp
wäreFunktion (MyType);
Sie würden mit einer Kopie des Arguments innerhalb der Funktion arbeiten. Mit
func (MyType & amp;;);
Sie arbeiten mit dem Objekt selbst (d. h. demselben Objekt sowohl im aufrufenden als auch im aufgerufenen Bereich). Es ist in diesem Fall, wie mit einem Zeiger zu arbeiten, aber mit der gleichen "Punkt" -Syntax wie für Objekte.
Natürlich ist das eine oberflächliche und simple Erklärung. Für mich fasste das Erfassen der tiefen Zens unterhalb von Zeigern, Referenzen und dem Rest der Horde Jahre.