Assigned vs <> nil

Question

Is there any difference between If Assigned(Foo) and If (Foo <> nil)? If So, when should they each be used?

Answer 1

TL;DR

The official documentation states

Assigned(P) corresponds to the test P <> nil for a pointer variable, and @P <> nil for a procedural variable.

Hence, for a non-procedural pointer variable (such as a variable of type PInteger, PMyRec, TBitmap, TList<integer>, or TFormClass), Assigned(P) is the same thing as P <> nil.

However, for a procedural variable, Assigned(P) is the same thing as @P <> nil, while P <> nil would try to execute the procedure or function that P points to (with an empty list of parameters).

Explanation

The documentation excerpt above summarizes it pretty well. Assigned(X) returns True if and only if the X variable, which has to be a pointer under the hood (with some exception), has a non-nil value.

Assigned can be used for "old-school" pointer variables:

var
  i: Integer;
  p: PInteger;
begin
  i := 5;

  p := @i;
  { Assigned(p)        True }
  { p <> nil           True }

  p := nil;
  { Assigned(p)        False }
  { p <> nil           False }

Assigned can also be used for object (and metaclass) variables. Indeed, in Delphi, an object (or metaclass) variable is simply a pointer under the hood:

L := TList<integer>.Create;
try
  { Assigned(L)        True }
  { L <> nil           True }
finally
  FreeAndNil(L);
end;

{ Assigned(L)          False }
{ L <> nil             False }

(And, for completeness, an example with a metaclass variable:

var
  FC: TFormClass;
begin

  FC := TForm;
  { Assigned(FC)       True }
  { FC <> nil          True }

  FC := nil;
  { Assigned(FC)       False }
  { FC <> nil          False }

)

In all these examples, Assigned(X) is exactly the same thing as X <> nil.

However, for procedural types, things are slightly different.

First, let's warm up:

type
  TStringProc = procedure(const AText: string);

procedure MyStrProc(const AText: string);
begin
  ShowMessage(AText);
end;

procedure TForm1.FormCreate(Sender: TObject);
var
  SP: TStringProc;
begin
  SP := MyStrProc;
  SP('test');
end;

Notice in particular that SP is used to actually invoke the procedure it currently points to.

Now, you might try

procedure TForm1.FormCreate(Sender: TObject);
var
  SP: TStringProc;
begin
  SP := MyStrProc;
  ShowMessage(BoolToStr(Assigned(SP), True)); { True }
  ShowMessage(BoolToStr(SP <> nil, True)); { will not compile }

  SP := nil;
  ShowMessage(BoolToStr(Assigned(SP), True)); { False }
  ShowMessage(BoolToStr(SP <> nil, True)); { will not compile }
end;

but that will not even compile. The compiler says, "Not enough actual parameters". The reason is that the above code will try to execute the procedure that SP points to, and then indeed the required AText parameter is missing. (Of course, at compile time, the compiler doesn't know if SP will point to a compatible procedure or not, but it does know the signature of such a valid procedure.)

And even if the procedural type had an empty parameter list, it wouldn't compile, since a procedure doesn't return a value (much less a value that can be compared against nil).

But beware! The following code will compile:

type
  TGetPtrFunc = function: pointer;

function MyPtrFunc: pointer;
begin
  Result := nil;
end;

procedure TForm1.FormCreate(Sender: TObject);
var
  PF: TGetPtrFunc;
begin
  PF := MyPtrFunc;
  ShowMessage(BoolToStr(Assigned(PF), True)); { True }
  ShowMessage(BoolToStr(PF <> nil, True)); { False (!) }

  PF := nil;
  ShowMessage(BoolToStr(Assigned(PF), True)); { False }
  ShowMessage(BoolToStr(PF <> nil, True)); { will cause access violation at runtime }
end;

The first PF <> nil will compare the MyPtrFunc function result value against nil; it will not tell you whether the PF function pointer is assigned or not (it is!).

The second PF <> nil will try to invoke a nil function pointer; that's a bug (access violation exception).

To test if a procedural variable is assigned, you have to test @PF <> nil:

procedure TForm1.FormCreate(Sender: TObject);
var
  SP: TStringProc;
begin
  SP := MyStrProc;
  ShowMessage(BoolToStr(Assigned(SP), True)); { True }
  ShowMessage(BoolToStr(@SP <> nil, True)); { True }

  SP := nil;
  ShowMessage(BoolToStr(Assigned(SP), True)); { False }
  ShowMessage(BoolToStr(@SP <> nil, True)); { False }
end;

procedure TForm1.FormCreate(Sender: TObject);
var
  PF: TGetPtrFunc;
begin
  PF := MyPtrFunc;
  ShowMessage(BoolToStr(Assigned(PF), True)); { True }
  ShowMessage(BoolToStr(@PF <> nil, True)); { True }

  PF := nil;
  ShowMessage(BoolToStr(Assigned(PF), True)); { False }
  ShowMessage(BoolToStr(@PF <> nil, True)); { False }
end;

For procedural variables, Assigned(X) is the same thing as @X <> nil, as stated by the documentation.

Methods

Methods work as regular procedures as far as this topic is concerned. For instance, for a method variable M, Assigned(M) is equivalent to @M <> nil and is True iff the method pointer is not nil. (Under the hood, I believe @M yields the Code member of TMethod.)

procedure TForm1.FormCreate(Sender: TObject);
var
  M: TNotifyEvent;
begin
  M := Self.FormClick;
  ShowMessage(BoolToStr(Assigned(M), True)); { True }
  ShowMessage(BoolToStr(@M <> nil, True)); { True }

  M := nil;
  ShowMessage(BoolToStr(Assigned(M), True)); { False }
  ShowMessage(BoolToStr(@M <> nil, True)); { False }
end;

What to use?

So, should you use Assigned(X) or X <> nil for non-procedural pointers? And should you use Assigned(X) or @X <> nil for procedural pointers? It is entirely a matter of taste.

Personally, I tend to use Assigned(X) when I want to test if the variable is assigned, and X = nil (or @X = nil) when I want to test if the variable is not assigned, simply because not Assigned(X) is less compact.

A related warning

Of course, both Assigned(X) and X <> nil (or @X <> nil) only test if the pointer is nil or not; if non-nil, the pointer might still point to garbage. For instance, since local non-managed variables are not initialized in Delphi, they might well be non-nil before they are assigned a value, but in that case they point to garbage:

procedure TForm1.FormCreate(Sender: TObject);
var
  L: TList<integer>; { local non-managed variable: not initialized }
begin
  Assigned(L) { True or False (chance). If True, it points to garbage data. }
              { Bad things will happen if you try to use L as a list here }
              { (especially if L is not nil). }

Another example:

  L := TList<integer>.Create;
  try
    { Do things with L }
  finally
    L.Free;
  end;

  Assigned(L); { True, but L points to garbage -- don't use it as a list! }