Warteschlange realisieren

[DeddyH]

Ich hatte eben noch editiert. BTW: Du solltest das {$R *.dfm} direkt hinter das implementation verschieben.

[p80286]

[OT] ich kann mich noch an meine erste Warteschlange erinnern, die war 64 Stellen lang, es gab einen Anfang, ein Ende und die Anzahl der gespeicherten Bytes.
Am Ende der Schlange wurde eingefügt, am Anfang gelesen.
Beim Einfügen wurde die Anzahl und das Ende um 1 erhöht, beim Lesen Die Anzahl um 1 vermindert und der Anfang um 1 erhöht.
war die warteschlage voll wurde nicht geschrieben, war sie leer wurde nicht gelesen.
Der einzge Trick war, daß für den Datenindex i:=i and 63; verwendet wurde.

(Es könnte sein, daß auf dieses Vorgehen IBM ein Copyright hat)
[/OT]

Gruß
K-H

[hotkey]

So müsste es korrekt sein , oder nicht ?

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

{$R *.dfm}


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 >0;
  if Result then
    begin

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











end.

[DeddyH]

Nach meinem Dafürhalten sollte das jetzt stimmen. Wenn nun also der erste (an Array-Position 10) durch die Kasse ist, müssen die anderen nachrücken. Dafür kannst Du dann wieder eine For-Schleife verwenden, musst aber herunterzählen (downto statt to).

[hotkey]

Das versuche ich mal heute , wenn ich zu Hause bin und poste eventuell noch Fragen hier rein.

Vielen Dank an alle erstmal , ich bin mir sicher , da sind noch paar Unklarheiten , die wir dann hier hoffentlich klären können.

Ich bedanke mich bei allen , die mir versucht haben , zu helfen , bzw. geholfen haben :D

Bis später.

[mani64]

Hallo,

ja, so funktioniert das Einfügen, d.h. du schreibst angegebene Namen immer auf den nächst niedrigeren Platz.
Das ist aber erst die halbe Miete.
Wie fügst du ein, wenn next = 0 ist, d.h. die Schlange voll ist? Dann musst du anfangen, die Elemente zu verschieben, und zwar erst verschieben und danach einfügen.

Es sollte also irgendwie so weitergehen:

Code:

function tschlange.einfuegen(x: person):boolean;
 begin
   //hinter dem Array kann man nichts mehr einfügen
   Result := Next >0;
   if Result then
     begin
 
      //Daten an aktuelle Array-Position schreiben
       schlange[Next].Name := x.Name;
       schlange[Next].Id := x.id;
       //Position abziehen
       dec(Next);
     end
     else begin // next =0
       // 9 auf 10 schieben, 8 auf 9 schieben usw. - For-Schleife dafür verwenden
       // an Stelle 1 das Neue einfügen
     end;
 end;

Wie du die For-Schleife zum Verschieben programmierst, das wurde ja oben schon erwähnt (for i:=9 downto 1 do ... schlange[i+1]:=schlange[i]).
Außerdem solltest du x.id eindeutig machen, z.B. erst im Constructor mit id:=1 initialisieren, dann beim Einfügen schlange[next].id:=id und danach mit inc(id) immer um eins erhöhen, sobald du eine Person eingefügt hast. Die Id wird also vom Programm vergeben, zum Einfügen gibt man nur den Namen ein.
Ich würde daher der Einfüge-Funktion nur den Namen und nicht den ganzen Record übergeben, wie du es früher schon mal hattest, denn den kannst du aus dem Edit-Feld einfach übernehmen. Somit hast du im id der zuletzt eingefügten Person auch gleich die Anzahl der Leute, die insgesamt an der Kasse waren, um bei dem Beispiel zu bleiben.

[DeddyH]

Beim Einfügen soll automatisch rotiert werden? Das hätte einem aber auch gesagt werden können (oder ich habe es überlesen). Ich frage mich dann nur, was die Boolean-Funktion in dem Fall zurückgeben soll, eigentlich kann es dann auch gleich eine Prozedur sein.

[p80286]

Zitat:

Zitat von DeddyH (Beitrag 1166442)

Beim Einfügen soll automatisch rotiert werden? Das hätte einem aber auch gesagt werden können (oder ich habe es überlesen).

Du hast da garnichts übersehen.

Zitat:

Zitat von mani64 (Beitrag 1166441)

Die Id wird also vom Programm vergeben, zum Einfügen gibt man nur den Namen ein.

