Objekt auf Übergabe prüfen.

[Popov]

@Aphton

Zitat:

Kommt drauf an, was du mit Fehlermeldung meinst:
a. Exception
b. Rückgabewert = NIL

Das ist es ja, es ist vorerst ein konstruiertes Beispiel. Wäre der Rückgabewert NIL, müsste man den nicht vorher zuweisen. Exception? Kann sein, vermutlich, aber entweder man überprüft jedes mal vorher individuell was zurück kommen könnte, oder man ist auf alles vorbereitet.

@himitsu

Delphi-Quellcode:

..
  Result := sl.Objects[Index]; // bei einer Execptiopn wird Result zwar nicht überschrieben, aber dann werden die nächsten Zeilen eh nicht ausgeführt

Ich gebe zu, im Grunde ein Sicherheitsfanatiker zu sein, der die Hälfte der Zeit an einem Programm damit verbringt Fehler abzufangen noch bevor sie eine Exception auslösen. Somit fühle ich mich unwohl bei dem Gedanken eine Zeile ins offene Messer laufen zu lassen, in der Annahme, dass es nicht treffen wird, da es darüberfliegt.

@Sir Rufo

Lassen wir mal sl.OwnsObjects außen vorweg, dazu komme ich gleich.

Assigned war auch meine erste Idee, hab es dann aber verworfen, denn entweder ich hab einen Gedankenfehler oder ...

Delphi-Quellcode:

  if o <> nil then ...

//und

  if Assigned(o) then ...

Also entweder ich verstehe Assigned falsch oder es ist das Gleiche.

Wenn ich nun das mache

Delphi-Quellcode:

var
  o: TObject;
begin

dann hat o irgendeinen Wert, ist somit nicht NIL, aber Assigned gleich True, womit eine Abfrage ein falsches Ergebnis liefern würde.

Entweder ich sehe das falsch oder eine frische Objektvariable kann nicht mit NIL oder Assigned geprüft werden.

Somit wäre bei Result := sl.Objects[Index]; Result unkontrolliert, denn entweder wird ein Objekt zugewiesen oder kein Wert übergeben. In dem Fall ist der Wert wie vor der Zeile. Womit wir dann zu himitsus und deinem Vorschlag kommen - knallt es schon in der Zeile sl.Objects[Index] , kann man danach auf jegliche Überprüfung verzichten, denn an der Stelle bricht die Funktion ab. Wie gesagt, ich hab nichts dagegen, nur will ich keine zwei gleiche Fehlermeldungen nacheinander.

Zu sl.OwnsObjects . In Delphi 7 gibt es die noch nicht. Gehe ich richtig in der Annahme, dass inzwischen die Objekte automatisch freigegeben werden?

[Sir Rufo]

Du hast einen Gedankenfehler

Delphi-Quellcode:

function Test( sl : TStringList; Index : Integer) : TObject;
begin
  Result := sl.Objects[Index];
  sl.Delete(Index);
end;

procedure foo;
var
  o : TObject;
begin
  o := Test( MyStringList, 1 );
  // o hat jetzt eine Referenz aus der StringList, 
  // oder es kam eine Exception in Test und der Rest hier wird auch nicht abgearbeitet
  DoSomethingWith( o );
end;

oder hier der Ablauf mit einer Exception in Test

Delphi-Quellcode:

foo
  o := Test( MyStringList, -1 );
    Result := sl.Objects[Index]; // Knallt und gibt eine Exception
    // fertig mit Test
  // fertig mit foo
// Eine MessageBox mit der Exception

und hier ohne Exception

Delphi-Quellcode:

foo
  o := Test( MyStringList, 1 );
    Result := sl.Objects[Index];
    sl.Delete( Index );
    // fertig mit Test
  DoSomethingWith( o );
// fertig mit foo

[Popov]

Wie das abläuft dachte ich mir schon bevor ich die erste Frage gestellt habe, ich wollte nur wissen was Stand der Programmiertechnik ist. Wie gesagt, ob das nun falsch oder richtig ist, ich baue überall im Programm Abfragen, noch bevor eine Exception kommt. Ich denke mir, ich mache oft zu viel des Guten, so dass hier der erste Reflex die Frage war, wie kann ich die zweite Zeile abfangen?

[Sir Rufo]

Wenn dir der Ablauf klar ist, dann ist doch aber die Frage obsolet.

Denn du willst ja die 2. Exception verhindern, die aber schon durch die 1. Exception verhindert wird, weil da eben eine Exception geworfen wird.

Zitat von Popov:

Nun gehen wir mal davon aus, Index ist außer Bereich, also gibt es eine Fehlermeldung. Das ist auch so gewollt.

Nun weiter im Programm, als nächstes ist die Zeile sl.Delete(Index); dran. Falls der Index zu hoch ist, wird es auch hier eine Fehlermeldung geben. Und das soll nicht sein. Eine Meldung ist ok, zwei zuviel.

Jetzt bitte nicht fragen wieso hier Index nicht vorher überprüft wird, ist nur ein Beispiel.

Den Index würde ich auch nicht prüfen, der wird von der StringList geprüft und wirft eine Exception, wenn es nicht passt.

[Popov]

Im Grunde hast du ja Recht. Man kann das wunderbar mit einer grünen Ampel vergleichen. Grüne Ampel bedeutet, dass man über die Straße gehen kann. Weitere Prüfung der Sicherheit ist nicht nötig. Man muss nicht noch zusätzlich nach links und rechts gucken. Manche tun es trotzdem.

[Sir Rufo]

An einer Ampel kann es dir passieren, dass jemand doch noch bei rot fährt, eine Exception läuft so lange zurück, bis diese gefangen wird, oder poppt eben auf.

Jedes andere Verhalten kannst du entweder als non-existent betrachten, oder ich erwarte in deinem Code auch so etwas:

Delphi-Quellcode:

function Calc1and1 : integer;
begin
  Result := 1+1;
  if Result <> 2 then
    ShowMessage( 'Häh?' );
end;

[himitsu]

Zitat von Popov:

Ich gebe zu, im Grunde ein Sicherheitsfanatiker zu sein, der die Hälfte der Zeit an einem Programm damit verbringt Fehler abzufangen noch bevor sie eine Exception auslösen. Somit fühle ich mich unwohl bei dem Gedanken eine Zeile ins offene Messer laufen zu lassen, in der Annahme, dass es nicht treffen wird, da es darüberfliegt.

Keine Sorge.

PS: Selbst der Compiler wird dir sagen, daß er den vorherrigen Code versucht rauszuwerfen.