Warum TStrings erstellen mit TStringList.Create?

[Guido Eisenbeis]

Zitat von thkerkmann:

Dann ist ja wohl TStringlist der größere Eimer

Ja, ja, ich sehe, meine Metapher hinkt gewaltig!

[himitsu]

Code:

Lebewesen > Mensch > Mann > Frank
                          > Daniel
                   > Frau
          > Hund > Pudel
                 > Dackel

var X: Mensch;
  Y: Lebewesen;

Procedure Toilette(Tür: Mann);

In X passen also nur Menschen, Männer und Frauen rein
und in Y dagegen auch noch die Tiere.

Auf dieses Klo dürfen auch NUR die Männer und demnach geht sozusagen Folgendes:
Toilette(Frank); bei dem
Toilette(Mensch); könnte es sich eventuell auch um eine Frau handeln und wer möchte denn, daß die uns was abguckt?

[Guido Eisenbeis]

@himitsu: Interessant, dass du die "Frau" bei den "Menschen" eingeordnet hast!? *grins*

Zitat von Guido Eisenbeis:

Man kann also einen kleinen Eimer (Nachfahre) in einen großen Eimer (Basisklasse) stecken.

Zitat von thkerkmann:

Dann ist ja wohl TStringlist der größere Eimer

Da hat Thomas natürlich recht. Und um meine Metapher anzupassen, formulier ich es mal so:
Ein größerer Eimer (Nachfahre) kann das beinhalten, was ein kleinerer Eimer (Basisklasse) beinhaltet.

Nichtsdestotrotz wieder zurück zum eigentlichen Thema, das immer noch nicht gelöst ist:

Warum eine Variable als TStrings deklarieren, wenn mit TStringList instanziert wird?

Guido.

[mkinzler]

Zitat:

Warum eine Variable als TStrings deklarieren, wenn mit TStringList instanziert wird?

Lies dir die Anworten noch einmal durch

[Muetze1]

@himitsu: in deinem Beispiel wären "Frank" und "Daniel" aber Instanzen von TMann und nicht Ableitungen. Oder was bilden denn Daniel und Frank denn noch neues aus? Ein viertes Bein? Wenn es natürlich Mutanten sind, dann wären es Ableitungen.

[Guido Eisenbeis]

Zitat von mkinzler:

Lies dir die Anworten noch einmal durch

So eine "Antwort" erweckt in mir das Gefühl kurz vor dem Veralbertwerden! Ich hoffe, dass das hier nicht der Fall ist. Und um dir zu zeigen, dass ich dir dahingehend Vertrauen geschenkt habe, habe ich tatsächlich die Postings oben noch einmal durchgelesen. Ich kann keine Antwort auf meine Frage erkennen.

Falls ich jedoch blind bin und eine Antwort schlichtweg übersehe, oder du sie erkennen kannst, dann bitte sag sie mir. Und um Missverständnissen vorzubeugen: Bitte nicht in Form von Totschlagargumenten, wie z. B. "wenn du genau kuckst, dann siehst du sie auch" oder "jedem anderen ist das klar" usw. Bitte in einer klaren Form, die ich auch dann verstehe, falls ich wirklich betriebsblind sein sollte!

Guido.

[mkinzler]

TStrings ist eine abstrakte Klasse, hierin wird ein (Soll-)Verhalten festgelegt
TStringList ist eine Klasse, die das vorgegebene Verhalten implementiert.
Es gibt aber auch andere Implementierungen (ein Beispiel hat Frank schon genannt)
Wenn man den Typ einer Variablen nun auf TStrings festlegt, kann man hier Referenzen auf Objekte verschiedenster Ableitungen/Implementierungen ablegen; TStringList limitiert auf die eine Implementierungen ( und Nachfahren dieser)

[himitsu]

@Muetze1:

Delphi-Quellcode:

TLebewesen = class
  Körper: TFettpolstermitknochen;
  ...
end;

TMann = class(TLebewesen)
  Eier: TSchrumpeldinger;
  Penis: TGlied;
  ...
end;

TFrau = class(TLebewesen)
  Hirn: TSchuhtick;
  Mumu: TSagichnicht;
  ...
end;

TFrank = class(TMann)
  Persönlichkeit: TFranksPersönlichkeit;
  ...
end;

Zitat:

Warum eine Variable als TStrings deklarieren, wenn mit TStringList instanziert wird?

Zitat:

Wenn du selber die TempList nur als TStringList verwendest und sie nicht weitergibst, dann kannst du sie auch direkt als TStringList deklarieren und hast dann auch direkten Zugriff auf spezielle Erweiterungen der TStringList.

Es kommt praktisch in jedem Einzelfall darauf an, was mit der Liste dann alles gemacht und an was sie eventuell übergeben wird.

[Guido Eisenbeis]

Zitat von Muetze1:

@himitsu: in deinem Beispiel wären "Frank" und "Daniel" aber Instanzen von TMann und nicht Ableitungen. Oder was bilden denn Daniel und Frank denn noch neues aus?

Zum Beispiel die Eigenschaften FaehrtPorsche, IstHetero: Boolean; oder SauftourTermine: Date;