Die ID wir ausserhalb des Programmes zur identifikation der Person benötigt, darum ist dieser Vorschlag nicht verwendbar.


Gruß
K-H

[mani64]

Zitat:

Zitat von p80286 (Beitrag 1166444)

Zitat:

Zitat von DeddyH (Beitrag 1166442)

Beim Einfügen soll automatisch rotiert werden? Das hätte einem aber auch gesagt werden können (oder ich habe es überlesen).

Du hast da garnichts übersehen.

Ich hatte den Eindruck gewonnen, dass es hotkey bisher hauptsächlich um das Vorrücken in der Schlange ging. Wenn dies nicht automatisch geschehen soll, dann muss er eben den Teil unter else in eine eigene Prozedur "Aufrücken" umwandeln.

Zitat:

Zitat von p80286 (Beitrag 1166444)

Zitat:

Zitat von mani64 (Beitrag 1166441)

Die Id wird also vom Programm vergeben, zum Einfügen gibt man nur den Namen ein.

Die ID wir ausserhalb des Programmes zur identifikation der Person benötigt, darum ist dieser Vorschlag nicht verwendbar.

Davon war bisher m.E. nicht die Rede. Sie soll laut #1 lediglich zur Identifikation dienen - und hotkey hat beim bisher vorgestellten Code auch nur eine Eingabeprozedur für den Namen präsentiert. Soll die ID auch eingegeben werden, so würde ich ein 2. Edit-Feld vorschlagen und entsprechenden Code für die Übernahme.

[hotkey]

Hallo,

da bin ich wieder.

Also wollte kurz was klarstellen : Die Id haben wir deshalb benutzt , damit wir die Menschen eindeutig identifizieren können , denn wir haben nicht ausgeschlossen , dass eine Person den gleichen Namen hat , wie eine andere.

Bevor ich noch verschiebe und so habe ich jetzt ein bisschen erweitert :

Delphi-Quellcode:

unit Unit1;

interface

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

type
  TForm1 = class(TForm)
    Edit1: TEdit;
    Edit2: TEdit;
    Button1: TButton;
    procedure Button1Click(Sender: TObject);

  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

{$R *.dfm}


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 >0;
  x.Name:= form1.edit1.text;              //  ERWITERUNG
  x.id := strtoint(form1.edit2.text);        // ERWEITERUNG
  if Result then
    begin

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

    schlange[next].Name:=x.name;
    schlange[next].id := x.id;

    end;
end;




procedure TForm1.Button1Click(Sender: TObject);
begin
myschlange := tschlange.create;

//myschlange.einfuegen()
end;

end.

Ich weiß , das im Button ist doppelt gemooppelt , ist aber irgendwie Gewöhnungssache geworden bei mir , hoffe , das macht keine Fehler.

Wenn ich jetzt für x.Name und x.Id 2 Edit-Felder habe , wie rufe ich die Funktion auf ?

So hier :

Delphi-Quellcode:

 einfuegen(x.id;x.name)

, geht das so ?

[p80286]

Zunächst einmal sollte das "create" dort verschwinden, denn wenn Du auf Button1 clickst, dann sollte Dein "Warteschlangenarray schon existieren.

Ich würde ein Record übergeben, etwa so

Delphi-Quellcode:

var
  myrec : tperson;   //tperson ist etwas besser als das nackte person

begin
  Myrec.ID:=  Edit1.Text;
  Myrec.Name:=Edit2.Text;
  MySchlange.Einfuegen(Myrec);
  .....

Du solltest Dir vielleict auch angewöhnen halbwegs sprechende Namen für Deine Variablen und Typen zu benutzen, damit machst Du Dir das Leben etwas einfacher.

z.B. edt_Name oder edt_ID



Gruß
K-H

[DeddyH]

So ähnlich hatte ich mir das auch gedacht. Wozu soll man auch einen Record-Parameter deklarieren, den man dann innerhalb der Funktion gar nicht nutzt, sondern stattdessen auf GUI-Controls zugreift? Macht ja keinen Sinn.

[hotkey]

Hallo,

also so sieht es jetzt bei mir aus :

Delphi-Quellcode:

unit Unit1;

interface

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

type
  TForm1 = class(TForm)
    Edit1: TEdit;
    Edit2: TEdit;
    Button1: TButton;
    procedure Button1Click(Sender: TObject);

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

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


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


var
  Form1: TForm1;
  myschlange:Tschlange;
  myrec : Tperson;
  i : integer;

