Warteschlange realisieren

[hotkey]

Hallo,

als Übung für die kommende Informatik-LK-Klausur möchte ich mich mit der Warteschlange beschäftigen.

Also ich habe 10 Personen , die anstehen , diese 10 Personen sind in einem Array vom Typ person (record) gespeichert , so sieht mein Quellcode bisher aus :

So hatten wir in der Schule damit angefangen.

Delphi-Quellcode:

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs;

type
  TForm1 = class(TForm)
  private
    { Private declarations }
  public
    { Public declarations }
  end;

  person = record
    Name:string;
    id:integer;
  end;


  Tschlange = class
  private
    next,max:integer;
    schlange : array [1..10] of person;
  public
    function einfuegen(x:person):boolean;
    constructor create;
  end;




var
  Form1: TForm1;

implementation


constructor tschlange.create;
 begin
  next :=0;
  max := 10;
 end;

function tschlange.einfuegen(x:person):boolean;
 begin
   schlange[next] := x;
  end;

{$R *.dfm}

end.

Im Record haben wir noch die Id hinzugefügt , also es können ja Personen anstehen , die den gleichen Namen und sogar den gleichen Nachnamen haben ( Peter Müller etc) , deswegen eine eindeutige ID.

So , auf dem Formular habe ich erstmal GARNIX.
Und ich weiß auch nicht mehr weiter , bei der

Delphi-Quellcode:

function einfuegen(x:person):boolean

.

Kriege ich hier einen Tipp , wie ich eine Person jetzt einfügen kann ?
Also z.b , wo ich ein edit-feld habe und wo dann sich eine Person einfügen kann.

Danke schon im Voraus.

[turboPASCAL]

Delphi-Quellcode:

schlange : array [1..10] of person;

Delphi-Quellcode:

... next:=0;

Delphi-Quellcode:

schlange[next] := x;

Das wird wohl 'n Fehler geben.

Ich pers würde ein dyn. Array oder eine TList nutzen.

Zitat:

Zitat von hotkey (Beitrag 1166346)

So , auf dem Formular habe ich erstmal GARNIX.

Muss man ja auch nicht unbedingt. ;)

Zitat:

Zitat von hotkey (Beitrag 1166346)

Und ich weiß auch nicht mehr weiter , bei der

Delphi-Quellcode:

function einfuegen(x:person):boolean

.

Kriege ich hier einen Tipp , wie ich eine Person jetzt einfügen kann ?

Na, mach dir ein Editfeld und einen butten auf das Formular. Im ButtonXClick -Ereignis machst du deine Einfügen function erin und erhöst den Zähler der Warteschlange.

[hotkey]

Danke erstmal fr deine Antwort.

Aber warum muss der Zähler der Warteschlange erhöht werden ?

[turboPASCAL]

Damit man weis wann die Warteschlange voll ist. Das kann man auch anders realisieren, ist aber, ich sag mal logisch einfacher.

[himitsu]

Schalte in den Projektoptionen die Bereichsprüfung an. :!:

Delphi-Quellcode:

    schlange : array [1..10] of person;

constructor tschlange.create;
 begin
  next :=0;
  max := 10;
 end;

function tschlange.einfuegen(x:person):boolean;
 begin
   schlange[next] := x;

Auf was wird "next" wohl stehen, beim Einfügen?

PS: Wozu hast du dir "max" nochmals gespeichert? (das kann man ja aus dem Array auslesen)


Mit einem dynamischen Array oder einer Liste würde man sich nicht speichern müssen, wo man grade ist, da man dort einfach immer die letzte Position als die Aktuelle ansehn könnte.

Eine Liste währe für einen Queue/FiFo (first in first out) eh besser geeignet, da er Möglichkeiten bietet, um die Lsite zu bearbeiten (Einfügen und Löschen).
Ein Array ist mehr für einen Stack/FiLo (first in last out) geeignet.

[hotkey]

Also danke erstmal für die Antworten , will aber kurz logisch was klargestellt haben :

Wenn ich jetzt eine Person einfüge in Schlange[1] , dann ist das erste Feld im Array voll , die erste Person muss aber sozusagen an die Kasse , denn das 10.Array Feld , also das letzte , ist ja eigentlich die Stelle , wo die erste Peron steht.

Also muss man ja immer +1 rechnen , oder ?

