@Dizzy
Nur wann braucht man mal einen einzelnen primitiven Wert?
Um mehrere, zusammengehörige Werte zu einem Paket zu verschnüren, das nur einmal existieren darf, wäre das klassische Singleton wohl die gebräuchliste Lösung.
Delphi-Quellcode:
interface
type
TSingletonDings = class
private
function getSomeValue: TSomeType; virtual; abstract;
procedure setSomeValue(const aValue: TSomeType); virtual; abstract;
public
property SomeValue: TSomeType read getSomeValue write setSomeValue;
class function Instance: TSingletonDings;
end;
implementation
uses
...;
type
TRichtigesDings = class(TSingletonDings)
private
fSomeValue: TSomeType;
fAllowDestruction: Boolean;
function getSomeValue: TSomeType; override;
procedure setSomeValue(const aValue: TSomeType); override;
public
destructor Destroy; override;
end;
var
staticDings : TRichtigesDings;
{ TSingletonDings }
class function TSingletonDings.Instance: TSingletonDings;
begin
Result := staticDings;
end;
{ TRichtigesDings }
destructor TRichtigesDings.Destroy;
begin
if fAllowDestruction then
inherited
else
raise InvalidSingletonDestructionException.Create(TSingletonDings);
end;
function TRichtigesDings.getSomeValue: TSomeType;
begin
Result := fSomeValue;
end;
procedure TRichtigesDings.setSomeValue(const aValue: TSomeType);
begin
fSomeValue := aValue;
end;
initialization
staticDings := TRichtigesDings.Create();
staticDings.fAllowDestruction := False;
finalization
staticDings.fAllowDestruction := True;
staticDings.Free();
end.
TSingletonDings.Instance.SomeValue := Miep;
@Hagen
Sicher ist es widerlich eine Variable anlegen zu müssen, die über die ganze
Unit sichtbar ist...
Aber solange dort effektiv nur eine Klasse definiert ist, ist es zwar hässlicher als ein statisches Feld, aber genauso einsetzbar.
Innerhalb einer Klasse würde ich Sichtbarkeiten nicht mehr unterteilen wollen. Schließlich sollte man genau wissen was man da gerade macht und ein anderer (bzw. man selbst ein paar Wochen später) kann sich innerhalb einer auch nicht so leicht in den Fuss schiessen.
Bis Delphi32 statische Felder bekommt (statische Variablen in einer funktion finde *ich persönlich* sinnlos...), müssen wir mit dem leben was wir haben.
Typ. Konstanten sind hauptsächlich deshalb problematisch, da sie vielleicht einen lieben Tages keine Unterstützung des Compilers mehr erfahren werden (sie sind bereits jetzt per default nicht erlaubt).
.Net kennt solche Konstrukte noch nicht einmal! (Also statische lokale Variablen)
Auf kurz oder lang wird es das also nicht mehr geben. Warum sollte man es also jetzt noch jemandem zeigen?
Oh und bevor jetzt jemand aufschreit dass es in managed C++ geht: Bitte vorher den
IL Code ansehen.
Aus...
Code:
public:
void Miep()
{
static int x = 4;
x++;
}
...wird dann...
Code:
public static int ?x@?1??Miep@Comp1@CppClassLib@@Q$AAMXXZ@4HA;
Code:
public void Miep()
{
?x@?1??Miep@Comp1@CppClassLib@@Q$AAMXXZ@4HA++;
}
...und das dürfte wohl in keinster Weise restriktiv sein.