implementation

{$R *.dfm}


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

function tschlange.einfuegen(x: tperson):boolean;
begin
  //hinter dem Array kann man nichts mehr einfügen
  Result := Next >0;
  if Result then
    begin

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

    schlange[next].Name:=x.name;
    schlange[next].id := x.id;

    end
     else    // wenn next = 0 ist
        begin
            for i:=9 downto 1 do
            schlange[i+1]:=schlange[i];
            showmessage('Fehler'); // Test , ob was gemacht wird , wenn next =0 ist
            end;



end;

procedure recordirgendwas;
 begin
  myrec.Name := form1.edit1.text;
  myrec.id := strtoint(form1.edit2.text);
  end;



procedure TForm1.Button1Click(Sender: TObject);
begin
recordirgendwas;



end;

end.

Ist das semantisch richtig ?

[DeddyH]

Weshalb trägst Du die Daten denn jetzt 2 mal ein?

[edit]

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
var 
  MyRec: TPerson;
begin
  MyRec.Name := Edit1.Text;
  MyRec.id := StrToInt(Edit2.Text);
  MySchlange.einfuegen(MyRec);
end;

Wenn Du die ganzen globalen Variablen (außer dem Formular) mal weglässt, wird das viel übersichtlicher. MySchlange könnte auch ein privates Feld des Fornulars werden, welches Du im OnCreate erzeugst und im OnDestroy wieder freigibst.[/edit]

[hotkey]

Wo denn , wenn ich fragen darf ?

[DeddyH]

Na, hier:

Zitat:

Delphi-Quellcode:

  if Result then
    begin

      //Daten an aktuelle Array-Position schreiben
      schlange[Next].Name := x.Name; //Nr. 1
      schlange[Next].Id := x.id;
      //Position abziehen
      dec(Next);

    schlange[next].Name:=x.name; //Nr. 2
    schlange[next].id := x.id;

    end

[hotkey]

Naja next ist doch 10 , und wenn ich was eingefügt habe , will ich in ja next 9 was reinmachen , dazu muss ich doch dec benutzen , oder ?

[schöni]

In ButtonClick ist nichts doppelt.

Doppelt gemoppelt ist eher das hier:

Delphi-Quellcode:

function tschlange.einfuegen(x: person):boolean;
begin
  //hinter dem Array kann man nichts mehr einfügen
  Result := Next >0;
  x.Name:= form1.edit1.text; // ERWITERUNG
  x.id := strtoint(form1.edit2.text); // ERWEITERUNG
  if Result then
    begin

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

    schlange[next].Name:=x.name;
    schlange[next].id := x.id;

    end;
end

nämlich das 2. Mal Schlange[next].name und Schlange[next].id.

Warum?

Weil die Zuweisung bereits bei "Daten an aktuelle Position schreiben" erfolgt. Die 2. Zuweisung darunter erfolgt nicht nur unnötig doppelt, sondern zu allem Überfluss noch nach der Dekrementierung des Index Next. So steht dann der Name mit gleicher ID zwei Mal in der Schlange. Hintereinander. Das geht logisch nicht, ist Fehler, weil eine Person nur einmal in der Schlange stehen kann. Diese kann maximal zu einem späteren Zeitpunkt NACHDEM sie an der Kasse schon bezahlt hat, nochmals kommen.

Denn der Name der Person hat sich zwischenzeitlich im Code vor der 2. Zuweisung noch nicht geändert, ist also mit Sicherheit noch dieselbe Person.
.

[DeddyH]

Ja, aber wieso schreibst Du dann in 9 dieselben Daten nochmal?

[hotkey]

Achso ich verstehe den Fehler jetzt.

Aber :

Delphi-Quellcode:

function tschlange.einfuegen(x: person):boolean;
begin
  //hinter dem Array kann man nichts mehr einfügen
  Result := Next >0;
  x.Name:= form1.edit1.text; // ERWITERUNG
  x.id := strtoint(form1.edit2.text); // ERWEITERUNG
  if Result then
    begin

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

    schlange[next].Name:=x.name;
    schlange[next].id := x.id;

    end;
end

Wenn ich was eingebe die ID und den Namen , dann bin ich ja im 10.Array Feld , denn next ist 10 , und wie kann ich dann Daten ins 9.Array Feld eingeben ?

[DeddyH]

Indem Du neue Daten eingibst und dann erneut einfuegen aufrufst?

