Warum braucht Class Property einen Static-Getter?

[himitsu]

Tachchen,

wieso müssen bei Class-Property die Getter/Setter eigentlich Static-Class-Methods sein?

Delphi-Quellcode:

class function MyGetter: TObject; {static}
class property MyClass: TObject read MyGetter;  //verlangt static

Aber durch Static gibt es dann kein Self mehr und man kann nicht mehr den Klassentyp einer abgeleiteten Klasse auslesen.

[Der schöne Günther]

Zitat:

A class field is shared between two classes that are related by inheritance. So that cannot be used for polymorphism. And a class static method also cannot supply polymorphic behaviour.

Use a virtual class function rather than a class property.

Quelle: http://stackoverflow.com/a/11013542/2298252

Kann man wohl nichts machen

[TBx]

Zitat von himitsu:

Tachchen,
Aber durch Static gibt es dann kein Self mehr und man kann nicht mehr den Klassentyp einer abgeleiteten Klasse auslesen.

Und wozu sollte das gut sein? Klassenvariablen, Klassenmethoden und Klassenproperties sind schließlich Instanzunabhängig. Und da man sich auch nur auf eigene Klassenvariablen beziehen kann, ist es völlig Wumpe, ob eine Klassenmethode weiß, dass sie in einer Kindklasse aufgerufen wird.

Was hast Du denn eigentlich vor, dass Du so ein Kronstrukt benötigst?

Gruß aus dem hohen Norden
Thomas

[Dejan Vu]

Zitat von TBx:

Aber durch Static gibt es dann kein Self mehr

Worauf würde 'Self' denn dann eigentlich zeigen?

[Namenloser]

Zitat von Dejan Vu:

Zitat von TBx:

Aber durch Static gibt es dann kein Self mehr

Worauf würde 'Self' denn dann eigentlich zeigen?

Es gibt kein "Self". Eine statische Klassenmethode ist wie eine ganz normale Routine.

Wie der Compiler es konkret handhabt, weiß ich gerade nicht, aber ich würde vermuten, dass er entweder sagt "undefinierter Bezeichner" oder es einfach stur durch den Klassennamen ersetzt.

Ein vernünftiger Grund, weshalb Property-Getter statisch sein müssen, fällt mir spontan nicht ein. Faulheit der Compilerentwickler?

[himitsu]

Nicht Static-Methoden kennen ihren Nachfahren.

Ein Property ist doch eigentlich nur ein "Alias" für den Getter, also sollte das doch mit dem Static eigentlich nichts zu tun haben

Self ist ein unsichtbarer Parameter, der als erstes in der Parameterliste drinsteht.
Nur bei Static gibt es diesen Parameter nicht. Das sieht intern wie eine "normale" Funktion, so als wäre sie nicht in einer Klasse drin.

Delphi-Quellcode:

type
  TMyClass = class
    function Method: string;
    class function ClassMethod: string;
    class function StaticMethod: string; static;
  end;

  TOtherClass = class(TMyClass);
  end;


function TMyClass.Method: string;
begin
  // Self = die Instanz (TObject)
  // ClassType = TMyClass oder TOtherClass 
  Result := ClassName;  // MyClassType={Self.}ClassType / MyClassType=Self.ClassType 
end;

class function TMyClass.ClassMethod: string;
begin
  // Self = der Klassentyp (TClass)
  // ClassType = TMyClass oder TOtherClass 
  Result := ClassName;  // MyClassType=Self
end;

class function TMyClass.StaticMethod: string;
begin
  // Self gibt es nicht
  // kennt nur sich und nicht den Nachfahren
  Result := 'k.A.';
end;

Code:

MyObj.Method               TMyClass
OtherObj.Method            TOtherClass
TMyClass.Method            geht natürlich nicht
TOtherClass.Method         geht natürlich nicht

MyObj.ClassMethod          TMyClass
OtherObj.ClassMethod       TOtherClass
TMyClass.ClassMethod       TMyClass
TOtherClass.ClassMethod    TOtherClass

MyObj.StaticMethod         k.A.
OtherObj.StaticMethod      k.A.
TMyClass.StaticMethod      k.A.
TOtherClass.StaticMethod   k.A.

[Dejan Vu]

Zitat von Namenloser:

Es gibt kein "Self". Eine statische Klassenmethode ist wie eine ganz normale Routine.

Sagte schon himitsu und der gesunde Menschenverstand sowieso. Ich habe nur nachgefragt, denn wenn jemand die Nichtexistenz von Etwas bedauert, müsste er auch sagen können, wie dieses Etwas denn aussehen sollte, wenn es denn existieren würde, ne wahr?

Delphi-Quellcode:

Type
  TMyClass = class
    class function StaticMethod; virtual; static;
  end;
  TOtherClass = class(TMyClass)
    class fnction StaticMethod; override; static;
  end;

class function TMyClass.StaticMethod: string;
begin
   Result := 'TMyClass';
end; 
class function TOtherClass .StaticMethod: string;
begin
   Result := TOtherClass ;
end;

Geht das?

[Uwe Raabe]

Zitat von Dejan Vu:

Zitat von TBx:

Aber durch Static gibt es dann kein Self mehr

Worauf würde 'Self' denn dann eigentlich zeigen?

Bei einer Klassenmethode zeigt Self auf den aktuellen Klassentyp. So könnt eine nicht-statische Klassenmethode in etwa sowas machen:

Delphi-Quellcode:

type
  TMyBaseClass = class
  public 
    class procedure Execute;
  end; 

  TMyClass1 = class(TMyBaseClass);
  TMyClass2 = class(TMyBaseClass);
  

class procedure TMyBaseClass.Execute;
var
  instance: TMyBaseClass;
begin
  instance := Self.Create;
  try
    ...
  finally
    instance.Free;
  end;
end;

begin
  TMyClass1.Execute; // erzeugt ein TMyClass1
  TMyClass2.Execute; // erzeugt ein TMyClass2
end;

[Stevie]

Einen nicht static Getter bräuchte man, wenn class variables virtual wären.