auch noch Senf dazugeb:
Die Funktion :
Assigned(var P: Pointer)
(engl.: to assign = etwas zuweisen) prüft, ob einem Zeiger oder einer Prozedurvariable ein Wert zugewiesen wurde. Wenn Ja, dann liefert sie "True" zurück, sonst "False"
Du kannst sie also benutzen, wenn Du Dich vor dem Zugriff auf einen Zeiger/Prozedurvariable vergewissern möchtest, das der Zeiger auch auf etwas anderes als den von Lucky genannten geschützten Speicherbereich, der "Nil" heißt, zeigt. Ob an der Stelle im Speicher, auf den der Zeiger / die Prozedurvariable zeigt auch etwas sinnvolles/gültiges steht, sagt sie Dir allerdings nicht (Siehe Christians Bemerkung zu Variante 1).
Edit: Beispiel:
Delphi-Quellcode:
type
TMeinZeiger = ^Integer;
// erzeugt einen Zeigertyp, der auf Integervariablen
// zeigen kann er zeigt also immer auf (in 32-bitSystemen)
// auf das erste von 4 Byte in denen Integerwerte abgelegt
// werden. Gibt es eigentlich schon in Delphi und heißt
// "PInteger"
var
A : Integer;
// eine IntegerVariable (eigentlich nichts anderes als
// ein TMeinzeiger, nur das Delphi Dir die "Zeigerarbeit"
// abnimmt
MeinZeiger : TMeinZeiger;
// ein Zeiger vom o.g. Typ
begin
A := 10;
// weist dem Speicherberich, auf den A verweist (referenziert)
// den Wert 10 zu.
MeinZeiger := @A;
// weist dem Pointer "MeinZeiger" die Adresse der Integervariable
// A zu. "MeinZeiger" verweist nun auf den selben Speicherplatz
// wie "A".
// Das "@" Zeichen nennt man in Delphi Adressoperator. Er ist quasi
// die Umkehrung des "^" - Zeichens, welches Zeiger derefferenziert.
// Erklärung:
// Delphi nimmt Dir ja eine Menge Arbeit mit Speicheradressen ab,
// indem es Dir Variablen zur Verfügung stellt, die Du Dir leichter
// merken kannst als Speicheradressen. Immer wenn Du eine solche
// Variable benutzt, dereferenziert Delphi die Variable "heimlich"
// und bezieht daher die Operationen, die Du mit der Variable
// anstellst, auf den Speicher, auf den die Variable zeigt.
// Anders bei Pointern/Zeigern. Dort würde eine Zuweisung der Art:
// "MeinZeiger := 10;" nicht dem Speicherbereich, auf den
// "MeinZeiger" verweist sondern dem Zeiger selbst den Wert 10
// zuweisen, so dass er dann auf das 10. Byte im Speicher zeigt.
// Wenn Du aber einmal - wie in diesem Falle - die Adresse benö-
// tigst, auf die eine Variable (hier "A") zeigt so kannst Du
// Delphi sozusagen daran hindern, die Variable automatisch zu
// derefferenziern, indem Du ihr den @-Operator voranstellst.
// Hui - das war lang...
if Assigned(MeinZeiger)
// liefert in diesem Falle "True"
then MeinZeiger^ := 5;
// weist dem Speicherplatz, auf den "MeinZeiger" verweist den
// Wert 5 zu, d.h. auch A hat jetzt den Wert 5, gerade so,
// als ob Du "A := 5;" geschrieben hättest. Wichtig hier, das
// Dach "^" nach dem Zeigernamen - dieses derefferenziert
// den Zeiger, was nix anderes heißt, als dem Compiler zu
// sagen, das der Wert dem Speicherbereich zugewiesen
// werden soll, auf den MeinZeiger verweist. Ohne das
// Dach "^" hättest Du dem Zeiger die Adresse 5 zugewiesen,
// was dann mit Sicherheit eine ungültige Adresse wäre und
// zu einer Exception führt
MeinZeiger :=
nil;
// wir machen den Zeiger ungültig
if Assigned(MeinZeiger)
// liefert jetzt "False", da der Zeiger auf "nil" zeigt und
then MeinZeiger^ := 30;
// die Wertzuweisung wird nicht ausgeführt, A hat also
// immer noch den Wert 5
end;
is wohl eher ein Mini-Tut als ein Beispiel geworden, da ich selbst aber argen Kummer mit dem Begreifen von Zeigern hatte
, denke ich ist es für NewBees ganz hülfreich.