There is another way as well, you can declare simple global variables – 
depending where you declare it determines it’s scope - how visible it it is.

In this example string2 can be seen by any unit that uses this one, just as 
Form11 (the particular instance of TForm11, and is also a global variable) is 
visible.

String3 can be seen by all procedures in this unit, but not by anywhere else.   
 If you have lots of simple variables to store and they don’t need to be 
inherited etc this is the simplest way to do it.

You can take this further:
If I have lots of constants to declare, or variables to store I create a unit 
which is code only (no classes) eg called storeunit and declare all the 
constants and variables I want there, any form or unit that wants access to all 
these variables just has to add storeunit to its uses clause.   This 
centralises all such declarations in one place away from a form and is very 
tidy.   I will often put simple global functions and procedures in here too, as 
they also become globally available, eg various standard ways for formatting 
dates and strings.   Also this unit can be uses in different projects as well.  
 For this just go to File/New/Unit   and the IDE gives you a new blank unit 
already to add stuff to – a simpler unit with no form or class stuff.

Here string4 string5 integer1 integer2 integer3 can all be seen from anywhere 
that uses Storeunit

It depends on whether you like using global variables or not.   Also its a good 
idea to use a clear naming convention for such variables.

There are other tricks you can do too -  you can alter compiler settings to 
allow assignable constants for a procedure, then any values assigned here will 
be preserved between calls to the procedure.   But that seems to be confusing 
to me, as it really becomes a variable and not a constant.   I saw that used in 
and example where the program wanted a counter of the number of times the 
procedure was called, and the counter constant in the procedure was assigned a 
new value each time the procedure was called, its quite a tidy way to do that 
sort of thing.  In this case the scope (visibility) of the variable is totally 
limited to the one procedure.


type
  TForm11 = class(TForm)
    Button1: TButton;
    procedure Button1Click(Sender: TObject);
  private
    { Private declarations }
  public
    { Public declarations }
    MyString : string;
  end;

var
  Form11: TForm11;
  string2: string;

implementation

uses storeunit;

{$R *.dfm}

var
string3: string;


procedure TForm11.Button1Click(Sender: TObject);
begin
  MyString := 'Hello, world!';
  string2:=’Hello world2’;
  string5:=’Hello world5’;
end;



unit Storeunit;

interface

var
string4:string;
string5:string;
integer1:integer;
integer2:integer;
integer3:integer;

implementation

end.

John
From: Marshland Engineering 
Sent: Thursday, January 20, 2011 3:45 PM
To: delphi@delphi.org.nz 
Subject: [DUG] Variabels stored

Is there a way to store variables so I can use them from one procedure to 
another?  

I have been currently storing them in hidden edit.text boxes on the form but 
there must be a better way. 

Cheers Wallace

--------------------------------------------------------------------------------
_______________________________________________
NZ Borland Developers Group - Delphi mailing list
Post: delphi@delphi.org.nz
Admin: http://delphi.org.nz/mailman/listinfo/delphi
Unsubscribe: send an email to delphi-requ...@delphi.org.nz with Subject: 
unsubscribe
_______________________________________________
NZ Borland Developers Group - Delphi mailing list
Post: delphi@delphi.org.nz
Admin: http://delphi.org.nz/mailman/listinfo/delphi
Unsubscribe: send an email to delphi-requ...@delphi.org.nz with Subject: 
unsubscribe

Reply via email to