Delphi: What are the advantages of using System.New() instead of a local variable, other than just spare a tiny amount of memory?

Question

Let's go back to the basics. Frankly, I have never used New and Dispose functions before. However, after I read the New() documentation and the included examples on the Embarcadero Technologies's website and the Delphi Basics explanation of New(), it leaves questions in my head:

What are the advantages of using System.New() instead of a local variable, other than just spare a tiny amount of memory?

Common code examples for New() are more or less as follows:

  var
      pCustRec : ^TCustomer;
  begin
      New(pCustRec);
      pCustRec^.Name := 'Her indoors';
      pCustRec^.Age  := 55;
      Dispose(pCustRec);
  end;

In what circumstances is the above code more appropriate than the code below?

  var
      CustRec : TCustomer;
  begin
      CustRec.Name := 'Her indoors';
      CustRec.Age  := 55;
  end;

Answer 1

If you can use a local variable, do so. That's a rule with practically no exceptions. This results in the cleanest and most efficient code.

If you need to allocate on the heap, use dynamic arrays, GetMem or New. Use New when allocating a record.

Examples of being unable to use the stack include structures whose size are not known at compile time, or very large structures. But for records, which are the primary use case for New, these concerns seldom apply.

So, if you are faced with a choice of stack vs heap for a record, invariably the stack is the correct choice.

Answer 2

From a different perspective:

Both can suffer from buffer overflow and can be exploited.

If a local variable overflows, you get stack corruption.

If a heap variable overflows, you get heap corruption.

Some say that stack corruptions are easier to exploit than heap corruptions, but that is not true in general.

Note there are various mechanisms in operating systems, processor architectures, libraries and languages that try to help preventing these kinds of exploits.

For instance there is DEP (Data Execution Prevention), ASLR (Address Space Layout Randomization) and more are mentioned at Wikipedia.

Answer 3

A local static variable reserves space on the limited stack. Allocated memory is located on the heap, which is basically all memory available.

As mentioned, the stack space is limited, so you should avoid large local variables and also large parameters which are passed by value (absence of var/const in the parameter declaration).

A word on memory usage:
1. Simple types (integer, char, string, double etc.) are located directly on the stack. The amount of bytes used can be determined by the sizeof(variable) function.
2. The same applies to record variables and arrays. 3. Pointers and Objects require 4/8 bytes.