generic TList of Record - Direktzugriff auf Feld

[himitsu]

Kennt folgendes schon jemand?

Delphi-Quellcode:

var Y: TList<TMyRec>;

Y := TList<TMyRec>.Create;
R.S := 'abc';
Y.Add(R);
Y[0].S := 'xyz';  // [DCC Fehler] Project2.dpr(25): E2064 Der linken Seite kann nichts zugewiesen werden
WriteLn(Y[0].S);
Y.Free;

ging vor D2010 mal, aber die Änderung wurde nicht in die Liste übernommen
siehe http://www.delphipraxis.net/162591-r...delphi-xe.html

Vor D2010 gab es noch keine Fehlermeldung, aber dafür gingen die Änderungen gerne mal verloren.




Eventuell gäbe es da ja Abhilfe, wenn man nur den Record als Pointer zugänglich machen würde.

Delphi-Quellcode:

program Project2;

{$APPTYPE CONSOLE}

uses
  SysUtils, DList;

type
  TMyRec = record
    S: String;
    i: Integer;
  end;

var
  X: TDirectList<TMyRec>;
  R: TMyRec;
  i: Integer;

begin
  try
    X := TDirectList<TMyRec>.Create;
    try
      R.S := 'Hallo';
      R.i := 1;
      X.Add(R);  // der normale Weg halt

      with X.Add^ do begin  // wenn kein Punkt folgt, sollte man den ^ nicht vergessen
        S := 'du';
        i := 2;
      end;

      X.Add.S := 'Welt';

      i := X.AddP;
      X[i].S := '^^';  // eigentlich   X.ItemsD[i].S := '^^';   aber ist ja das Default

      for i := 0 to X.Count - 1 do begin
        WriteLn(X[i].i, ' ', X[i].S);
        X[i].S := X[i].S + ' ';
      end;

      for R in X do
        Write(R.S);  // hier aber nur Lesezugriffe möglich, es sei denn, ...
      WriteLn;
    finally
      X.Free;
    end;

    WriteLn('*Ende*');
    ReadLn;
  except
    on E: Exception do begin
      WriteLn(E.ClassName, ': ', E.Message);
      ReadLn;
    end;
  end;
end.

Ja ja, man könnte natürlich auch eine Klasse aus dem Record machen und würde dann eine TObjectList<TMyClass> verwenden.






@SirThornberry: Wie findest du meinen brutalen Weg, um an FItems ranzukommen?

[Stevie]

Die Möglichkeit, einen nested Type als Pointer auf einen Typenparameter innerhalb eines generischen Typens zu deklarieren, ist ein Bug (Quelle: Barrys Antwort).

Also nicht wundern oder jammern, wenn das mal nicht so klappt, wie gedacht.

[himitsu]

So wie ich das dort glaube verstanden zu haben, ist das schon richtig.
Aber es gibt manchmal einen Bug, welcher irgendwann in ferner Zukunft (also nie, wie immer) gefix werden solle.



Ich glaub in D2009 hatte ich da mal einen derartigen Bug
und der Workaround war nicht schön und dazu noch Fehleranfällig.

Delphi-Quellcode:

type
  TMyGenType<T, P> = class(...)
  end;

  TNewType = TMyGenType(Byte, PByte);

Denn es könnte passieren, daß ^T <> P.


Nja, ist man ja langsam gewohnt, daß immer irgendwas nicht funktioniert.

[Stevie]

Zitat von himitsu:

So wie ich das dort gelesen hab, ist das schon richtig, aber es gibt manchmal einen Bug, welcher irgendwann in ferner Zukunft (also nie, wie immer) gefix werden soll.

Zitat:

Pointers to open generic types are not supported because generic pointer types are not supported, although it is possible (compiler bug) to create them in certain circumstances (particularly pointers to nested types inside a generic type)

Das ist der wichtige Satz

[himitsu]

Hmmm, aber schön, daß die Generics noch mehr beschränkt werden sollen ... man kann ja schon jetzt nicht viel damit anfangen

[Stevie]

Zitat von himitsu:

Hmmm, aber schön, daß die Generics noch mehr beschränkt werden sollen ... man kann ja schon jetzt nicht viel damit anfangen

Wenn du nicht viel damit anfangen kannst, versuchst du einfach nur das falsche damit.

Und ich sehe auch nicht, dass sie noch mehr beschränkt werden sollen - eher im Gegenteil:

Zitat von Barry Kelly:

The limitation on generic pointer types ought to be removed in the future, but I can't make promises when.

[himitsu]

Die ein bis zwei billigen Standardsachen funktionieren ja.

Aber wenn nichtmal Pointer funktionieren (also DAS Delphifeature schlechthin), dann ...
Oder wo ist die starke Typbindung von Delphi geblieben? (TMyGenType<T: TStrings> )

[Stevie]

Zitat:

Aber wenn nichtmal Pointer funktionieren (also DAS Delphifeature schlechthin)

Äh, wat? Wohl eher, dass man fast keine (ich zähle dazu jetzt nicht Objektreferenzen) davon braucht oder nicht immer jedes ^ schreiben muss, wenn man sie mal doch braucht.

Zitat von himitsu:

Oder wo ist die starke Typbindung von Delphi geblieben? (TMyGenType<T: TStrings> )

Soll mir was genau sagen?