Damit die erte Person bis schlange[10] vorrückt , und dann immer so weiter , oder ?

[himitsu]

Ja?
Sollte doch wohl auch logisch sein, oder wieso bist du eigentlich auf die Idee mit der next-Variable gekommen?

Irgendwie mußt du ja auch wissen wo du grade bist.
OK, man könnte alle Felder mit NIL initialisiert halten und wirde jedesmal nachsehn, aber ein NEXT/CURRENT währe bestimmt einfacher.
Ein dynamisches Array oder eine Liste ginge auch, da man dort immer den letzten Eintrag als den aktuellen betrachten könnte.

Und nochmals, schalte besser zukünftig immer die Bereichsprüfung an, denn damit währe dieser Fehler sofort aufgefallen,
wobei man sich auch über ein bissl Debuggen dem Problem hätte annehmen können. :roll:

[hotkey]

Naja , das hat der Lehrer hinprogrammiert , konnte aber nicht fragen , was next heißen soll , weil ich grade an etwas anderem programmiert habe xD.

Also , trotzdem danke für die Antwort.

Also , wir haben jetzt den Code , hab diesen [0] Befehl korrigiert :

Delphi-Quellcode:

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs;

type
  TForm1 = class(TForm)
  private
    { Private declarations }
  public
    { Public declarations }
  end;

  person = record
    Name:string;
    id:integer;
  end;


  Tschlange = class
  private
    next,max:integer;
    schlange : array [1..10] of person;
  public
    function einfuegen(x:person):boolean;
    constructor create;
  end;




var
  Form1: TForm1;

implementation


constructor tschlange.create;
 begin
  next :=1;
  max := 10;
 end;

function tschlange.einfuegen(x:person):boolean;
 begin
   schlange[next] := x;
  end;

{$R *.dfm}

end.

Wenn ich jetzt ein Edit-Feld habe , und ich gebe dort zum Beispiel Peter ein , das ist ja ein String , also :

Delphi-Quellcode:

....
//
schlange[1] := form1.edit1.text;

Das geht ja nicht wegen den Datentypen , wie behebe ich diesen Fehler ?

2. Denkansatz von mir :

Delphi-Quellcode:

...
//
schlange.name[1]:= form1.edit1.text;

Geht das hier ?
Wie setze ich das um , dass ich einen Namen ins Array speichern kann.
Der record heißt person , ich bin ein bisschen durcheiannder , wie ihr seht , bin aber eifrig am Überlegen , also bitte nciht denken , dass ich nix mache oder so.

[himitsu]

Stattdessen im Unterricht besser zuhören?

Zitat:

Delphi-Quellcode:

schlange.name[1] :=

Geht das hier ?

Gegenfrage: Was ist wohl das Array, Schlange oder Name?


Und vergiß nicht das Next zu setzen.
Frage dazu: Was passiert wohl, wenn du mehrmals nacheinander "einfuegen" aufrufst?

[hotkey]

Hab ja zugehört , aber das Programmieren hatte mich grad in den Bann gezogen und ich saß vor dem Rechner like this : *-* xd

Also wenn ich mehrmals einfügen drücke , geht er sozusagen aus dem Array raus , ich muss es begrenzen , deswegen max , und max ist ja 10.

Wenn ich ne for-schleife hätte müsste ich

Delphi-Quellcode:

...to max do

schreiben.

Also das Array heißt ja Schlange.

Aber wenn ich einfach schlange[1]:=form1.edit1.text; schreibe , geht das nicht.

Ich muss ihm ja sagen , dass er , wenn auf das Record zugreift , den "Namen" im Record , der auf String ist , aufgreifen.

Also ins Array einfügen , aber im Record dann mit "Name" ansprechen lassen.

Vielleicht
schlange[1].name:=form1.edit1.text;