[hotkey]

Oh man , stimmt , wieder kompliziert gedacht :)

Also das Programm sieht 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;
    Edit2: TEdit;
    Button1: TButton;
    procedure Button1Click(Sender: TObject);

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

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


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


var
  Form1: TForm1;
  myschlange:Tschlange;
  myrec : Tperson;
  i : integer;

implementation

{$R *.dfm}


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

function tschlange.einfuegen(x: tperson):boolean;
begin
  //hinter dem Array kann man nichts mehr einfügen
  Result := Next >0;
  if Result then
    begin

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


    end
     else    // wenn next = 0 ist
        begin
            for i:=9 downto 1 do
            schlange[i+1]:=schlange[i];
            showmessage('Fehler'); // Test , ob was gemacht wird , wenn next =0 ist
            end;



end;

procedure recordirgendwas;
 begin
  myrec.Name := form1.edit1.text;
  myrec.id := strtoint(form1.edit2.text);
  end;



procedure TForm1.Button1Click(Sender: TObject);
begin
recordirgendwas;



end;

end.

Jetzt wird, sobald ich in die 2 Edit-Feld Komponenten Namen und ID'S eingebe , das Array gefüllt oder ?

[DeddyH]

Das glaube ich nicht, Tim. Du hast MySchlange noch gar nicht erzeugt. Macht aber auch nichts, da Du ihre Methoden ja auch noch nicht aufrufst :mrgreen:

[hotkey]

Danke , stimmt , das hatte ich vergessen, hab aber trotzdem 2 Fehlermeldungen :(

Delphi-Quellcode:

unit Unit1;

interface

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

type
  TForm1 = class(TForm)
    Edit1: TEdit;
    Edit2: TEdit;
    Button1: TButton;
    procedure Button1Click(Sender: TObject);

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

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


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


var
  Form1: TForm1;
  myschlange:Tschlange;
  myrec : Tperson;
  i : integer;

implementation

{$R *.dfm}


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

function tschlange.einfuegen(x: tperson):boolean;
begin
  //hinter dem Array kann man nichts mehr einfügen
  Result := Next >0;
  if Result then
    begin

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


    end
     else    // wenn next = 0 ist
        begin
            for i:=9 downto 1 do
            schlange[i+1]:=schlange[i];
            showmessage('Fehler'); // Test , ob was gemacht wird , wenn next =0 ist
            end;



end;

procedure recordirgendwas;
 begin
myschlange := tschlange.create
myschlange.free;
myschlange.einfuegen(x:person) // [B]Hier sagt er , Booelan und TPerson inkompatibel und er kennt das X nicht [/B]
  myrec.Name := form1.edit1.text;
  myrec.id := strtoint(form1.edit2.text);
  end;



procedure TForm1.Button1Click(Sender: TObject);
begin
recordirgendwas;



end;

end.

[DeddyH]

Weißt Du eigentlich, was Du da tust bzw. liest Du, was wir schreiben? Wieviele Instanzen von MySchlange willst Du denn anlegen, die Du nie wieder freigeben kannst? Außerdem schau Dir mein Edit in #54 noch einmal an.

[edit] Wenn wir die Reihenfolge der Typdeklarationen etwas ändern, kann die Schlange auch ein Feld des Formulars werden:

Delphi-Quellcode:

type
  Tperson = record
    Name:string;
    id:integer;
  end;

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

  TForm1 = class(TForm)
    Edit1: TEdit;
    Edit2: TEdit;
    Button1: TButton;
    procedure Button1Click(Sender: TObject);
    procedure FormCreate(Sender: TObject);
    procedure FormDestroy(Sender: TObject);
  private
    { Private declarations }
    (* FSchlange gehört jetzt dem Formular und ist auch nur von dem zu erreichen *)
    FSchlange: TSchlange;
  public
    { Public declarations }
  end;

//...

procedure TForm1.FormCreate(Sender: TObject);
begin
  (* Instanz anlegen *)
  FSchlange := TSchlange.Create;
end;

procedure TForm1.FormDestroy(Sender: TObject);
begin
  (* Instanz freigeben*)
  FSchlange.Free;
end;

Wie schon erwähnt, bis auf die Formularvariable können alle globalen Variablen entfallen. Nur als Denkanstoß. [/edit]

[hotkey]

Tut mir Leid , du hattest es ja bearbeitet , dass du es bearbeitet hast , hatte ich nicht gesehen , Entschuldigung.

So , jetzt habe ich keine Fehler mehr :

Delphi-Quellcode:

unit Unit1;

interface

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

type
  TForm1 = class(TForm)
    Edit1: TEdit;
    Edit2: TEdit;
    Button1: TButton;
    procedure Button1Click(Sender: TObject);

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

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


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


var
  Form1: TForm1;
  myschlange:Tschlange;
  myrec : Tperson;
  i : integer;

implementation

{$R *.dfm}


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

function tschlange.einfuegen(x: tperson):boolean;
begin
  //hinter dem Array kann man nichts mehr einfügen
  Result := Next >0;
  if Result then
    begin

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


    end
     else    // wenn next = 0 ist
        begin
            for i:=9 downto 1 do
            schlange[i+1]:=schlange[i];
            showmessage('Fehler'); // Test , ob was gemacht wird , wenn next =0 ist
            end;



end;

procedure recordirgendwas;
 begin
 myschlange := tschlange.create;
 myschlange.Free;
 myschlange.einfuegen(myrec);
  myrec.Name := form1.edit1.text;
  myrec.id := strtoint(form1.edit2.text);
  end;



procedure TForm1.Button1Click(Sender: TObject);
begin
recordirgendwas;



end;

end.

Damit kann ich jetzt was , in meinen "Verhältnissen" , anfangen oder ?

[DeddyH]

Ich habe gerade noch einmal editiert. Du kannst doch nicht bei jedem Klick auf den Button eine neue Schlange anlegen, das schafft nur Speicherlecks und führt nicht zum Ziel.

[hotkey]

Danke für den editierten Denkanstoß :)

