Konstanten im Interface

[Der schöne Günther]

In Delphi können Interfaces keine Konstanten haben, oder?

Ja, es sind in der Regel Implementations-Details die dort nicht hineingehören. Ich ziehe Standard-Belegungen für Parameter immer gerne in Konstanten raus:

Delphi-Quellcode:

TSomeClass = class
   private const
      Param_someProc_someParam = 12;
   public
      procedure someProc(const someParam: Integer = Param_someProc_someParam);
end;

In einem Interface bleibt mir nur

Delphi-Quellcode:

ISomeInterface = interface
   procedure someProc(const someParam: Integer = 12);
end;

Oder?

[himitsu]

Zitat:

Zitat von Der schöne Günther (Beitrag 1242376)

In Delphi können Interfaces keine Konstanten haben, oder?

Wie wäre es mit Ausprobieren?

(ich glaub zwar nicht, wobei aber z.B. Property möglich sind, obwohl Interfaces sowas eigentlich auch nicht haben)

public, protected und private gibt es allerdings leider auch nicht, wobei man das private via Interface-Vererbung indirekt nutzen kann, um z.B. das "private" vor der Codevervollständigung zu verstecken.

[Thom]

Eine Möglichkeit:

Delphi-Quellcode:

  TSomeBaseClass = class(...)
  private const
    Param_someProc_someParam = 12;
  end;

  ISomeInterface = interface
    procedure someProc(const someParam: Integer = TSomeBaseClass.Param_someProc_someParam);
  end;

  TSomeClass = class(TSomeBaseClass,ISomeInterface)
  public
    procedure someProc(const someParam: Integer = TSomeBaseClass.Param_someProc_someParam);
  end;

[Der schöne Günther]

Natürlich habe ich selbst probiert und gesucht.

Properties helfen einem für Default-Parameter nicht weiter.

Das mit "private" und Interface-Vererbung verstehe ich nicht. Hast du ein Beispiel?


Thom, das Interface von der Klasse abhängig zu machen ist keine gute Idee. Aber: Deine

Delphi-Quellcode:

TSomeBaseClass

macht doch noch einmal deutlich, dass die Parameterbelegung eine Implementierungseigenschaft ist: Die implementierende Klasse kann einen Standardwert vorgeben, selbst wenn das Interface kein vorgibt!

Da hatte ich irgendwie ein Brett vorm Kopf :oops:

[Thom]

Du hattest doch selbst die Idee, die Konstante in der (implementierenden) Klasse unterzubringen. Willst Du das nicht, dann definier doch einfach eine globale Konstante:

Delphi-Quellcode:

const
  Param_someProc_someParam = 12;

type
  ISomeInterface = interface
    procedure someProc(const someParam: Integer = Param_someProc_someParam);
  end;

  TSomeClass = class(...,ISomeInterface)
  public
    procedure someProc(const someParam: Integer = Param_someProc_someParam);
  end;

Zitat:

Zitat von Der schöne Günther (Beitrag 1242383)

Die implementierende Klasse kann einen Standardwert vorgeben, selbst wenn das Interface kein vorgibt!

Falls das eine Frage war: Ja.

Delphi-Quellcode:

type
  ISomeInterface = interface
    procedure someProc(const someParam: Integer);
  end;

  TSomeClass = class(...,ISomeInterface)
  private type
    Param_someProc_someParam = 12;
  public
    procedure someProc(const someParam: Integer = Param_someProc_someParam);
  end;

[himitsu]

Delphi-Quellcode:

  ISomeInterface = interface
  {private} const
    Param_someProc_someParam = 12;
  private  // geht nicht
    function MyGetter: Integer;
    procedure MySetter(Value: Integer);
    function MyGetter2(Index: Integer): Integer;
    procedure MySetter2(Value, Index: Integer);
  public
    procedure someProc(const someParam: Integer = Param_someProc_someParam);
    property MyProperty: Integer read MyGetter write MySetter;  // geht
    property MyProperty2: Integer index 1 read MyGetter write MySetter;  // Index geht nicht
    property MyProperty3: Integer index 2 read MyGetter write MySetter;
  end;