Bin mir aber nicht sicher :(

[hotkey]

Hey , ich hab es hinbekommen jackpot :D

So sieht es aus :

Delphi-Quellcode:

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls;

type
  TForm1 = class(TForm)
    Edit1: TEdit;
  private
    { Private declarations }
  public
    { Public declarations }
  end;

  person = record
    Name:string;
    id:integer;
  end;


  Tschlange = class
  private
    next,max:integer;
    schlange : array [1..10] of person;
  public
    function einfuegen(x:person):boolean;
    constructor create;
  end;




var
  Form1: TForm1;

implementation


constructor tschlange.create;
 begin
  next :=1;
  max := 10;
 end;

function tschlange.einfuegen(x:person):boolean;
 begin
   schlange[next].Name := form1.edit1.text;
  end;

{$R *.dfm}

end.

Jetzt ist das , was ich ins Edit-Feld eingebe , im ersten Feld des Arrays gespeichert oder ?

[hotkey]

So , aber ich bekomme hier einen Fehler :

Delphi-Quellcode:

function tschlange.einfuegen(x:person):boolean;
 var i:integer;
 begin
   schlange[next].Name := form1.edit1.text;

   for i:=1 to 9 do
    schlange[next] := schlange[next]+1; // FEHLER



  end;

WOllte dieses Aufrücken programmieren , aber er sagt mir " Inkompatile Typen "
Wie soll ich da vorgehen?

[hans ditter]

Moin Hotkey! :)

Schau dir nochmal genau deinen Code an:

Delphi-Quellcode:

for i := 1 to 9 do
  schlange[next]:=schlange[next]+1;

Da springen mir gleich zwei Fehler ins Auge:

1. benutzt du i überhaupt nicht, machst also 9 Mal dasselbe. Und zwar weist du neunmal schlange[next] schlange[next]+1 zu.

Und da liegt 2. der nächste Fehler: wenn du der Position x aus Schlange die Position x+1 zuweisen willst, musst du Delphi das auch so mitteilen:

Delphi-Quellcode:

schlange[next]:=schlange[next + 1]

[hotkey]

Hallo , danke für den Tipp , jetzt compiliert er wenigstens.

Das mit der for-Schleife habe ich gemacht , damit ich den Namen , den ich ins Edit-Feld eingebe , aufrücken kann.

Also , wenn ich den Namen eingebe , ist er ja zuerst im ersten Feld des Arrays , und durch die For-Schleife wollte ich das ganze in das 10.Feld einrücken lassen.

Ist das semantisch überhaupt korrekt , also die For-Schleife , das mit +1 und so ?

[hans ditter]

Moin!

Ich muss jetzt nochmal fragen, was du genau vor hast:

Ich stell mir das grad wie eine Supermarktkasse vor: Peter (mein Bsp. ;) ) hat alles in seinem Einkaufswagen und geht jetzt Richtung Kasse. Dabei kommt er bei Platz 1 (schlange[1]) an und will vorrücken auf Platz 10 (schlange[10]), also der Kasse. Ist das richtig?

In dem Fall musst du eine for-Schleife programmieren, die dir Peter durch das Array schiebt:

Delphi-Quellcode:

for i := 1 to 9 do
  schlange[i + 1] := schlange[i];

Das wäre dann auch ziemlich das, was du schon programmiert hast.

Allerdings mal logisch überlegt... hast du auch bedacht, dass Peter dann theoretisch auf allen Plätzen vor der kasse steht? Wenn du Peter einen Platz weiterschiebst, musst du seinen alten Platz ja auch wieder frei machen! ;)

[mani64]

Hallo,

du musst erst verschieben und dann einfügen, und zwar musst du von Platz 9 abwärts verschieben (9 auf 10, 8 auf 9, ... bis zu 1 auf 2). Dann hast du Platz 1 frei und kannst dort den neuen Namen einfügen.

[hotkey]

Hallo,

also bei mir sieht es jetzt so aus :

Delphi-Quellcode:

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls;

type
  TForm1 = class(TForm)
    Edit1: TEdit;
  private
    { Private declarations }
  public
    { Public declarations }
  end;

  person = record
    Name:string;
    id:integer;
  end;


  Tschlange = class
  private
    next,max:integer;
    schlange : array [1..10] of person;
  public
    function einfuegen(x:person):boolean;
    constructor create;
  end;




var
  Form1: TForm1;

implementation


constructor tschlange.create;
 begin
  next :=1;
  max := 10;
 end;

function tschlange.einfuegen(x:person):boolean;
  var i:integer;
    begin
      schlange[next].Name := form1.edit1.text;

    for i:=1 to 9 do
     schlange[next] := schlange[next+1];
     end;

{$R *.dfm}

end.