Ist es jetzt richtig ?
Jetzt wird die Klasse direkt instanziiert bei FormCreate , ohne , dass ich auf den Button klicke.

Delphi-Quellcode:

unit Unit1;

interface

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

type

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


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



  TForm1 = class(TForm)
    Edit1: TEdit;
    Edit2: TEdit;
    Button1: TButton;
    procedure Button1Click(Sender: TObject);
    procedure FormCreate(Sender: TObject);

  private
    { Private declarations }
     FSchlange : Tschlange;
  public
    { Public declarations }
  end;




var
  Form1: TForm1;
  myschlange:Tschlange;
  myrec : Tperson;

implementation

{$R *.dfm}


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

function tschlange.einfuegen(x: tperson):boolean;
var i:integer;
begin
  //hinter dem Array kann man nichts mehr einfügen
  Result := Next >0;
  if Result then
    begin

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


    end
     else    // wenn next = 0 ist
        begin
            for i:=9 downto 1 do
            schlange[i+1]:=schlange[i];
            showmessage('Fehler'); // Test , ob was gemacht wird , wenn next =0 ist
            end;



end;

procedure recordirgendwas;
 begin
 myschlange.einfuegen(myrec);
  myrec.Name := form1.edit1.text;
  myrec.id := strtoint(form1.edit2.text);
  end;



procedure TForm1.Button1Click(Sender: TObject);
begin
recordirgendwas;

showmessage(inttostr(myrec.id));

end;

procedure TForm1.FormCreate(Sender: TObject);
begin
Fschlange := Tschlange.create;
end;



end.

[DeddyH]

Schmeiß jetzt endlich die globalen Variablen raus:!: Du gibst FSchlange nicht wieder frei und greifst zum Teil auf myschlange zu, welche es aber nicht gibt. Außerdm finde ich es befremdlich, dass Du aus einer Methode des Formulars heraus eine reguläre Prozedur aufrufst, welche dann wieder auf Felder des Formulars zurückgreift, das ist doch Blödsinn.

[hotkey]

Meinst du so hier :

Delphi-Quellcode:

unit Unit1;

interface

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

type

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


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



  TForm1 = class(TForm)
    Edit1: TEdit;
    Edit2: TEdit;
    Button1: TButton;
    procedure Button1Click(Sender: TObject);
    procedure FormCreate(Sender: TObject);

  private
    { Private declarations }
     FSchlange : Tschlange;
  myschlange:Tschlange; // Das kann ich eigentlich löschen , oder ?
  myrec : Tperson;
  public
    { Public declarations }
  end;




var
  Form1: TForm1;


implementation

{$R *.dfm}


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

