Bei der Deklaration einer Variable einen Wert definieren

[Delphi-Neuling]

Hallo Leute,

meine Frage ist kurz und knapp: Wie ist es möglich bei der Deklaration einer Variable, wie hier im Beispiel:

Delphi-Quellcode:

var Variable : integer;

einen Wert wie beispielsweise 10 festzulegen?

Delphi-Neuling

[Neutral General]

Hi,

Das geht (nur) bei globalen Variablen so:

Delphi-Quellcode:

var Variable : integer = 100;

Bei lokalen Variablen oder Variablen einer Klasse geht das nicht.

[Delphi-Neuling]

Hallo Neutral General,

und wie mache ich das ohne einer globalen Variable? Gibt es da auch eine andere Möglichkeit?

Delphi-Neuling

[Apollonius]

Nein. Nur bei globalen Variablen ist eine derartige Initialisierung überhaupt sinnvoll (aus Maschinensprache-Sicht betrachtet). Lokalen Variablen und Feldern musst du von Hand zu gegebener Zeit einen Wert zuweisen.

[Delphi-Neuling]

Hallo ihr Beide,

danke für die Hilfe :!:

Delphi-Neuling

[alex517]

Das geht auch bei lokalen Variablen.
Allerdings heißen diese Variablen dann "Zuweisbare typisierte Konstanten" und muss in den Projectoptionen
eingeschaltet werden.
Ich nutze das z.B. um sicherzustellen, dass eine Procedure/Funktion nicht rekursiv aufgerufen wird.

Delphi-Quellcode:

procedure Foo();
const  // <--- const nicht var !
  lLock: Boolean = false;
begin
  if lLock then exit;
  lLock := true;
  try
   ..
   ..
  finally
    lLock := false;
  end;
end;

alex

[Apollonius]

Das ist dann aber keine lokale Variable mehr.

[alex517]

Zitat:

Zitat von Apollonius

Das ist dann aber keine lokale Variable mehr.

sondern?

[Luckie]

Eine beschreibbare Konstante. So etwas zu nutzen halte ich übriogens für schlechten Stil. Entweder ich benutze eine Variable, um damit zu arbeiten oder ich deklarier eine Konstante, weil ich einen konstanten Wert haben will.

[himitsu]

@Delphi-Neuling:
weise einfach direkt zu Begin der Prozedur/Funktion (also gleich nach dem ersten Begin) den gewünschten Wert zu.

Delphi-Quellcode:

procedure Foo();
var xyz: Integer;
begin
  xyz := 123;
  {...}
end;

des sollte eigentlich die beste/einfachste Variante sein.



@Zuweisbare typisierte Konstanten:
So wären außerdem alle Konstantan davon betroffen,
was einige Nachteile mit sich bringen kann :wall:

Dann doch lieber globale Variablen (innerhalb des Implementation-Blocks haben sie auch keine Auswirkungen außerhalb der Unit)
Und mit passenden Variablennamen kommt man auch sonst mit nichts in Konflikte.

Delphi-Quellcode:

implementation

{...}

var Procedure_Foo_Lock: Boolean = false;

procedure Foo();
begin
  if Procedure_Foo_Lock then exit;
  Procedure_Foo_Lock := true;
  try
    {...}
  finally
    Procedure_Foo_Lock := false;
  end;
end;

[mirage228]

Zitat:

Zitat von alex517

Zitat:

Zitat von Apollonius

Das ist dann aber keine lokale Variable mehr.

sondern?

Das ist eine Konstante, die du mittels Compiler-Switch zum Beschreiben zweckentfremdest :-P :mrgreen:

[SubData]

Zitat:

Zitat von alex517

Ich nutze das z.B. um sicherzustellen, dass eine Procedure/Funktion nicht rekursiv aufgerufen wird.

alex

Edit: War Käse...

[sirius]

Zitat:

Zitat von alex517

Zitat:

Zitat von Apollonius

Das ist dann aber keine lokale Variable mehr.

sondern?

In C gibt es so etwas (ähnliches) und nennt sich statische Variable.

[alex517]

oh man, hätte ich bloß nichts gesagt..