Delphi-Quellcode:

  TSomeClass = class(TSomeBaseClass,ISomeInterface)
  public
    procedure someProc(const someParam: Integer = TSomeBaseClass.Param_someProc_someParam);
  end;

Wenn du die Klasse nur als Interface brauchst, dann kannst du in der Klasse auch den Default-Wert weglassen.

Ansonsten ist die Idee von Thom eh besser, also die Konstante in einer Klasse zu definieren und in beiden Definitionen (Interface und Klasse) die selbe Konstante zu nutzen,
wobei TSomeClass nicht unbedingt von TSomeBaseClass abgeleitet sein muß.


PS: Die Benamung von Param_someProc_someParam finde ich etwas unglücklich.
Was ist, wenn diese Konstante auch an anderen Stellen verwendet wird?
Da wäre es ja eigentlich besser die "Funktion" als Namen zu nehmen und nicht den Ort.

[jaenicke]

Zitat:

Zitat von Der schöne Günther (Beitrag 1242376)

In Delphi können Interfaces keine Konstanten haben, oder?

Es wäre mir neu, dass das in anderen Sprachen bei Interfaces geht.

[himitsu]

Aber prinzipiell gibt es keinen Grund, warum es in Gelphi nicht gehen sollte.

Die Konstanten werden ja zur CompileTime aufgelöst und sind dann, zur Laufzeit, letztendlich nicht mehr im Interface vorhanden.

[Der schöne Günther]

Zitat:

Zitat von jaenicke (Beitrag 1242388)

Zitat:

Zitat von Der schöne Günther (Beitrag 1242376)

In Delphi können Interfaces keine Konstanten haben, oder?

Es wäre mir neu, dass das in anderen Sprachen bei Interfaces geht.

Also in Java sehe ich das relativ häufig. Immer wieder spaßig wenn zwei implementierte Interfaces auch noch jeweils eine Konstante mit dem selben Namen haben :-)


Konstanten habe ich Delphi sowieso noch nicht so ganz verstanden. Ich vermisse bsp. immer noch ein bisschen, die Konstanten eines Objekts erst im Konstruktor setzen zu können. In C++ geht das ja über den Element-Initialisierer...

[mjustin]

Zitat:

Zitat von jaenicke (Beitrag 1242388)

Zitat:

Zitat von Der schöne Günther (Beitrag 1242376)

In Delphi können Interfaces keine Konstanten haben, oder?

Es wäre mir neu, dass das in anderen Sprachen bei Interfaces geht.

In Java hat die Möglichkeit, innerhalb einer Interface-Deklaration auch Konstanten zu definieren, immer schon bestanden. Es macht auch Sinn, da es ermöglicht, Zusammengehörendes gemeinsam zu definieren.

Code:

public interface GroupedInterface extends Interface1, Interface2, Interface3 {

    // constant declarations
    
    // base of natural logarithms
    double E = 2.718282;
 
    // method signatures
    void doSomething (int i, double x);
    int doSomethingElse(String s);
}

http://docs.oracle.com/javase/tutori...erfaceDef.html

[himitsu]

Zitat:

Zitat von Der schöne Günther (Beitrag 1242395)

Konstanten habe ich Delphi sowieso noch nicht so ganz verstanden. Ich vermisse bsp. immer noch ein bisschen, die Konstanten eines Objekts erst im Konstruktor setzen zu können. In C++ geht das ja über den Element-Initialisierer...

Wie meinst'e denn das?

Konstanten haben ja schon einen Wert ... den braucht man doch nicht erst im Constructor zu setzen? :gruebel:

[jaenicke]

Zitat:

Zitat von Der schöne Günther (Beitrag 1242395)

