Why is var after type in new Projekt?

[coradi]

Why is var after type?
Doesn't it make sense to put globals variable more top?

Code: Pascal  [Select][+][-]

1. unit Unit1;
2.  
3. {$mode objfpc}{$H+}
4.  
5. interface
6.  
7. uses
8.   Classes, SysUtils, Forms, Controls, Graphics, Dialogs;
9.  
10. type
11.   TForm1 = class(TForm)
12.   private
13.  
14.   public
15.  
16.   end;
17.  
18. var
19.   Form1: TForm1;
20.  
21. implementation
22.  
23. {$R *.lfm}
24.  
25. end.

       

[440bx]

var comes after type because when you declare a var you need to know the type of the var.  You can't say

Code: Pascal  [Select][+][-]

1. var : I_don't_know_the_type_yet_I_ll_figure_it_out_later;

and expect that to compile.  Clairevoyant compilers are not a thing yet.

HTH.

[coradi]

ah, ok, yes, that make sense

[creaothceann]

Doesn't it make sense to put globals variable more top?

Constants, types and variables can be placed in any order because they can reference each other.

For example a constant can be defined as const MyConst = SizeOf(MyType) + 10, or a variable can be defined as var MyVar : MyType = high(MyType).

[cdbc]

Hi
Pascal = 'Declare before use', simple as that.
Regards Benny

[coradi]

ist VAR x y Z not declare?
Is TYPE xyz not Declare too?

[Thaddy]

No, although technically both are also declarations.
Type provides the formal description also known as  declaration or definition
Var provides the implementation for what is described for the type also know as declaration or instantiation.

Therefor type needs to be before var since var implements type.
A var is an instance of a type
types are not variables.

[LeP]

While we're on the subject, another thing that can be useful is to use a type before its definition.
This can be done if it's used in the same declaration block where the type is declared (WORKS ONLY FOR TYPES):

Code: Pascal  [Select][+][-]

1. type
2.   IForm1 = ^TForm1;                   //<--TForm1 is used before it's declaration, but inside the same block. THIS IS OK and compiles.
3.  
4.   TForm1 = class(TForm)
5.     Button1: TButton;
6.   private
7.     { Private declarations }
8.   public
9.     { Public declarations }
10.   end;

Code: Pascal  [Select][+][-]

1. type
2.   IForm1 = ^TForm1;                   //<--TForm1 is used before it's declaration, but OUTSIDE the declaration block. THIS IS NOT OK and doesn't compile !!!
3.  
4. type
5.   TForm1 = class(TForm)
6.     Button1: TButton;
7.   private
8.     { Private declarations }
9.   public
10.     { Public declarations }
11.   end;

[Xenno]

It is also possible:

Code: Pascal  [Select][+][-]

1. type
2.   TClassA = class;
3.   TClassB = class
4.     FMyA: TClassA;
5.   end;
6.  
7. var
8.   NewA: TClassA;
9.   NewB: TClassB;
10.  
11. type
12.   TClassA = class
13.     FMyB: TClassB;
14.   end;

[Thaddy]

Yes, forward type declarations are possible but the var needs to follow otherwise the compiler errors with var X is not fully defined. You can not declare a var before the type is fully defined.

[jamie]

For those that are more internal, the compiler is designed to be a single pass compiler which makes it quicker to build applications.

 But there are some optimizers that can't be taken advantage of due to this method but, in today computers that might not be such a problem unless you were targeting small under powered devices where it makes a difference to have multiple pass compilers.

  So, in short, the compiler could do a complete sweep of the unit file to build all the type references and then do the code build on the second pass, but as far as I know that does not happen and for the most part it really isn't that beneficial. The best you have now is the ability to create a forward reference for a pointer to an item because the pointer is always the same size throughout. This includes forward references to class that have not yet been typed because they are further down the list in the file.

[Thaddy]

Although that is a good description even multipass compilers like clang and C++ will throw an error if a var is used before its type is defined.

[Xenno]

Try this:

Code: Pascal  [Select][+][-]

1. program Project1;
2.  
3. {$mode objfpc}{$H+}
4.  
5. uses
6.   {$IFDEF UNIX}
7.   cthreads,
8.   {$ENDIF}
9.   Classes
10.   { you can add units after this };
11.  
12. type
13.   TManager = class;
14.   TStaff = class
15.     Mgr: TManager;
16.     TheName: String;
17.   end;
18.  
19. var
20.   Cindy: TStaff;
21.   John: TManager;
22.  
23. type
24.   TManager = class
25.     HisStaff: TStaff;
26.     TheName: String;
27.   end;
28.  
29. begin
30.   John := TManager.Create;
31.   try
32.     John.TheName := 'Johnny B. Nice';
33.     Cindy := TStaff.Create;
34.     try
35.       Cindy.TheName := 'Cindy Crawying';
36.       Cindy.Mgr := John;
37.       John.HisStaff := Cindy;
38.       WriteLn('Cindy''s manager: ' + Cindy.Mgr.TheName);
39.       WriteLn('John''s staff: ' + John.HisStaff.TheName);
40.       ReadLn;
41.     finally
42.       Cindy.Free;
43.     end;
44.   finally
45.     John.Free;
46.   end;
47. end.

The output will be:

Cindy's manager: Johnny B. Nice
John's staff: Cindy Crawying

[Thaddy]

Yes, of course, but the announcement that the compiler can rely on the type being made is the same thing:
There is a definition for type before var.
BTW your example can bite.

[Warfley]

Well the better question is: Why do you need a global variable in the first place? The answer is actually that you don't. If you don't like the variable to be there you could also remove (move it to the LPR locally if statically created) or make it a singleton or something fancy like that.