Zitat:

Zitat von alex517

Zitat:

Zitat von Apollonius

Das ist dann aber keine lokale Variable mehr.

sondern?

Mein "sondern" bezog sich auf Apollonius Aussage das dieses "Gebilde" nicht lokal sein soll.
Das es per Definition eine veränderbare Konstante ist, darauf habe ich ja selbst hingewiesen.

Zitat:

Zitat von himitsu

Dann doch lieber globale Variablen (innerhalb des Implementation-Blocks haben sie auch keine Auswirkungen außerhalb der Unit)
Und mit passenden Variablennamen kommt man auch sonst mit nichts in Konflikte.

Da finde ich meine Variante sinnvoller, die Variable(Konstante) wird genau dort definiert wo sie
hingehört und verwendet wird.

Zitat:

Zitat von Luckie

So etwas zu nutzen halte ich übrigens für schlechten Stil.

Warum? Wenn ich Konstanten in dieser Form definiere,

Delphi-Quellcode:

const
  cfgFarbe: TColor = clRed;

dann mache ich das genau aus dem Grund, diese später ändern zu können.

Zitat:

Zitat von himitsu

So wären außerdem alle Konstantan davon betroffen,
was einige Nachteile mit sich bringen kann

Welche Nachteile?
"Richtige" Konstanten

Delphi-Quellcode:

  cFehlerColor = clRed;

können nicht verändert werden.

alex

Edit: Mit so vielen Leuten auf einmal habe ich mich ja noch nie angelegt.
Fehlt mir nur noch Hagens Standpauke. ;)

[Apollonius]

Deine zuweisbaren typisierten Konstanten behalten ihren Wert, nachdem die Routine verlassen wurde. Außerdem gibt es nette Effekte, falls die Routine sich irgendwann einmal selbst aufruft, da dann beide die gleiche "Variable" verändern.

[alex517]

Zitat:

Zitat von Apollonius

Deine zuweisbaren typisierten Konstanten behalten ihren Wert, nachdem die Routine verlassen wurde. ..

Genau das nutze ich aus, damit dieses

Zitat:

Zitat von Apollonius

Außerdem gibt es nette Effekte, falls die Routine sich irgendwann einmal selbst aufruft, ..

nicht passiert.

Mein Beispiel zeigt ja genau die Verhinderung des rekursiven Aufrufs.

alex

[Apollonius]

Ja. Ich wollte nur feststellen, dass diese statischen Variablen, wie sie in C heißen, eine ganz andere Funktion als lokale Variablen erfüllen. Damit sind sie für den Threadersteller keine Lösung.

[himitsu]

Konstanten sind aber Konstanten und keine veränderlichen Variablen.
außerdem ist des {$J+} / {$WRITEABLECONST ON} mehr zur Abwärtskompatibilität vorhanden.

Obwohl ich zwar auch gern mal einige "Fehler" ausnutze ... irgendwo muß man doch nicht gleich alles machen, nur weil es geht?


Vorallem da durch eine unbedachte Verwendung dieser Compilerschalter sich schnell mal die Adressen auf die "Konstanten"-Inhalte ändern.

Zitat:

Zitat von alex517

die Variable(Konstante) wird genau dort definiert wo sie
hingehört und verwendet wird.

mach ich genauso, da ich sowas schließlich direkt vor der Funktion definiere :angel2:

[gammatester]

Zitat:

Zitat von himitsu

Konstanten sind aber Konstanten und keine veränderlichen Variablen.

Genau! Und deshalb sind typed constants auch keine Konstanten! Auch sind veränderliche Variablen ein Pleonasmus bzw. wären unveränderliche Variablen ziemlich sinnlos.

Zitat:

Zitat von himitsu

Vorallem da durch eine unbedachte Verwendung dieser Compilerschalter sich schnell mal die Adressen auf die "Konstanten"-Inhalte ändern.

Völlig unverständlich!? Wieso sollten sich die Adressen ändern, und wenn, was wäre daran so verwerflich? Wenn Du ein paar neue Variable definierst, ändern sich doch auch eventuell Adressen von schon vorhandenen?

Zitat:

