как задать "мерность" масива и для каждого "измерения" максимальный индекс

[vova_]

нужно создать масив имеющий U динамических индексов

на подобии:

U:=...;
POLЕ: array[0..N(1)][0..N(2)][0..N(3)]...[0..N(U-1)][0..N(U)] of string;

Если такое возможно, то как производить присвоение такому масиву и как его правильно объявлять.
Если я слишком многого хочу так и скажите, буду искать другие пути.

И ещё, существует ли ограничение на сумму количеств значений которые принимают индексы многомерного масива.

Подскажите пожалуста.

[Пёсик]

В заголовке темы вопрос понятен, но в тексте уже пошло какое-то надругательство в виде: "динамических индексов"
Массив с динамической, т.е. неопределенной (или, точнее, задаваемой во время выполнения), размерностью в Дельфи объявить невозможно (если это не так, то пусть старшие товарищи меня поправят).

[Вадим Мошев]

Массив с динамической, т.е. неопределенной (или, точнее, задаваемой во время выполнения), размерностью в Дельфи объявить невозможно (если это не так, то пусть старшие товарищи меня поправят).

Вы ошиблись. Можно.

var A: array of integer;
begin
//.....
SetLength(A, N);// N - размерность массива
end;

http://www.delphi-manual.ru/lesson5.php?com=yes
ссылка в основном для атвора темы

Кроме вышеописанных, так называемых статических массивов, у которых количество элементов неизменно, в Delphi можно использовать динамические массивы, количество элементов в которых допускается изменять в зависимости от требований программы. Это позволяет экономить ресурсы компьютера, хотя работа с такими массивами происходит гораздо медленнее. Описываются динамические массивы аналогично статическим, но без указания диапазона индексов:

type TDinArray = array of Integer;
var A : TDinArray;

После создания в динамическом массиве нет ни одного элемента. Необходимый размер задаётся в программе специальной процедурой SetLength. Массив из ста элементов:

begin
SetLength(A, 100);
end;

[Пёсик]

Нет, речь идет не о динамических массивах как таковых, а о "динамической" размерности массивов, которую можно было бы устанавливать программно.

Например, если двухмерный статический массив объявляется так:
array[0..N, 0.. M] of ...
то динамический так:
array of array of ...
Последний с заранее неизвестным количеством элементов по каждой из размерности.
Но автору то надо объявить такой массив, размерность которого заранее неизвестна (может это будет двухмерный, а может дестимерный) и размерность которого определялась бы при выполнении.
Причем каждая размерность тоже не определена (т.е. массив динамический).
Понятно, что такое в Дельфи невозможно. Правда, объявляю с осторожностью - может кто додумался как это смастерить.

[GunSmoker]

Именно как динамический массив (array of) не получится. Но "легко" можно через указатели.

type
  TArrayItemType = Integer;

  PArray = ^TArray;
  PArrayItems = ^TArrayItems;
  TArrayItems = array[0..MaxInt div SizeOf(Pointer) - 1] of PArray;
  TArray = record
             Length: Integer;
             case Byte of
               0: (Item: TArrayItemType);
               1: (Items: PArrayItems);
           end;

function DArrayCreate(const ALength: Integer): PArray;
var
  Arr: PArray;
  X: Integer;
begin
  Arr := AllocMem(SizeOf(TArray));
  try
    Arr.Length := ALength;
    Arr.Items := AllocMem(SizeOf(TArray) * ALength);

    for X := 0 to ALength - 1 do
    begin
      Arr.Items[X] := AllocMem(SizeOf(TArray));
      Arr.Items[X].Length := -1;
    end;

    Result := Arr;
    Arr := nil;
  finally
    if Assigned(Arr) then
      FreeMem(Arr);
  end;
end;

procedure DArrayFree(var AArray: PArray); forward;

procedure DArrayFreeItems(var AArray: PArray);
var
  X: Integer;
begin
  if AArray = nil then
    Exit;

  if AArray.Length >= 0 then
  begin
    for X := 0 to AArray.Length - 1 do
      DArrayFree(AArray.Items[X]);
    FreeMem(AArray.Items);
  end;
end;

procedure DArrayFree(var AArray: PArray);
begin
  if AArray = nil then
    Exit;

  DArrayFreeItems(AArray);
  FreeMem(AArray);
  AArray := nil;
end;

