Question

I have been developing for some time now, and I have not used pointers in my development so far.

So what are the benefits of pointers? Does an application run faster or uses fewer resources?

Because I am sure that pointers are important, can you “point” me to some articles, basic but good to start using pointers in Delphi? Google gives me too many, too special results.

Answer 1

A pointer is a variable that points to a piece of memory. The advantages are:

• you can give that piece of memory the size you want.
• you only have to change a pointer to point to a different piece of memory which saves a lot of time copying.

Delphi uses a lot of hidden pointers. For example, if you are using:

var   myClass : TMyClass; begin   myClass := TMyClass.Create; 

myClass is a pointer to the object.

An other example is the dynamic array. This is also a pointer.

To understand more about pointers, you need to understand more about memory. Each piece of data can exist in different pieces of data.

For example global variables:

unit X;  interface  var   MyVar: Integer; 

A global variable is defined in the datasegment. The datasegment is fixed. And during the lifetime of the program these variables are available. Which means the memory can not be used for other uses.

Local variables:

procedure Test; var   MyVar: Integer; 

A local variable exists on the stack. This is a piece of memory that is used for housekeeping. It contains the parameters for the function (ok some are put in a register but that is not important now). It contains the return adress so the cpu knows where to return if the program has ended. And it contains the local variables used in the functions. Local variables only exists during the lifetime of a function. If the function is ended, you can’t access the local variable in a reliable way.

Heap variables:

procedure Test2; var   MyClass: TMyClass; begin   MyClass := TMyClass.Create; 

The variable MyClass is a pointer (which is a local variable that is defined on the stack). By constructing an object you allocate a piece of memory on the heap (the large piece of ‘other’ memory that is not used for programs and stacks). The variable MyClass contains the address of this piece of memory. Heap variables exist until you release them. That means that if you exit the funcion Test2 without freeing the object, the object still exists on the heap. But you won’t be able to access it because the address (variable MyClass) is gone.

Best practices

It is almost always preferably to allocate and deallocate a pointer variable at the same level.

For example:

var   myClass: TMyClass; begin   myClass := TMyClass.Create;   try     DoSomething(myClass);     DoSomeOtherthing(myClass);   finally     myClass.Free;   end; end; 

If you can, try to avoid functions that return an instance of an object. It is never certain if the caller needs to dispose of the object. And this creates memory leaks or crashes.