Zum Beispiel kann der String Peter jetzt in allen Feldern des Arrays stehen , wie mani64 netterweise gesagt hat , Peter soll aber als erster an der Kasse stehen , aber wie gebe ich die anderen Array-Felder frei?
Ich will ja noch andere Persoenn hinzufügen.

[schöni]

Zitat:

Zitat von hotkey (Beitrag 1166396)

Hallo,

also bei mir sieht es jetzt so aus :

Delphi-Quellcode:

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls;

type
  TForm1 = class(TForm)
    Edit1: TEdit;
  private
    { Private declarations }
  public
    { Public declarations }
  end;

  person = record
    Name:string;
    id:integer;
  end;


  Tschlange = class
  private
    next,max:integer;
    schlange : array [1..10] of person;
  public
    function einfuegen(x:person):boolean;
    constructor create;
  end;




var
  Form1: TForm1;

implementation


constructor tschlange.create;
 begin
  next :=1;
  max := 10;
 end;

function tschlange.einfuegen(x:person):boolean;
  var i:integer;
    begin
      schlange[next].Name := form1.edit1.text;

    for i:=1 to 9 do
     schlange[next] := schlange[next+1];
     end;

{$R *.dfm}

end.

Zum Beispiel kann der String Peter jetzt in allen Feldern des Arrays stehen , wie mani64 netterweise gesagt hat , Peter soll aber als erster an der Kasse stehen , aber wie gebe ich die anderen Array-Felder frei?
Ich will ja noch andere Persoenn hinzufügen.

Aaaaalso, da will ich mich auch mal hier reinhängen:

Ich verstehe die bisherige Logik so, das die Person an Position Schlange[1] an der Kasse steht und weitere Personen hinzu kommen, während Person 1 noch wartet, bis alle Artikel abgerechnet sind, weshalb Person[2], Person[3],... solange warten müssen. DEshalb muss auch der Zähler "next" immer um eins
erhöht werden. Weil Person[1] in Schlange[1] an der Kasse steht.

Erst dann eght es weiter:

Person[1] hat bezahlt:
Person[2] rückt vor auf Position 1
Person[3] rückt vor auf Position 2
...

[hotkey]

Hallo,

genau so ist es.

Also wenn ich eien Person einfüge zum Beispiel schlange[1]:= 'Otto';

Dann ist Otto doch im ersten Feld drin , im ersten Array-Feld, ich will aber , dass Otto in das 10. Array Feld kommt , ich stelle es mir so waagerecht vor sozusagen.

Das 10.Array Feld ist die erste Position an der Schlange , in das 9. Array Feld kommt dann zum Beispiel Peter , der als zweiter ansteht.

Semantisch habe ich es ja verstanden , aber es bröckelt bisschen bei der Umsetzung.

Also ein Element im Array ins 10. Feld verschieben , sodass andere Felder für andere Personen , die noch kommen werden , verfügbar sind.

[Klaus01]

Guten Morgen,

bist Du, für die Klausur, auf Array und Record beschränkt?

Einfacher, wie schon mehrmals gesagt, wird es, wenn Du ein TList verwendest.
Würdest Du TPerson von Record auf Klasse umstellen, könntest Du ein TObjectList verwenden.

