CODEWITHSUNDEEP
pointersdelphipascal
Gus Mueller
Gus Mueller

Reputation: 375

in Delphi 5, is a TList parameter always passed by reference?

I am migrating some code from Delphi 5 to a modern platform. Currently I have the compiled code (which works in my environment) and the source code (which cannot be compiled in my environment). This means I can't really experiment with the code by changing it or inserting breakpoints or dumping values. In looking at one particular passage of code, I see that one Procedure (ProcedureA) is calling another (ProcedureB) and passing in parameters that must be by reference, since otherwise ProcedureB would have no effect. It's my understanding that a var prefix must be added to parameters in a Procedure's parameter list in order for them to be passed by reference, but this is not being done here. One of the parameters, though, is of type TList, which I know to be essentially an array of pointers. My question is: are parameters of type TList (as well as others having to do with pointers) implicitly passed by reference?

Here's the code:

Procedure ProcedureB(PartyHeaderInformationPtr : PartyHeaderInformationPointer;
                                                PartyHeaderTable : TTable;
                                                _PrisonCode : String;
                                                _FineType : TFineTypes;
                                                PartyHeaderInformationList : TList);

begin
  with PartyHeaderInformationPtr^, PartyHeaderTable do
    begin
      AssessmentYear := FieldByName('TaxRollYr').Text;
      PartyType := FieldByName('PartyType').Text;
      PartyNumber := FieldByName('PartyNo').AsInteger;
      PrisonCode := _PrisonCode;
      FineType := _FineType;

    end;  {with PartyHeaderInformationPtr^ ...}

  PartyHeaderInformationList.Add(PartyHeaderInformationPtr);

end;  {AddPartyHeaderPointerInformation}

{=================================================================}
Procedure ProcedureA(PartyHeaderTable : TTable;
                                              PartyDetailTable : TTable;
                                              PartyHeaderInformationList : TList);

var
  Done, FirstTimeThrough : Boolean;
  PrisonPartyFound, JunglePartyFound : Boolean;
  PrisonPartyYear, PrisonCode, PartyType : String;
  PartyHeaderInformationPtr : PartyHeaderInformationPointer;

begin
  PartyHeaderTable.Last;
  PrisonPartyYear := '';
  PrisonPartyFound := False;
  JunglePartyFound := False;
  Done := False;
  FirstTimeThrough := True;

  repeat
    If FirstTimeThrough
      then FirstTimeThrough := False
      else PartyHeaderTable.Prior;

    If PartyHeaderTable.BOF
      then Done := True;

    If not Done
      then
        begin
          PartyType := PartyHeaderTable.FieldByName('PartyType').Text;

          If ((not JunglePartyFound) and
              ((PartyType = 'MU') or
               (PartyType = 'TO')))
            then
              begin
                JunglePartyFound := True;

                New(PartyHeaderInformationPtr);

                AddPartyHeaderPointerInformation(PartyHeaderInformationPtr,
                                                      PartyHeaderTable,
                                                      '', ltPlace,
                                                      PartyHeaderInformationList);

              end;  {If ((not JunglePartyFound) and ...}

        end;  {If not Done}

  until Done;

end;  {FillPartyHeaderInformationList}

Upvotes: 1

Views: 671

Answers (1)

Andreas Rejbrand
Andreas Rejbrand

Reputation: 109003

Yes.

In Delphi, classes are reference types.

Every variable of type TBitmap, TList, TButton, TStringList, TForm etc. is nothing but a pointer to the object, so an object is always passed "by reference". It is only this address, this native-sized integer, that is given to the called routine.

Consequently, even without var, the called routine can alter the object since it, like the caller, has the address to it. But the pointer itself is passed by value, so if the called routine alters the parameter pointer to point to a different object, the caller will not see that; only the called routine's copy of the address is changed. With var, the pointer itself is passed by reference, so the called routine can change that too: it can change the original object, and it can make the caller's variable point to a different object, if it wants to.

On the other hand, value types like integers, booleans, sets, static arrays, and records are passed by value, so -- without any parameter decoration such as var -- the called routine gets a copy, and any changes made are only made to that copy. The caller will not see its variable being modified. If you use a var parameter, however, the variable will be passed by reference.

So, in your case, it has nothing to do with TList being a "list" or being something that "contains pointers". It's about TList being a class.

Upvotes: 8

Related Questions