alternative zu "array" in TP gesucht

Da ein array unter TP nur max. 64K gross sein kann, suche ich eine einfache altenative.
thx

Hi,

TP ?
Turbo-Pascal ?
unter Dos ?
unter Windows (Delphi)?

bischen genauer bitte !


CU

Ja, in TP unter Dos. Möchte Daten in array speichern und anschliessend auf HD übertragen. Habe schon gedacht direkt auf HD zu speichern, habe aber "Angst" das Daten verloren gehen. Die Daten die ich speichern möchte kommen vom UART (Polling, max 115K). Vielleicht weiss ja jemand eine einfache Altenative oder jemand sagt mir das ich keine Angst haben zu brauche.
thx

Also ich würde die Daten als file (Ramdrive) speichern. Oder Du mußt mit ^Pointern und dynamischer Speicherreservierung GetMem arbeiten.

Das mit dem Ramdrive ist einfacher. Wenn Du die Daten auf dauer behalten willst, umkopieren nicht vergessen !!

Dynamische Speicherverwaltung gehört zur hohen Kunst in Pascal (Kunst kommt von können ). Davor wollte ich mich ja eigentlich drücken, aber so wie es ausieht komme ich nicht drum herum. Ramdrive ist eine alternative, vielleicht gibt es ja noch andere Möglichkeiten.

thx

Es gibt die Alternative: Pointer!

Hab's zwar schon lange nicht mehr gemacht, aber ich such mal die Routinen raus. Damit kannst du große Speichermengen mit kleinem Stack verwalten.

TT

Hier habe ich einen Code. Der sollte funktionieren:

TYPE
PListe = ^TListe;
TListe = Object
next: PListe;
CONSTRUCTOR Init;
Function count;
Procedure Insert(pListe);
End;

PData = ^TData;
TData = Object (TListe)
Xdata: byte;
CONSTRUCTOR Init(x:Byte);
PROCEDURE XOut;
End;

CONSTRUCTOR TListe.Init;
BEGIN
next := NIL;
END;

FUNCTION TListe.count;
VAR
empty : Boolean;
BEGIN
empty:=next=NIL;
IF empty THEN count:=0;
ELSE count:=next^.count + 1;
END;

PROCEDURE TListe.Insert(Pliste);
BEGIN
P^.next:=next;
next:=p;
End;

PROCEDURE TData.Init(x:Byte);
BEGIN
XData:=x;
END;

PROCEDURE TData.XOut;
BEGIN
Write (XData);
END;

VAR
L:TListe;
y:Byte;
Pliste;

BEGIN
l.init;
(* Einlesen *)
P:=new(Pdata,init($41));
l.insert(p);
P:=new(PData,init($42));
l.insert(p);
(* Ausgabe *)
p:=l.next;
WHILE p <> NIL DO
BEGIN
p^.xout;
p:=p^.next;
END
END.

Natürlich kannst du statt des Byte auch ein Array nehmen, das die größe des Einlesepuffers hat.

TT

Vielen Dank für das Listing und die damit verbundene Arbeit. Ich werde es dem Compiler anbieten.
Nochmals DANKE!

Viele Dank für die Hilfe und die damit verbundene Arbeit. Werden Quellcode durch den Compiler jagen. Nochmals DANKE!

Viele Dank für die Hilfe und die damit verbundene Arbeit. Werde den Quellcode durch den Compiler jagen. Nochmals DANKE!

Viele Dank für die Hilfe und die damit verbundene Arbeit. Werde den Quellcode durch den Compiler jagen. Nochmals DANKE!

...wenn Du's richtig anstellst, brauchst Du den Quellcode nur *1x* durch den Compiler jagen :supergrin:

CU

------------------
Ich wollte mich selbst vergessen, um anderen Freude zu machen. Von da an war ich glücklich.