Beide haben den Vorteil, das ein Hinzufügen von Elementen am
Listenenden passiert (es sei denn man fügt ein (insert).
Wird ein Element von Position 0 entfernt, rücken alle anderen Elemente
automatisch um eine Position nach vorne.
Um das Verschieben in der Liste muss man sich dann nicht mehr kümmern.

Grüße
Klaus

[DeddyH]

Und wenn man bei dem statischen Array of Record bleiben muss, stellt man folgende Überlegungen an:
- Next initial auf 1
- Einfügen eines Datensatzes an Position Next, anschließend Next um 1 erhöhen
- Entfernen des ersten Elements -> alle folgenden um eine Position nach vorn kopieren

Dabei muss man dann noch beachten, wo man auf Next und wo man auf die lokale Schleifenvariable zugreift.

[hotkey]

Leider darf ich nur Arrays und Records benutzen , denn mit Listen wäre es zu einfach s

[hotkey]

Also bis jetzt Also next wird ja auf 1 initialisiert und dann wird auch next in der for-Schleife um 1 erhöht, sodass dann zum Beispiel Otto auf Feld 10 vorrückt , siehe For-Schleife :

Delphi-Quellcode:

function tschlange.einfuegen(x:person):boolean;
  var i:integer;
    begin
      schlange[next].Name := form1.edit1.text;

    for i:=1 to 9 do
     schlange[next] := schlange[next+1];
     end;

Die Frage ist jetzt , ob das semantisch so korrekt ist ?

Ich gebe jetzt zum Beispiel in form1.edit1.text Otto ein.

Dann rückt doch Otto in schlange[10] auf , oder ?

Das ist ja der Sinn der for-Schleife ?

[alphaflight83]

Das Problem hier ist, dass du Next zwar mit 1 initialisierst, aber später nie änderst.
Du schreibst also bei jedem Schleifendurchlauf vom Array Index 2 (Next+1) in den Array Index 1 (Next)

[DeddyH]

Nun muss ich einmal nachfragen: die erste Person in der Schlange steht auch im Array an Position 1? Oder an Position 10?

[hotkey]

Stimmt , aber leider hört jetzt irgendwie mein Latein auf.

Ich weiß nicht , wie ich den semantischen bzw. logischen Fehler jetzt hier beseitigen soll.

:oops:

[DeddyH]

Wo steht der erste denn nun? Wenn an Position 1, wozu dann die Schleife?

[hotkey]

// kann gelöscht werden.

[hotkey]

Delphi-Quellcode:

constructor tschlange.create;
 begin
  next :=1;
  max := 10;
 end;

function tschlange.einfuegen(x:person):boolean;
  var i:integer;
    begin
      schlange[next].Name := form1.edit1.text;

    for i:=1 to 9 do
     schlange[next] := schlange[next+1];
     end;

Hallo,

also wenn ich jetzt diesen Befehl hier betrachte

Delphi-Quellcode:

schlange[next].Name := form1.edit1.text;

Dann heißt es ja für mich , dass im ersten Feld des Arrays , jetzt das steht , was ich ins Edit-Feld eingebenen habe , zum Beispiel Otto.

Dann ist das erste Feld im Array also [1] besetzt mit dem String von Otto , so , und jetzt will ich aber , dass Otto VORRÜCKT nämlich auf Feld Nummer 10 , also auf das letzte Feld im Array , also auf [10] , also bei schlange[10] soll Otto stehen bzw. sein , das wollte ich eigentlich mit der for-Schleife hinkriegen , aber anscheiennd ist da ein logischer Fehler , für den ich leider keien Ansätze mehr habe.

[DeddyH]

Erklär mir das mal: einfügen an Stelle 1 und dann verschieben nach Stelle 10? Wieso nicht gleich an Stelle 10 einfügen? Ich kann Deiner Logik nicht folgen, sry.

[hotkey]

Haha , daran habe ich garnicht gedacht irgendwie xD.

Hab viel zu kompliziert gedacht , also so sieht es dann jetzt , nach deinem Tipp , danke nochmals , aus :

Delphi-Quellcode:

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls;

type
  TForm1 = class(TForm)
    Edit1: TEdit;
    Button1: TButton;
  private
    { Private declarations }
  public
    { Public declarations }
  end;

  person = record
    Name:string;
    id:integer;
  end;


  Tschlange = class
  private
    next,max:integer;
    schlange : array [1..10] of person;
  public
    function einfuegen(x:person):boolean;
    constructor create;
  end;


var
  Form1: TForm1;

implementation


constructor tschlange.create;
 begin
  next :=1;
  max := 10;
 end;

function tschlange.einfuegen(x:person):boolean;
  var i:integer;
    begin
      schlange[10].Name := form1.edit1.text;
      schlange[9].Name:= form1.edit2.text;
      schlange[8].name:=form1.edit3.text;

   // for i:=1 to 9 do
     //schlange[next] := schlange[next+1];


     end;

{$R *.dfm}


begin


end.

Und jetzt möchte ich , dass mit einer Showmessage-Prozedur mir angezeigt wird , wer zm Beispiel als 3. an der Kasse steht.
Geht das so hier :

[delphi procedure anzeigen;
begin
showmessage(high(schlange[8]))
[/dephi]

[DeddyH]

So brauchst Du Next aber auch nicht mehr. Irgendwie ergibt das alles keinen rechten Sinn in meinen Augen. Denken wir doch einmal logisch und sagen: der erste wird an Position 1 im Array geschrieben, der zweite an Position 2 usw. Dann sähe Einfügen ja so aus:

Delphi-Quellcode:

function tschlange.einfuegen(x: person): boolean;
begin
  //hinter dem Array kann man nichts mehr einfügen
  Result := Next <= max; 
  if Result then
    begin
      //Daten an aktuelle Array-Position schreiben
      schlange[Next].Name := x.Name;
      schlange[Next].Id := x.Id;
      //Position erhöhen
      inc(Next); 
    end;
end;

[hotkey]

Ja , danke für den großen Denkanstoß.

Irgendwie habe ich es bisschen durcheiander gebracht , sorry.


Aber jetzt ist es doch keine Warteschlange mehr , oder ?

Denn im ersten Array-Feld befindet sich ja eine Person , und später dann auch im zweiten Array-Feld.

Dann ist das zweite Array-Feld ja aber vor dem ersten Array-Feld , ist ja sowas wie Drängeln , oder nicht ?

[DeddyH]

Wie kann das 2. vor dem 1. sein?

[hotkey]

Na , es geht doch so oder nciht :


Array :

1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10

Otto| Peter| <----- ? ----> | Kasse

So wird das ja eingefügt , nach deiner Function , erst kommt Otto rein , danach Peter.

Peter ist dann aber vor Otto , obwohl Otto als erster da war , verstehst du , was ich meine ?:oops:

[DeddyH]

Ich habe 2 mal gefragt, wo die Kasse ist. Wenn die also an Position 10 steht statt an der 1, muss ja alles umgedreht werden.

[Klaus01]

Warteschlange (FiFo) heißt doch:

Warteschlange leer:
Person1 bekommt den ersten Platz in der Warteschlange
Eine weiter Person kommt hinzu
Person2 bekommt den zweiten Plaz in der Warteschlange

Person1 wird zuerst an der Kasse bedient.
Ist Person1 fertig wird sie aus der Warteschlange entfernt (mit Gewalt)
und Person zwei rückt an Position 1 und wird dann bedient.

Grüße
Klaus

[hotkey]

Oh , tut mir Leid, habs wohl übersehen.

Also Kasse ist "nach" Array-Feld Nummer 10.

Das heißt , next muss doch 10 sein , oder nciht ?

Und dann statt inc (next , muss dec(next) stehen , oder ?

Also:

Delphi-Quellcode:

function tschlange.einfuegen(x: person):boolean;
begin
  //hinter dem Array kann man nichts mehr einfügen
  Result := Next <= max; //next ist 10
  if Result then
    begin
      //Daten an aktuelle Array-Position schreiben
      schlange[Next].Name := x.Name;
      schlange[Next].Id := x.id;
      //Position erhöhen ->> // POSITION abziehen
      dec(Next);
    end;
end;

[DeddyH]

Genau. Ich persönlich hätte die Kasse ja an Position 1 stehen lassen, aber wenn es absichtlich kompliziert sein soll, bitteschön.

[edit] Moment, Next muss dann aber mit 10 initialisiert werden, und bei der Prüfung größer als 0 sein. [/edit]

[hotkey]

Also , jetzt sieht es so aus :

Delphi-Quellcode:

 unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls;

type
  TForm1 = class(TForm)
    Edit1: TEdit;
    Button1: TButton;

  private
    { Private declarations }
  public
    { Public declarations }
  end;

  person = record
    Name:string;
    id:integer;
  end;


  Tschlange = class
  private
    next,max:integer;
    schlange : array [1..10] of person;
  public
    function einfuegen(x:person):boolean;
    constructor create;
  end;


var
  Form1: TForm1;
  myschlange:Tschlange;

implementation


constructor tschlange.create;
 begin
  next :=10;
  max := 10;
 end;

function tschlange.einfuegen(x: person):boolean;
begin
  //hinter dem Array kann man nichts mehr einfügen
  Result := Next <= max; // MUSS ICH HIER WAS ÄNDERN ?
  if Result then
    begin

      //Daten an aktuelle Array-Position schreiben
      schlange[Next].Name := x.Name;
      schlange[Next].Id := x.id;
      //Position erhöhen
      dec(Next);
    end;
end;






{$R *.dfm}





end.