Pascal procedure pass variable arrays

MartynA gave you the hint to look at "open array parameters" in the online help. But it is not necessary to do what he proposes, using ArrayLoBound etc. The declaration of the actual array can have any index range.

I would do this:

program OpenArrayTest;

{$APPTYPE CONSOLE}

var
  { Initialization like this only possible for global variables. }
  Arr: array[11..15] of string = ('once', 'doce', 'trece', 'catorce', 'quince');
  I: Integer;

procedure ModifyArray(var A: array of string);
var
  I: Integer;
begin
  for I := Low(A) to High(A) do
    A[I] := A[I] + ' <-- ' + IntToStr(I);
end;

procedure ShowArray(const A: array of string);
begin
  for I := Low(A) to High(A) do
    Writeln(A[I]);
end;

begin
  ModifyArray(Arr);
  ShowArray(Arr);
  Writeln('-----');
  ShowArray(['one', 'two', 'three', 'four', 'five', 'six', 'seven']);
  Readln;
end.

The output is:

once <-- 0
doce <-- 1
trece <-- 2
catorce <-- 3
quince <-- 4
-----
one
two
three
four
five
six
seven

In other words, use High() and Low() to access the items in the parameter. Do not use any fixed bounds, since the array can have any length. Also note that you can get the number of items in the array using Length(A) or Length(Arr). You can not only pass static arrays, like Arr, you can also pass dynamic arrays, or use an open array constructor (using [ and ]), like I did in the second call to ShowArray().

More about open arrays in my article "Open arrays and array of const".

Judging by your comment, you are in a bit of a muddle.

In short, if you declare a parameter to a procedure to be an "array of", the array is always zero-based, regardless of the structure of the array you pass to it as an argument, as in

  test(arr);

Try the code below. You'll find that when it runs, you get a Range-Check error on the line

  a[5] := 'five';

That's because although arr has five elements, they are numbered 0..4, so there is no element of arr with index 5.

Although there are other was to declare procedure parameters, if you want to pass arrays to it as arguments, you have to make sure that either you mentally translate the array indexes as you write the code or (better) you declare the arrays you pass to it as zero-based, as I've done.

And, try and make a habit of turning range-checking on. It will catch error you yourself may overlook.

I'm going to leave you to rewrite your test procedure so that it works correctly as an exercise, because I'm "guessing" that what you've posted is some kind of school- or course-work and you should really put some effort into finding out how to correct your error yourself. If you're still stuck after reading this and trying the obvious solution, ask.

Btw, if you are using Delphi, look up "Open array parameters" in the Online Help. That explains the restrictions on using "array of ..." procedure-parameters.

Also btw, Rudy Velthuis says in his answer "But it is not necessary to do what {MartynA] proposes, using ArrayLoBound etc." That is true, it is not necessary but he has missed my point. If you hard-code array bounds, with values like 1 and 5, and then change them later, it is easy to overlook other values that need updating too, like in your for loop. Defining these values as consts is a good habit to get into because it avoids introducing inconsistencies, but more importantly makes sure you think about what you are doing. IME ...

program arrayparam;

const
  ArrayLoBound = 0;
  ArrayHiBound = 4;

var
  arr : array[ArrayLoBound..ArrayHiBound] of string;
  i : integer;

{$R+}  // Turn range-checking on

procedure test(var a : array of string);
var
  i : integer;
begin
  a[1] := 'one';
  a[2] := 'two';
  a[3] := 'three';
  a[4] := 'four';
  a[5] := 'five';
  for i := 1 to 5 do
    writeln(a[i]);
end;

begin
  test(arr);
  writeln('-----');

  for  i := ArrayLoBound to ArrayHiBound do
  begin
    writeln(arr[i]);
    if arr[i] = '' then
      writeln('NOTHING');
  end;
  readln
end.

All good answers but just to be complete: the asker can get exactly the result asked for.

It could be that accessing them using 1 to 5 is important for the asker's purposes.

Make the changes below and it will print out as originally expected.

type

TArr = array[ 1..5 ] of string;

var

arr : TArr;

procedure test( var a : TArr );

I agree that defaulting to 0 based arrays is simply easier and using the functions low / hi make it bulletproof.

But I can also see that sometimes indexing in your own way could be of use / important.