Edit: Schreibfehler korrigiert.

[sirius]

Zitat von Guido Eisenbeis:

Ok, bleibt immer noch die Ausgangs-Frage: Warum eine Variable als TStrings deklarieren, wenn mit TStringList instanziert wird?

Wenn man direkt folgendes macht:

Delphi-Quellcode:

var x:TStringList;
begin
  x:=TStringlist.create;
 
  ...
end;

und hier x nur als Tstringlist verwendet und niemals nicht
eine andere Klasse (abgeleitet von TStrings) in x verwendet, dann ist es völlig sinnlos TStrings zu nehmen und in der Hilfe auch unsauber erklärt. --> Hier wäre x besser als TStringlist deklariert. Wenn du nirgends Probleme (mit dem Compiler) damit bekommst ist es auch in Ordnung TStringList zu verwenden. Mit TStrings würdest du dir Möglichkeiten verbauen, die vorhanden sind, du aber auf Grund der Deklaration nicht weist wo (Die Möglichkeit der Sortierung hat TStrings IMHO noch nicht dabei etc. pp).


Wo nimmt man nun TStrings?
Möglichkeit 1 (Wurde schon mehrfach hier erwähnt ):
-> Parameter
Du hast eine Methode, welche als Parameter TStrings bekommt

Delphi-Quellcode:

procedure myClass.myMethod(x:TStrings)
begin
  showmessage(x.Strings[0]);
end;

Du kannst in dieser Methode verschiedene Ableitungen von TStrings bekommen und bspw. nur die Strings auslesen und - wie hier - anzeigen. Ob das jetzt eine TStringList ist oder Memostrings oder von einem Stringgrid oder eine eigene Ableitung von TStrings ist völlig egal. Durch die virtualisierung des Getters von Strings wird bei jeder Variante intern eine andere Methode aufgerufen, nur du bekommst immer einen String vom Index 0 zurück.

Möglichkeit 2
-> Unterschiedliche Instanzierung von TStrings
Du bist dir bei der Deklaration noch nicht sicher welche Variante du von TStrings nimmst (das entscheidet sich quasi erst zur Laufzeit):

Delphi-Quellcode:

var x:TStrings;
begin
  if irgendetwas=irgendetwasanders then
    x:=TStringlist.create
  else
    x:=Memo1.lines;
  end;
  
  ...
end;

Hier mal noch ein Beipsiel:

Delphi-Quellcode:

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

type
  TmyStrings = class(TStrings)
   protected
    function Get(Index: Integer): string; override;
    function GetCount: Integer; override;
   public
    function Add(const S: string): Integer; override;
    procedure Delete(Index: Integer);  override;
    procedure Insert(Index: Integer; const S: string); override;
    procedure Clear; override;
  end;


  TForm1 = class(TForm)
    Memo1: TMemo;
    RadioGroup1: TRadioGroup;  //mit 3 Einträgen
    Edit1: TEdit;
    Button1: TButton; //eintragen des Edits in ausgewählte Impl. von TStrings
    Button2: TButton; //Anzeige der Stringlist
    procedure RadioGroup1Click(Sender: TObject);
    procedure Button1Click(Sender: TObject);
    procedure Button2Click(Sender: TObject);
    procedure FormCreate(Sender: TObject);
  private
    { Private-Deklarationen }
    FStrings:TStrings;
    FmyStrings:TmyStrings;
    FStringList:TStringList;
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

procedure TForm1.RadioGroup1Click(Sender: TObject);
begin
  //Übergabe einer konkreten Implementierung an FStrings
  case RadioGroup1.ItemIndex of
    0: FStrings:=Memo1.lines;
    1: FStrings:=FmyStrings;
    2: FStrings:=FStringList;
    else FStrings:=nil;
  end;
end;

procedure TForm1.Button1Click(Sender: TObject);
begin
  //eigentliche Verwendeung von FStrings
  if assigned(FStrings) then
    FStrings.Add(edit1.Text);
end;

procedure TForm1.Button2Click(Sender: TObject);
begin
  //Anzeige der StringList
  showmessage(FStringlist.Text);
end;

procedure TForm1.FormCreate(Sender: TObject);
begin
  //ein paar Initialisierungen
  FStringList:=TStringlist.Create;
  FmyStrings:=TmyStrings.Create;
end;


{ TmyStrings }

function TmyStrings.Add(const S: string): Integer;
begin
  //es wird in dem Programm ausschließlich add verwendet
  showmessage(s);
  result:=-1;
end;

procedure TmyStrings.Delete(Index: Integer);
begin  //abstrakte Methode überschreiben
end;

function TmyStrings.Get(Index: Integer): string;
begin  //abstrakte Methode überschreiben
  raise Exception.create('Keine Strings gespeichert');
end;
function TmyStrings.GetCount: Integer;
begin  //abstrakte Methode überschreiben
  result:=0;
end;
procedure TmyStrings.Insert(Index: Integer; const S: string);
begin //abstrakte Methode überschreiben
end;
procedure TmyStrings.Clear;
begin //abstrakte Methode überschreiben
end;