Class und Record

[mfs]

Hallo,
könnte mir jemand bitte einen Tipp geben?

Ich hab folgendes Problem: ich hab in meinem Programm folgende beide Klassen (s. unten), die funktionieren einwandfrei:

--------------- Meine Klassen ------------------

Delphi-Quellcode:

type
TAttributClass = class
  private
    { Private-Deklarationen }
    
  protected
    { Protected-Deklarationen }

  public
    { Public-Deklarationen }
    Name: String;
    Typ: String;
    Position:integer;
    Laenge:integer;
    Werte:string;
    Pflicht :Boolean;
    Wiederholen:string;
  end;

type
  TKategorieClass = class
  private
    { Private-Deklarationen }
    
  protected
    { Protected-Deklarationen }

  public
    { Public-Deklarationen }
    Name: String;
    AttributListe:TList;
  end;

----------------------------------------------------

Die möchte ich aber anstatt den Klassen zwei "records" machen, in so etwa:

Delphi-Quellcode:

type Attribute = record
           Name:String;
           Typ: String;
             .....
end;
type Kategorie = record
           Name: String;
           AttributListe:TList;
end;

var user:Array of Kategorie;

Aber dann kann ich nicht mehr die Liste "AttributListe" erzeugen und auf sie zugreifen, was mache ich da falsch? Wie kann ich ein neues Element (user) in die Liste hinzufügen?

Danke für jede Hilfe...

[edit=Dax][delphi]-Tags hinzugefügt. In Zukunft bitte selbst machen :) Mfg, Dax[/edit]

[mkinzler]

Zitat:

Aber dann kann ich nicht mehr die Liste "AttributListe" erzeugen und auf sie zugreifen

Wo instantiierst du die TList-Klasse? Kommt ein Fehler, welcher?

[DP-Maintenance]

Dieses Thema wurde von "Dax" von "Neuen Beitrag zur Code-Library hinzufügen" nach "Object-Pascal / Delphi-Language" verschoben.
Ist kein Schnipsel für die Codelib ;)

[mfs]

ich initialisiere sie in der Procedure in dem ich die eine Liste mit von allen usern erzeugen möchte also in der "Attributliste"

Was ich mach will sieht ungefähr so aus:

if Attributliste= nil then
Attributliste:= TList.Create
else Attributliste.Clear;
.
.
.

user[0].name:=....
user[0].typ:=....
.
.
user[n].name:=....
user[n].typ:=....

AttributListe.Add(user);

Bin ich auf dem richtigen Weg?

Wichtig ist, dass ich keinen Zeiger benutze :? ist das machbar?

[Dax]

Indem du von TList ableitest und alle Prozeduren/Funktionen, die mit deinem Record auskömmen müssen, darauf trimmst diesen Record anzunehmen. .Add(const{da ansonsten der Record kopiert wird} user: Attribute) müsste dann nur noch inherited Add(@user); aufrufen - für die anderen Methoden analog.

PS: Delphi-Tags! :?

[mfs]

Danke für die Hilfe.. Da ich aber noch relativ Anfänger bin, verstehe nicht alles was Du meinst.

Würdest Du bitte deswegen vielleicht an meinem Code etwas ändern oder mir einen Link bzw. ein Bsp. geben, was mir weiterhilfen könnte!! :cry:

[Dax]

Wenn du von TList ableitest, damit deine Liste Records statt Pointern nimmt, tust du das:

Delphi-Quellcode:

  TRecordList = class(TList)
  private
    function getRec(Index: Integer): Attribute;
    procedure SetRec(Index: Integer; const Value: Attribute);
  public
    property Items[Index: Integer]: Attribute read getRec write SetRec; default; 
    function Add(const Item: Attribute): Integer;
    function Extract(const Item: Attribute): Attribute;
    function First: Attribute;
    function IndexOf(const Item: Attribute): Integer;
    procedure Insert(Index: Integer; const Item: Attribute);
    function Last: Attribute;
    function Remove(const Item: Attribute): Integer;
  end;

{ TRecordList }

function TRecordList.Extract(const Item: Attribute): Attribute;
begin
  Result := Attribute(inherited Extract(@Item));
end;

function TRecordList.Add(const Item: Attribute): Integer;
begin
  Result := inherited Add(@Item);
end;

function TRecordList.First: Attribute;
begin
  Result := Attribute(inherited First^);
end;

function TRecordList.getRec(Index: Integer): Attribute;
begin
  Result := Attribute(inherited Get(Index)^);
end;

function TRecordList.IndexOf(const Item: Attribute): Integer;
begin
  Result := inherited IndexOf(@Item);
end;

function TRecordList.Last: Attribute;
begin
  Result := Attribute(inherited Last^);
end;

function TRecordList.Remove(const Item: Attribute): Integer;
begin
  Result := inherited Remove(@Item);
end;

procedure TRecordList.Insert(Index: Integer; const Item: Attribute);
begin
  inherited Insert(Index, @Item);
end;

procedure TRecordList.SetRec(Index: Integer; const Value: Attribute);
begin
  inherited Put(Index, @Value);
end;

Ich denke du siehst, das alle Methoden der Klasse nun einen anderen Typen als Parameter haben (nämlich Attribute anstatt von Pointer), was dich die Klasse für deine Records benutzen lässt. Du kannst es also völlig transparent benutzen :)

Das inherited bedeutet, das dort nicht nochmal die selbe Methode aufgerufen wird, sondern die der Basisklasse (also TList). Weil TList aber unbedingt Pointer haben will, müssen wir noch ein wenig friemeln mit den @'s und ^'s. ;)

[mfs]

Super .. Danke schön .. :thumb:

Damit kann ich mit Sicherheit anfangen :-D

Beste Güsse
mfs