function tschlange.einfuegen(x: tperson):boolean;
var i:integer;
begin
  //hinter dem Array kann man nichts mehr einfügen
  Result := Next >0;
  if Result then
    begin

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


    end
     else    // wenn next = 0 ist
        begin
            for i:=9 downto 1 do
            schlange[i+1]:=schlange[i];
            showmessage('Fehler'); // Test , ob was gemacht wird , wenn next =0 ist
            end;



end;

procedure recordirgendwas;
 begin
 myschlange.einfuegen(myrec);
  myrec.Name := form1.edit1.text;
  myrec.id := strtoint(form1.edit2.text);
  end;



procedure TForm1.Button1Click(Sender: TObject);
begin
recordirgendwas;

showmessage(inttostr(myrec.id));

end;

procedure TForm1.FormCreate(Sender: TObject);
begin
Fschlange := Tschlange.create;
end;

procedure TForm1.FormDestroy(Sender: TObject);
begin
Fschlange.Free;
end;

end.

[DeddyH]

Du brauchst weder MySchlange noch MyRec als private Felder oder globale Variablen. Nochmal in der Zusammenfassung (Implementation von TSchlange ausgelassen):

Delphi-Quellcode:

type
  Tperson = record
    Name:string;
    id:integer;
  end;

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

  TForm1 = class(TForm)
    Edit1: TEdit;
    Edit2: TEdit;
    Button1: TButton;
    procedure Button1Click(Sender: TObject);
    procedure FormCreate(Sender: TObject);
    procedure FormDestroy(Sender: TObject);
  private
    { Private declarations }
    (* FSchlange gehört jetzt dem Formular und ist auch nur von dem zu erreichen *)
    FSchlange: TSchlange;
  public
    { Public declarations }
  end;

//...

procedure TForm1.FormCreate(Sender: TObject);
begin
  (* Instanz anlegen *)
  FSchlange := TSchlange.Create;
end;

procedure TForm1.FormDestroy(Sender: TObject);
begin
  (* Instanz freigeben*)
  FSchlange.Free;
end;

procedure TForm1.Button1Click(Sender: TObject);
var
  MyRec: TPerson;
begin
  MyRec.Name := Edit1.Text;
  MyRec.id := StrToInt(Edit2.Text);
  FSchlange.einfuegen(MyRec);
end;

So einfach kann das sein.

[hotkey]

Vielen Dank :

Delphi-Quellcode:

unit Unit1;

interface

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

type

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


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



  TForm1 = class(TForm)
    Edit1: TEdit;
    Edit2: TEdit;
    Button1: TButton;
    procedure Button1Click(Sender: TObject);
    procedure FormCreate(Sender: TObject);
    procedure FormDestroy(Sender: TObject);

  private
    { Private declarations }
     FSchlange : Tschlange;
  public
    { Public declarations }
  end;




var
  Form1: TForm1;


implementation

{$R *.dfm}


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

function tschlange.einfuegen(x: tperson):boolean;
var i:integer;
begin
  //hinter dem Array kann man nichts mehr einfügen
  Result := Next >0;
  if Result then
    begin

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


    end
     else    // wenn next = 0 ist
        begin
            for i:=9 downto 1 do
            schlange[i+1]:=schlange[i];

            end;

end;





procedure TForm1.Button1Click(Sender: TObject);
var MyRec:Tperson;
begin
myrec.Name := edit1.text;
myrec.id := strtoint(edit2.text);
Fschlange.einfuegen(myrec);


end;

procedure TForm1.FormCreate(Sender: TObject);
begin
Fschlange := Tschlange.create;
end;



procedure TForm1.FormDestroy(Sender: TObject);
begin
Fschlange.Free;
end;

end.

Jetzt ist es semantisch und syntaktisch korrekt , oder ?

Das heißt , ich kann jetzt 10 Sachen in ein Array mit 10 Feldern reinhauen , oder ?

[DeddyH]

Wirf den Compiler an und probier es aus. Abgesehen davon, dass Du vergessen hast, in der einfuegen-Methode nach dem Aufrücken noch die neuen Daten einzutragen, ist mir jetzt nichts mehr aufgefallen.

[hotkey]

Hab es compiliert , passt alles.

Das andere mache ich erstmal jetzt später , hab keine Power mehr , Gehirn ist müde xD.

Vielen vielen Dank an alle und besonders an dich DeddyH , tut mir Leid , ich bin noch ein Anfänger , ich übe aber fleißig :D

Das war eine Warteschlange , bald kommt der Kellerspeicher , ich hoffe , da wirst du mir wieder helfen.

Schönen Tag noch an alle ! :D