Wert aus einer const-Deklaration überschreiben?!

[OldGrumpy]

Hallo zusammen,

heute bin ich auf eine sehr seltsame Sache gestossen. Normalerweise geht man ja davon aus, dass Werte als "const" deklariert werden weil sie eben Konstanten sind. Doch heute bin ich eines besseren belehrt worden(?) :)

Folgendes Konstrukt:

Unit a deklariert im interface einen const-Wert:

Delphi-Quellcode:

Unit test;

interface
uses{...};
type{Typendeklarationen}
const maxvalue: integer = 2500;
{...}

So weit, so gut. Nun habe ich hier aber eine zweite Unit, die im Initialization-Teil diese Konstante mit einem eigenen Wert überschreibt! Laut Debugger steht danach auch der neue Wert drin. Wie kann das sein? Und vor allem, macht das Sinn, und kann das später Probleme geben? Zur Verdeutlichung:

Delphi-Quellcode:

Unit main;
interface
uses {...},test;
{Rest der Interface-Abteilung}
implementation
{...}
initialization
{...}
test.maxvalue:=10000;
{...}
finalization
{...}
end.

Vielleicht hat ja jemand einen hilfreichen Kommentar dazu :)

[Muetze1]

Dies hängt von deinen Projekteinstellungen ab. Dort dann im speziellen von den Compilereinstellungen zu typisierten Konstanten. Du hast die Möglichkeit typisierten Konstanten was zu zu weisen und erhälst damit dann eine statische Variable. Ob dies nun möglich ist, legst du in den Projektoptionen/Compiler fest.

[Relicted]

Ist z.B. hilfreich wenn du einen gewissen wert nur in einer prozedur speichern willst ohne dass andere objekte,funktionen oder sonst was zugriff drauf hat.

Delphi-Quellcode:

procedure TForm1.wert( nWert : integer );
const
  cnWert = -1;
begin
  cnWert := nWert + cnWert;
  
  // weitere verarbeitung...
end;

die konstante wird also wie eine member variable behandelt ( der aktuelle wert bleibt da drin ) nur ist die sichtbarkeit der konstante durch die deklaration nur noch innerhalb der prozedur "wert".

eine andere funktion ist z.b. das realisieren von singleton objekten...

Delphi-Quellcode:

class function TSingleton.Instance : TSingleton;
const
  coInstance : TSingleton = nil;
begin
  if not Assigned( coInstance ) then
    coInstance := TSingleton.Create;

  result := coInstance;
end;

so kann man immer über TSingleton.Instance.Funktion auf das objekt zugreifen... ohne irgendwann mal was instanzieren zu müssen... achja und in jeder unit wo die Singleton.pas eingebunden ist kann auf ein und das selbe objekt zugegriffen werden ( man verhindert eine globale variable )

gruß
Reli

[Muetze1]

Zitat:

Zitat von Relicted

die konstante wird also wie eine member variable behandelt ( der aktuelle wert bleibt da drin ) nur ist die sichtbarkeit der konstante durch die deklaration nur noch innerhalb der prozedur "wert".

Hinweis: ... wie ein static member (bzw. class member)! Ein normaler Member wäre pro Instanz vorhanden, diese "Variable" ist nur einmalig vorhanden!

[OldGrumpy]

Na gut, mit diesen Zusatzinfos macht das Sinn. Herzlichen Dank für die ausführlichen Erläuterungen :) Bisher ging ich davon aus dass const auch const bedeutet, aber wie so oft im Leben... "das ist nicht so einfach" :mrgreen:

[Relicted]

tja wie so oft... doppeldeutigkeit ist doch ganz eindeutig :-) oder so ^^

[Muetze1]

Was mir eben noch auffällt und noch nicht richtig hervorgehoben wurde: wenn die Typenangabe bei der Deklaration der Konstante weggelassen wird, dann ist die Konstante unabhängig von der Compilereinstellung konstant. Die Compilereinstellung bezieht sich nur auf typisierte Konstanten.

Delphi-Quellcode:

Const
  coReallyConst = 34.4; // Typ nicht angegeben: immer konstant
  coNotConst : Double = 111.3;   // Typ angegeben: Compilereinstellung legt fest ob konstant oder nicht.

[Reinhard Kern]

Zitat:

Zitat von Muetze1

Was mir eben noch auffällt und noch nicht richtig hervorgehoben wurde: wenn die Typenangabe bei der Deklaration der Konstante weggelassen wird, dann ist die Konstante unabhängig von der Compilereinstellung konstant. Die Compilereinstellung bezieht sich nur auf typisierte Konstanten.

Delphi-Quellcode:

Const
  coReallyConst = 34.4; // Typ nicht angegeben: immer konstant
  coNotConst : Double = 111.3;   // Typ angegeben: Compilereinstellung legt fest ob konstant oder nicht.

Hallo,

das ist historisch bedingt: typisierte Konstanten waren, warum auch immer, die erste in Delphi verfügbare Möglichkeit Variablen zu initialisieren - war damals (Delphi 1 oder 2) auch als so beabsichtigt beschrieben, also ausdrücklich als nicht-konstant. Habe ich noch in einigen alten Programmen so drinstehen.

Gruss Reinhard