function DArrayLength(const AArr: PArray): Integer;
begin
  Assert(Assigned(AArr),   'DArrayLength: AArr = nil');
  Assert(AArr.Length >= 0, Format('DArrayLength: AArr.Length = %d', [AArr.Length]));
  Result := AArr.Length;
end;

procedure DArraySetItem(const AArr: PArray; const AIndex: Integer; const AItem: TArrayItemType); overload;
begin
  Assert(Assigned(AArr),        'DArraySetItem: AArr = nil');
  Assert(AArr.Length >= 0,      Format('DArraySetItem: AArr.Length = %d', [AArr.Length]));
  Assert(AIndex >= 0,           Format('DArraySetItem: AIndex = %d', [AIndex]));
  Assert(AIndex < AArr.Length,  Format('DArraySetItem: AIndex = %d < AArr.Length = %d', [AIndex, AArr.Length]));
  if AArr.Items[AIndex].Length >= 0 then
  begin
    DArrayFreeItems(AArr.Items[AIndex]);
    AArr.Items[AIndex].Length := -1;
  end;
  AArr.Items[AIndex].Item := AItem;
end;

procedure DArraySetItem(const AArr: PArray; const AIndex: Integer; const AItem: PArray); overload;
begin
  Assert(Assigned(AArr),        'DArraySetItem: AArr = nil');
  Assert(AArr.Length >= 0,      Format('DArraySetItem: AArr.Length = %d', [AArr.Length]));
  Assert(AIndex >= 0,           Format('DArraySetItem: AIndex = %d', [AIndex]));
  Assert(AIndex < AArr.Length,  Format('DArraySetItem: AIndex = %d < AArr.Length = %d', [AIndex, AArr.Length]));
  if AArr.Items[AIndex].Length >= 0 then
    DArrayFreeItems(AArr.Items[AIndex]);
  AArr.Items[AIndex] := AItem;
end;

function DArrayGetItem(const AArr: PArray; const AIndex: Integer): TArrayItemType;
begin
  Assert(Assigned(AArr),                 'DArrayGetItem: AArr = nil');
  Assert(AArr.Length >= 0,               Format('DArrayGetItem: AArr.Length = %d', [AArr.Length]));
  Assert(AIndex >= 0,                    Format('DArrayGetItem: AIndex = %d', [AIndex]));
  Assert(AIndex < AArr.Length,           Format('DArrayGetItem: AIndex = %d < AArr.Length = %d', [AIndex, AArr.Length]));
  Assert(AArr.Items[AIndex].Length < 0,  Format('DArrayGetItem: AIndex = %d, AArr.Items[AIndex].Length = %d', [AIndex, AArr.Items[AIndex].Length]));
  Result := AArr.Items[AIndex].Item;
end;

procedure TForm172.FormCreate(Sender: TObject);
var
  Arr: PArray;
  X, Y: Integer;
  Str: String;
begin
  Arr := DArrayCreate(5);
  try
    for X := 0 to DArrayLength(Arr) - 1 do
      DArraySetItem(Arr, X, DArrayCreate(4));

    Arr.Items[0].Items[0].Item := 1;
    Arr.Items[0].Items[1].Item := 2;
    Arr.Items[0].Items[2].Item := 3;
    Arr.Items[0].Items[3].Item := 4;

    Arr.Items[4].Items[0].Item := 10;
    Arr.Items[4].Items[1].Item := 20;
    Arr.Items[4].Items[2].Item := 30;
    Arr.Items[4].Items[3].Item := 40;

    for X := 0 to DArrayLength(Arr) - 1 do
    begin
      Str := '';
      for Y := 0 to DArrayLength(Arr.Items[X]) - 1 do
        Str := Str + IntToStr(Arr.Items[X].Items[Y].Item) + ' '#9;

      Memo1.Lines.Add(Str);
    end;

  finally
    DArrayFree(Arr);
  end;
end;

[vova_]

масивный овет
буду изучать
надо вникнуть
спасибо всем отозвавшимся
а то я не мого представить пока другого пути без такого рода масивов

а может есть такой изврат в другом язике програмирования
две подпрограммы както уж склею.

уж не впервой на етот вопрос так никто и не отозвался: http://programmersforum.ru/showthread.php?t=180125 пришлось лепить фортран с делфи

буду благодарен за любые, даже наводящие ответы по обоим темам