Methoden-Parameter soll Referenz, aber kein nil sein können

[Der schöne Günther]

Hallo.

Kann ich den "Gültigkeitsbereich" eines Parameters einschränken, dass ich zwar gerne Objekte annehme, aber kein nil ?

Beispiel:

Delphi-Quellcode:

procedure TMyClass.OperateOnObject(const someObject: TObject);
   if not Assigned(someObject) then raise EArgumentNilException.Create(..);
   
   // Kram
   
end;

myInstance.OperateOnObject(nil); // <-- Soll nicht kompilieren

Somit könnte ich mir auch immer das Exception werfen am Methodenanfang sparen. Gibt es da etwas?

Bislang fällt mir nur ein, den Methoden-Parameter zu einem var-Parameter zu machen aber das kann ja auch nicht Sinn der Sache sein.

Die Delphi-Hilfe spricht von einem sehr gut aussehenden [Ref]-Attribut für Parameter. Ich sehe allerdings bei mir keinen Unterschied: Das scheint mal wieder nur im iOS/Android-Compiler zu stecken...

Zitat:

Da S1 und S2 im Rumpf von CompareStr nicht geändert werden, können sie als Konstantenparameter deklariert werden.

Konstantenparameter können je nach verwendetem Compiler an die Funktion per Wert oder per Referenz übergeben werden. Um den Compiler zu veranlassen, einen Konstantenparameter per Referenz zu übergeben, können Sie den Dekorator [Ref] mit dem Schlüsselwort const verwenden.

Das folgende Beispiel zeigt, wie Sie den Dekorator [Ref] entweder vor oder nach dem Schlüsselwort const angeben können:

 function FunctionName(const [Ref] parameter1: Class1Name; [Ref] const parameter2: Class2Name);

[himitsu]

Nein.

Und zum Selberprüfen gibt es taustende Möglichkeiten.

Delphi-Quellcode:

Assert(Assigned(someObject));

Assert(Assigned(someObject), 'Du hast voll Mist gebaut,');

if not Assigned(someObject) then
  raise EProgrammerNotFound.Create('Hirn bitte anschalten!');  // Diese Exception wird eh zu selten verwendet.

[Uwe Raabe]

De Compiler kann doch noch gar nicht erkennen, ob der übergebene Parameter zur Laufzeit nil ist. Oder geht es dir um nil als Konstante im Quelltext?

[Der schöne Günther]

Richtig, wenn dort felsenfest und absichtlich nil steht.

[jensw_2000]

Sowas hier?

Delphi-Quellcode:

method MyObject.DivideBy(aValue: Integer);
require
  aValue <> 0;
begin
  MyValue := MyValue/aValue;
end;

Delphi-Quellcode:

method MyObject.Add(aItem: ListItem);
begin
  InternalList.Add(aItem);
ensure
  Count > 0;
End;

Require_(keyword)


Pre- und Postconditions stehen auch auf meiner Delphi Sprachfeature Wunschliste ganz oben.
Hoffentlich baut EMBT das irgendwann mit ein.
Wird echt mal wieder Zeit für ein paar echte Delphi Features, anstatt nur Halbherzigkeiten drum herum zu bauen.

[Mikkey]

Einstweilen hilft Dir vielleicht auch eine Suche nach

Code:

\(.*nil.*\)

Ich habe seinerzeit für C mir auch ein Suchmakro gemacht, das nach 'if' und einem einzelnen Gleichheitszeiten in derselben Zeile gesucht hat - Bsp.

Code:

if (a = 0) { ... }

[Der schöne Günther]

Das Suchen im Quelltext müsste aber jeder selbst in seiner IDE machen, richtig?

Weil einen "echten" Präprozessor habe ich in Delphi irgendwie auch noch nicht gefunden...


Den Wunsch nach einem "Design by Contract" habe ich persönlich jetzt weniger, mir ging es nur um eine ganz harmlose Typeneinschränkung zur Compilierzeit. Aber sowas wär natürlich auch nicht schlecht

Vor allem wundere ich mich weiterhin über das [Ref]-Attribut. Ich habe kein Android oder iOS-Device auf dem ich ein "Nextgen-Compiler"-Produkt laufen lassen könnte. Oder kann man mit den x86-Simulatoren für iOS und Android da was drehen?

[himitsu]

Aber diese Pre- und Postconditions werden doch auch erst zur Laufzeit geprüft?

Wobei ich den Sinn nicht verstehen kann, warum der Compiler den Wert eines Parameters prüfen können soll.
Was ist denn er unterschied, zwischen einem nil als Konstante und einem nil, das zur Laufzeit als Variable übergeben wird?

Und den Sinn hinter den Pre- und Postconditions, als neues Sprachfeature, seh ich irgendwie auch nicht.

Delphi-Quellcode:

require
  aValue <> 0;
begin

Ist dann doch wohl das Selbe wie das?

Delphi-Quellcode:

begin
  Assert(aValue <> 0);

[Namenloser]

Der Unterschied ist, dass man Post- und Preconditions wenigstens zum Teil statisch auswerten könnte.

[himitsu]

Was meinst du denn mit statisch?