Also in Java sehe ich das relativ häufig. Immer wieder spaßig wenn zwei implementierte Interfaces auch noch jeweils eine Konstante mit dem selben Namen haben :-)

Das ist dann vermutlich genau der Knackpunkt.

Zitat:

Zitat von Der schöne Günther (Beitrag 1242395)

Konstanten habe ich Delphi sowieso noch nicht so ganz verstanden. Ich vermisse bsp. immer noch ein bisschen, die Konstanten eines Objekts erst im Konstruktor setzen zu können. In C++ geht das ja über den Element-Initialisierer...

In Delphi geht das theoretisch auch, indem man veränderbare Konstanten aktiviert.

Ich persönlich halte das allerdings für äußerst unsauber. Denn Konstanten sind nun einmal konstant und nicht variabel. Wenn man sie aber per Code setzt, werden sie verändert und damit sind es keine Konstanten mehr. Dafür gibt es Variablen bzw. Felder.

[himitsu]

Inhaltlich gibt es da in Delphi auch Unterschide.

typisierte und untypisierte Konstanten

Untypisierte Konstanten sind echte Konstanten, welcher beim Kompilieren auch direkt an der Verwendungsstelle eingebaut werden
und typisierte Konstanten sind eigentlich schreibgeschützte Variablen (da gibt es sogar noch einen bösen Compilerschalter, für eine uralte Abwärtskompatibilität, mit dem man den Schreibschutz deaktivieren kann).

Wobei man referenzierte Typen (z.B. Strings) auch bei untypisierten Konstanten verändern kann, da sie auch mehr wie typisierte Konstanten verwaltet werden.

[Der schöne Günther]

Zitat:

Zitat von himitsu (Beitrag 1242401)

Wie meinst'e denn das?

Konstanten haben ja schon einen Wert ... den braucht man doch nicht erst im Constructor zu setzen? :gruebel:

Zumindest in C++ müssen sie nicht von Anfang an einen Wert haben. Beispiel:

Interface:

Code:

class TMyClass {
   public:
      const int someIntConst;

      TMyClass(const int someParam);
      TMyClass(void);

};

Implementation:

Code:

TMyClass::TMyClass(const int someParam) : someIntConst(someParam) {
   // Hier geschieht nichts
}

TMyClass::TMyClass(void) : someIntConst(42) {
   // Hier geschieht immer noch nichts
}


__fastcall TForm1::TForm1(TComponent* Owner)
   : TForm(Owner)
{

   TMyClass myNormalInstance;
   ShowMessage(myNormalInstance.someIntConst);


   TMyClass myCustomInstance(55);
   ShowMessage(myCustomInstance.someIntConst);

}

Die erste Messagebox gibt 42 aus, die zweite 55. Die beiden Instanzen haben unterschiedliche Werte in ihren Konstanten.

Ich finde das macht schon Sinn, denn oft legt man nur einmal im Konstruktor in Abhängigkeit der Parameter etwas fest und das soll für die gesamte Lebenszeit des Objekts so bleiben. In Delphi müssen alle Instanzen der gleichen Klasse in einer Konstante allesamt den gleichen Wert haben.

Den Compilerschalter habe ich auch schon gesehen. Aber das lasse ich besser so wie es ist ;-)

[himitsu]

Für mich ist das dann aber eine Variable, da der Wert variabel ist und nicht konstant.

[Der schöne Günther]

Für mich als Mensch ist es eine Konstante, da ich am Objekt den Wert nicht ändern kann: Über die gesamte Lebenszeit des Objekts hinweg ist der Wert zwingend konstant.

[Bernhard Geyer]

Zitat:

Zitat von Der schöne Günther (Beitrag 1242438)

Für mich als Mensch ist es eine Konstante, ...

himitsu ist aber auch ein Mensch (dachte jedenfalls bisher immer).

ok. Dieses konstrukt kann Delphi nicht. Aber was solls. Man kann mit einer Read-Only-Property fast das gleiche erreichen.