why two aliases to “array of string” treated differently?

Question

In Pascal there are two kinds of type declarations:

• type aliases: type NewName = OldType
• type creation: type NewType = type

Answer 1

I also had the same problem with Delphi, where I wanted to pass values from one identical array to another. Not only did I have "incompatibility" problems with two like array assignments, but I also could not use the "Copy()" procedure. To get around this problem, I found that I could use a pointer to an type array of array of string, instead.

For example:

type RecArry = array of array of string
     end;
var TArryPtr : ^RecArry;

Now, I can pass the values from any fixed array to another identical array without any compatibility or function problems. For example:

TArryPtr := @RecArry.LstArray //This works!
TArryPtr := @LstArray         //This also works!

With this created array assignment template, I can now work with all two dimensional arrays without any problems. However, it should be understood, that when accessing this type of string array pointer, an extra element is created, so that when we would expect this type of array 2D array below, for example:

Two_Dimensional_Fixed_Array[10][0]

We now get an extra element adjusted array as seen here:

New_Two_Dimensional_Fixed_Array[10][1]    

This means that we have to use some slightly tricky code to access the pointer array, because all the populated elements in Two_Dimensional_Fixed_Array[10][0] have moved down, so that they are offset by 1, as in New_Two_Dimensional_Fixed_Array[10][1].

Therefore where we would normally find the value 'X' in Two_Dimensional_Fixed_Array[1][0], it will now be found here in TArryPtr[0][1].

Its a trade off we all have to live with!

Another important note to bear in mind is the definition of a pointer array when it is declared. When a pointer array is type declared, the Borland compiler will not allow the Pointer array to have the same element size as the array to which it is pointing too. For example, if an array is declared as:

Orig_Arry : array [1..50,1] of string;

The pointer array which should point to it would be declared in the following fashion:

Type Pntr_Arry : array [1..50,2] of string;

Did you notice the the extra element? I am guessing the the Borland compiler has to widen the array pointer to allow for the pointer address.