Funkcja z tablicą

Czy da sie zrobic w pascalu funkcje której wartosc bedzie tablica? Chodzi mi o funkcje która posortuje tablice.

Używanie funkcji, która zwraca jako wartość posortowaną tablicę jest nie do końca potrzebne.
Można to zrealizować za pomocą procedury w dwojaki sposób. Pierwszy z nich sortuje oryginalną tablicę:

type 
 TTab = array [0..9] of Byte;

var STab, DTab :TTab;

procedure Sort(var ATab :TTab);
begin
 { sortowanie ATab}
end;

{ wywołanie }
Sort(STab);

Drugi sposób to wykonanie kopii tablicy, posortowanie jej i przekazanie do jako parametr:

procedure Sort(const Source :TTab; var Dest :TTab);
begin
 Dest := Source;
 { sortowanie desta }
end; 
{ wywołanie }
Sort(STab, DTab);

Użycie w nagłówku procedury modyfikatorów

const

i var

 da nam gwarancję, że Source nie będzie modyfikowane, a Dest będzie zwrócone.

Poniżej zamieszczam przykładowy program napisany przez Borlanda w Turbo Pascalu. Przedstawia on algorytm QSort

```delphi
{************************************************}
{                                                }
{ QuickSort Demo                                 }
{ Copyright (c) 1985,90 by Borland International }
{                                                }
{************************************************}

program QSort;
{$R-,S-}
uses Crt;

{ This program demonstrates the quicksort algorithm, which      }
{ provides an extremely efficient method of sorting arrays in   }
{ memory. The program generates a list of 1000 random numbers   }
{ between 0 and 29999, and then sorts them using the QUICKSORT  }
{ procedure. Finally, the sorted list is output on the screen.  }
{ Note that stack and range checks are turned off (through the  }
{ compiler directive above) to optimize execution speed.        }

const
  Max = 1000;

type
  List = array[1..Max] of Integer;

var
  Data: List;
  I: Integer;

{ QUICKSORT sorts elements in the array A with indices between  }
{ LO and HI (both inclusive). Note that the QUICKSORT proce-    }
{ dure provides only an "interface" to the program. The actual  }
{ processing takes place in the SORT procedure, which executes  }
{ itself recursively.                                           }

procedure QuickSort(var A: List; Lo, Hi: Integer);

procedure Sort(l, r: Integer);
var
  i, j, x, y: integer;
begin
  i := l; j := r; x := a[(l+r) DIV 2];
  repeat
    while a[i] < x do i := i + 1;
    while x < a[j] do j := j - 1;
    if i <= j then
    begin
      y := a[i]; a[i] := a[j]; a[j] := y;
      i := i + 1; j := j - 1;
    end;
  until i > j;
  if l < j then Sort(l, j);
  if i < r then Sort(i, r);
end;

begin {QuickSort};
  Sort(Lo,Hi);
end;

begin {QSort}
  Write('Now generating 1000 random numbers...');
  Randomize;
  for i := 1 to Max do Data[i] := Random(30000);
  Writeln;
  Write('Now sorting random numbers...');
  QuickSort(Data, 1, Max);
  Writeln;
  for i := 1 to 1000 do Write(Data[i]:8);
end.

Lepiej zadeklarować tzw. tablicę otwartą (open array). Nie jesteś wtedy ograniczony ilością elementów i jako argumentu funkcji możesz użyć zarówno array[0..10]of byte jak i array[1..102] of byte.

procedure Sortuj(var Tab: array of byte);
begin
  Low(Tab); //fcja zwracająca najmniejszy indeks
  High(Tab); //fcja zwracająca największy indeks
end;

Jeśli chciałbyć jako argumentu użyć tablicy dynamicznej, to wcześniej musisz zadeklarować jej typ:

type TablicaDynamiczna = array of byte;
procedure Sortuj(const Tab: TablicaDynamiczna);

Jeśli nie zmieniasz ilości elementów tablicy, to warto zastosować modyfikator const przed taką zmienną, bo Tab w istocie jest tylko wskaźnikiem. Nie można zapominać, że bez żadnego modyfikatora nie uzyskamy tutaj kopii tablicy, tylko także wskaźnika. Jeśli natomiast chcesz modyfikować ilość wyrazów tablicy, to zastosuj słowo kluczowe var.

//ups, rzeczywiscie, dynamiczne nie dzialaja... ale otwarte? zawsze bylem przekonany, ze tak :>

czytaj uważnie - to ma być w TP a tam nie ma open array