lokale Variablen mit globaler Lebensdauer?

[Robert_G]

@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.