Class doesn't work when defined as a global variable in delphi

Question

I created a simple class to explain my problem:

ttest =class
private
   val:boolean;
published
   function get:boolean;
end;

...

function ttest.get: boolean;
begin
   val:=not val;
   result:=val;
end;

Now if I declare a local ttest variable and call my_var.get; then everything works, but if I declare it as a global variable then it can't access the val field anymore, it shows an error message which says "Access violation...". I read some articles about classes in Delphi but still can't find my mistake.

Answer 1

You've neglected to instantiate the class.

Global class-reference variables are initialized to nil , whereas local variables are not initialized at all. The local variable has a value determined by whatever happened to be on the stack at the time you called your function, and your program is interpreting that value as though it were a TTest reference even though it's really not. Your program then reads the value at that memory address to get the value that would represent the val field.

The only reason your code appears to work with a non-global variable is luck. Whether it's good luck or bad is another matter. (Good luck, since your code appeared to work, and working code is always nice. Bad luck, since you'd have been alerted to your mistake earlier if your code had crashed.)

Instantiate a class before you use references to it.

x := TTest.Create;

Now you can access fields, methods, and properties of the object via the x variable.

You should have gotten a compiler warning when you attempted to use a local variable without assigning a value to it first. Although they're just warnings, and your program will still run, never ignore a warning or even a hint. When the compiler bothers to complain about something, it's usually right.

Answer 2

In Delphi object variables are always pointers. Before you can use the variable you need to initialize it with a reference to an object. The most common way to do that is to create a new object of the particular class.

procedure Foo;
var
  Obj: TObject;
begin
  Obj := TObject.Create;
  try
    // Do stuff with Obj
  finally
    Obj.Free;
  end;
end;

In this case Obj starts out as an uninitialized pointer (it will point to random memory). It is only after we assign the newly created TObject that Obj is a valid object reference.

In Delphi there is no automatic garbage collection for objects, so you always need to call free on them when you are done using them. If you declare a global or local object variable, you can initialize it the special initialization section of the unit and free the object in the finalization section.

unit myunit;

interface

var
  Obj: TObject;

implementation

initialization

Obj := TObject.Create;

finalization

Obj.Free;

end.

Variables declared in the interface section are globally visible, variables declared in the implementation section are only visible inside the unit. It should be noted that declaring a global object variable means that any unit can overwrite the variable with a reference to a new object without freeing the existing object first. This would cause a memory leak as again there is no automatic garbage collection.

Answer 3

A delphi class is basically just a description, not the object itself. You describe the properties and methods the final object should have. And the missing piece of the puzzle is that you havent really told Delphi to create an object from your class.

This is done by calling the constructor:

mMyInstance:=TTest.Create;

The constructor takes the class description and builds an object instance for you in memory. It returns a pointer to the object which you must store in a variable (myInstance in the above example) of the same type.

Reading your question, I suspect you want to create an object that is "always there", a bit like the printer object. This is easy to do, but just like the printer object - you must include that unit before you can access the object. I think Anders E. Andersen above has shown how most people would initialize an object from a unit centric point of view.

If you want the object to be reachable from another unit, say your mainform or any other unit, first add "myunit" to the uses list. Then to make it visible you add a function, like this:

function test:ttest;
Begin
  result:=obj;
end;

And remember to add "function test:TTest" to the interface section of the unit. Then you can use the object from another unit as such:

myUnit.test.get;

But be warned! This is pretty old school programming, and you run the risk of your unit being released (which calls finalization and thus destroys your object) before the other units are done with it. Thus you risk calling a function in an object which no longer exists in memory - causing a spectacular access violation when your program closes.

If you want to learn Delphi properly, head over to Delphi Basics and read up on the basic principles. It takes a while to learn a new language but you will soon get the hang of it.

Good luck!