was bedeutet ' nil ' ?

[shareholder]

Hallo,

Arbeite erst seit vorgestern mit Delphi und möchte alles wissen.
Habe auch schon im Index der OH gesucht. Dort wird 'nil' aber nicht gefunden !
kann mir bitte jmd kurz erklären, was es damit auf sich hat ?
vielen dank schonmal im vorraus

[Mirilin]

OH :

Zitat:

Das reservierte Wort nil ist eine spezielle Konstante, die jedem Zeiger zugewiesen werden kann. Ein solcher Zeiger verweist dann auf kein bestimmtes Ziel.

[Pyr0cracker]

Ich hab auch noch nicht so viel Ahnung, aber ich glaube nil bedeutet soviel wie 'nix', d.h. wenn man angibt:

Delphi-Quellcode:

var
  test: TImage; //bild
...

test := nil;

Dann belegt 'test' 0 kb Speicher. geht auch für integer, string, etc...

@jemanden-ders-besser-kann: wenn ich was falsches laber bitte korrigieren!

Gruß

[edit=Daniel B]Delphi-Tags korrigiert. Mfg, Daniel B[/edit]

[Marco Haffner]

Du bist der englischen Sprache mächtig? Einfach mal übersetzen, klärt so manches auf.

[edit]Och nö, bin gestört worden...[/edit]

[Christian Seehase]

Moin Shareholder,

nil ist im Prinzip gleich 0, nur für Pointer (Zeiger).
Hat ein Pointer diesen Wert, zeigt er auf nichts, ist also leer.

Das kannst Du z.b. benutzen, um, bei entsprechender Programmierung, festzustellen, ob eine Objektvariable auf ein Objekt zeigt, oder nicht (Objektvariablen enthalten, wenn sie gültig sind, die Adresse des Objektes).

Beispiel (nur um mal zu zeigen, was mich mit "gültig" und was mit "entsprechender Programmierung" meine.)

Delphi-Quellcode:

sl : TStringList;

begin
  sl := TStringList.Create; // Hiermit wird das Objekt erzeugt, 
                            // sl enthält anschliessend die Adresse des Objektes
  try
    // Irgendetwas mit der StringListe machen
  finally
    sl.Free;        // Objekt freigeben, Variante 1
    // oder
    FreeAndNil(sl); // Objekt freigeben, Variante 2
  end;
  if sl = nil then begin
    // wenn auf nichts gezeigt wird, dann
  end else begin
    // ansonsten
  end;
end;

Nach dem Create und vor dem Free bzw. FreeAndNil zeigt sl auf ein gültiges Objekt, in diesem Falle eine StringListe.
Nimmt man Variante 1 um das Objekt wieder freizugeben, so ist sl <> nil, ist aber ungültig, da das Objekt freigegeben wurde.
Bei Variante 2 wird sl auf gleichzeitig auf nil gesetzt, und man kann entscheiden, ob sl auf ein Objekt zeigt oder nicht (entsprechende Programmierung)
Variante 2 könnte man auch schreiben als

Delphi-Quellcode:

sl.Free
sl := nil;

[Christian Seehase]

Moin Pyrocracker,

nicht ganz.
Test selber belegt immer noch vier Byte (ein Pointer ist ja 32 Bit gross), hat aber den Wert 0.

Sollte vor dem test := nil; die Variable auf ein gültiges Objekt gezeigt haben, hast Du damit u.U. sogar ein Speicherleck geschaffen.

[Luckie]

Weiße ich einen Zeiger den Wert nil zu, dann bekomt er intern eine Adresse, die in einem geschützen Adressraum des Prozesses liegt. Jeder Zugriff endet dann mit einer AccessViolation. Somit ist sicher gestellt, dass dieser Zieger nicht zufälligerweise eine gültige Adresse zurück liefert. Grund für diese Vorgehensweise: Man kein einer Variablen nicht nichts zu ordnen. Irgend was muss ich ja angeben und sei es auch nur die Zahl null. Jetzt kann aber die Adress 0 durchaus gültig sein, womit man sein Ziel nicht erreicht hätte den Zeiger führ ungültig zu erklären. Deswegen weißt man ihm eine Adress zu die in einem geschützen Speicherbereich des Prozess liegt. Nach zu lesen in "Windows Programmierung für Experten" von Jeffry Richter Kapitel "Speicherverwaltung".

[Hansa]

Zitat von shareholder:

Arbeite erst seit vorgestern mit Delphi...

Ihr könnt doch den armen Kerl nicht direkt so erschrecken. Mit dem Kram anzufangen, davon ist allerdings auch dringend abzuraten. Soviel im Voraus.

Es geht im Prinzip um Variablen, die halt im Speicher liegen. Nun gibt es Arrays, z.B. var Jahr : array [1..12] of string; Wunderbar geeignet, um die Namen der 12 Monate zu speichern. Es werden nicht weniger und nicht mehr.

Sollte trotzdem mal ein 13. Monat, so wie in Bayern die 5. Jahreszeit dazukommen, so wäre man schon dumm dran. Dies ließe sich wiederum durch ein dynamisches Array realisieren. Das kann man in gewisser Weise anpassen. Glaube bei Stringlisten wird so was verwendet. Das ist aber auch nur so eine halbe Sache. Direkt verwende ich das jedenfalls so nicht.

Intern wird das nämlich durch verkettete Listen/Bäume usw. realisiert. Na gut, kurzes Beispiel :

Delphi-Quellcode:

PROCEDURE l_loeschen;
  BEGIN   
    liste := ende;
    WHILE liste <> NIL DO BEGIN
      dispose (liste);
      liste := liste^.naechst;
    END;
  END;

So kann man eine Liste wieder löschen. Ich gehe da ans ende und lösche die Elemente so lange bis ich auf nil treffe. Stelle dir vor, du hast einen Stapel mit Desserttellern und mußt die einen nach dem anderen wegräumen. Du fängst also oben an und stellst sie nacheinander in einen Schrank. Solange bis nur noch der Tisch da ist und kein Teller mehr, das wäre dann nil. Mit new müßtest du die Teller vorher irgendwann aber aus dem Schrank geholt haben. Ähhm, ja so ungefähr läuft das. 8)

Und mit dem Speicherbereich, das sollte vorerst egal sein. Wobei mich allerdings wundert, daß hierzu keine vordefiniert Konstante verwendet wird, die beim Start von Delphi gesetzt wird, so daß man sie nicht einfach so überscheiben kann.

[Leuselator]

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.

[Pseudemys Nelsoni]

NIL = Not In List


soviel weiss ich ^^