Zitat von himitsu

mach ich genauso, da ich sowas schließlich direkt vor der Funktion definiere :angel2:

Leider sind diese Konstrukte dann allerdings nicht mehr lokal!

Das alles wäre halbwegs akzeptabel, wenn die Delphi-Weiterentwickler nicht in ihrer unendlichen Weisheit beschlossen hätten, daß innerhalb von Prozeduren/Funktionen etc.

Delphi-Quellcode:

var myvar: mytype = myvalue;

fehlerhaft ist, während

Delphi-Quellcode:

const myvar: mytype = myvalue;

erlaubt ist.

Gruß Gammatester

[Apollonius]

Dass dieses Konstrukt bei lokalen Variablen und Felder nicht funktioniert, finde ich absolut richtig. Bei globalen Variablen und Konstanten wird der Startwert einfach in einem Abschnitt des PE-Formats angegeben. Bei lokalen Variablen geht das nicht, man muss erst die Variable auf dem Stack allozieren und dann noch einen Wert hineinschreiben, was auf das selbe wie die explizite Zuweisung hinausläuft. Die Initialisierungs-Syntax würde dies verwischen.

[gammatester]

Zitat:

Zitat von Apollonius

Dass dieses Konstrukt bei lokalen Variablen und Felder nicht funktioniert, finde ich absolut richtig. Bei globalen Variablen und Konstanten wird der Startwert einfach in einem Abschnitt des PE-Formats angegeben. Bei lokalen Variablen geht das nicht, man muss erst die Variable auf dem Stack allozieren und dann noch einen Wert hineinschreiben, was auf das selbe wie die explizite Zuweisung hinausläuft. Die Initialisierungs-Syntax würde dies verwischen.

Ach das ist ja interessant:) Ich glaube, hier werden die ganze Zeit zwei Konzepte verwechselt bzw. vermischt.

Lokal vs. global hat vom Prinzip her nichts mit Lebensdauer, Initialisierung usw. zu tun. Es gibt ja auch lokale Konstanten und Funktionen? Soll das auch nicht mehr funktionieren? Lokal bedeutet, das eine Entität halt nur innerhalb einer Funktion sichtbar ist und nicht in der ganzen Unit bzw. im Programm.

Außerdem: wie eine lokale initialisierte Variable "alloziert" und "belegt" wird, sollte nicht in der Sprache festgelegt werden, das ist halt Implementation durch die Kompilerentwickler, und wird auch jetzt schon eifrig verwendet: siehe Schleifen-"Variable", die nicht auf dem Stack sondern in Registern sind; und diese Register können dekrementiert werden, obwohl die Variable inkrementiert wird.

Außerdem: Du hast wohl auch nichts dagegen, wenn bei Ansistrings oder Referenzcounted-Konstrukte "Die Initialisierungs-Syntax würde dies verwischen" würde.

Also versucht nicht den Leuten, die bestimmte Konstruktion verwenden wollen, diese auszureden, ihr müßt sie ja nicht verwenden.

Und das Pseudoargument, man muß nicht alles machen, was geht, fällt hier aus historischen Gründen auf den Urheber zurück, der "var =" benutzt.


Gruß Gammatester

[himitsu]

schau dir alleine mal die Speicherbereiche an, also wo was abgelegt wird (des is wohl die am Einfachsten sichtare Auswirkung)

Delphi-Quellcode:

const
  A = 'xyz';
  {$WRITEABLECONST ON}
  X: String = 'abc';
  {$WRITEABLECONST OFF}
  Y: String = 'bcd';
var
  Z: String;
begin
  Z := 'cde';
  Caption := Format('%x %x %x %x', [Integer(@X[1]), Integer(@Y[1]), Integer(@Z[1]), Integer(@A[1])]);

WritableConsts sind in Wirklichkeit auch nur Varialen und reagieren (bis auf gewisse Unterschiede) auch genauso.

Vorallem im ASM-Bereich wirst'e schnell merken, daß es einen großen Unterschied zwischen Konstanten, änderbaren Konstanten und Variablen gibt ... also z.B. wo/wie der Wert einer Integers abgelegt wird.