unverständlicher DCC-Fehler E2506

[himitsu]

also, ich hatte grad mal zur Abwechslung etwas rumgespielt und dabei ist dieses hier rausgekommen:

Delphi-Quellcode:

Unit AssocArray;

Interface
  Type TAssocArray<Typ> = Record
    Private
      Type TRec = Record
          Name:  WideString;
          Value: Typ;
        End;
      Var Data: Array of TRec;
      Function  GetName      (      Index: Integer):             String;
      Function  GetValue     (      Index: Integer):             Typ;
      Procedure SetValue     (      Index: Integer; Const Value: Typ);
      Function  GetNamedValue(Const Name:  String):              Typ;
      Procedure SetNamedValue(Const Name:  String;  Const Value: Typ);
      Function  GetIndex     (Const Name:  String):              Integer;
    Public
      Procedure SetLength(i: Integer);
      Function  Length:      Integer;

      Property  Name [      Index: Integer]: String  Read GetName;
      Property  Value[      Index: Integer]: Typ     Read GetValue      Write SetValue;      Default;
      Property  Value[Const Name:  String]:  Typ     Read GetNamedValue Write SetNamedValue; Default;
      Property  Index[Const Name:  String]:  Integer Read GetIndex;

      Function  Add   (Const Value: Typ;                 Const Name: String = ''): Typ;
      Procedure Insert(Const Value: Typ; Index: Integer; Const Name: String = '');
      Procedure Move  (     OldIndex, NewIndex: Integer);
      Function  Delete(                  Index: Integer):                          Typ; Overload;
      Function  Delete(            Const Name:  String):                           Typ; Overload;
    End;

Implementation
  Uses Windows;

  Function TAssocArray<Typ>.GetName(Index: Integer): String;
    Begin
      If (Index >= 0) and (Index < System.Length(Data)) Then
        Result := Data[Index].Name
      Else System.Error(reRangeError);
    End;

  Function TAssocArray<Typ>.GetValue(Index: Integer): Typ;
    Begin
      If (Index >= 0) and (Index < System.Length(Data)) Then
        Result := Data[Index].Value
      Else System.Error(reRangeError);
    End;

  Procedure TAssocArray<Typ>.SetValue(Index: Integer; Const Value: Typ);
    Begin
      If (Index >= 0) and (Index < System.Length(Data)) Then
        Data[Index].Value := Value
      Else System.Error(reRangeError);
    End;

  Function TAssocArray<Typ>.GetNamedValue(Const Name: String): Typ;
    Var i: Integer;

    Begin
      i := GetIndex(Name);
      If (i >= 0) and (i < System.Length(Data)) Then
        Result := Data[i].Value
      Else System.Error(reRangeError);
    End;

  Procedure TAssocArray<Typ>.SetNamedValue(Const Name: String; Const Value: Typ);
    Var i: Integer;

    Begin
      i := GetIndex(Name);
      If (i >= 0) and (i < System.Length(Data)) Then
        Data[i].Value := Value
      Else If Name <> '' Then
        Add(Value, Name)
      Else System.Error(reRangeError);
    End;

  Function TAssocArray<Typ>.GetIndex(Const Name: String): Integer;
    Begin
      If Name <> '' Then Begin
        Result := High(Data);
        While (Result >= 0) and (Data[Result].Name <> Name) do Dec(Result);
      End Else Result := -1;
    End;

  Procedure TAssocArray<Typ>.SetLength(i: Integer);
    Begin
      System.SetLength(Data, i);
    End;

  Function TAssocArray<Typ>.Length: Integer;
    Begin
      Result := System.Length(Data);
    End;

  Function TAssocArray<Typ>.Add(Const Value: Typ; Const Name: String = ''): Typ;
    Var i: Integer;

    Begin
      If GetIndex(Name) >= 0 Then System.Error(reInvalidOp);
      i := System.Length(Data);
      System.SetLength(Data, i + 1);
      Data[i].Name  := Name;
      Data[i].Value := Value;
    End;

  Procedure TAssocArray<Typ>.Insert(Const Value: Typ; Index: Integer; Const Name: String = '');
    Var i:  Integer;
      Temp: TRec;

    Begin
      If (Index >= 0) and (Index <= System.Length(Data)) Then Begin
        If GetIndex(Name) >= 0 Then System.Error(reInvalidOp);
        i := System.Length(Data);
        System.SetLength(Data, i + 1);
        If Index < i Then Begin
{ja und hier wird nicht gemeckert}
{}        MoveMemory(@Temp, @Data[i], SizeOf(TRec));
{}        MoveMemory(@Data[Index + 1], @Data[Index], (i - Index) * SizeOf(TRec));
{}        MoveMemory(@Data[Index], @Temp, SizeOf(TRec));
{}        ZeroMemory(@Temp, SizeOf(TRec));
        End;
        Data[Index].Name  := Name;
        Data[Index].Value := Value;
      End Else System.Error(reRangeError);
    End;

  Procedure TAssocArray<Typ>.Move(OldIndex, NewIndex: Integer);
    Var S:  String;
      Temp: Typ;

    Begin
      If (NewIndex >= 0) and (NewIndex < System.Length(Data)) Then Begin
        S    := GetName(OldIndex);
        Temp := Delete(OldIndex);
        Insert(Temp, NewIndex, S);
      End Else System.Error(reRangeError);
    End;

  Function TAssocArray<Typ>.Delete(Index: Integer): Typ;
    Var i: Integer;
      Temp: TRec;

    Begin
      If (Index >= 0) and (Index < System.Length(Data)) Then Begin
        Result := Data[Index].Value;
        i := System.High(Data);
        If Index < i Then Begin
{hier tritt jeweils der Fehler auf}
{}        MoveMemory(@Temp, @Data[Index], SizeOf(TRec));
{}        MoveMemory(@Data[Index], @Data[Index + 1], (i - Index) * SizeOf(TRec));
{}        MoveMemory(@Data[i], @Temp, SizeOf(TRec));
{}        ZeroMemory(@Temp, SizeOf(TRec));
        End;
        System.SetLength(Data, i);
      End Else System.Error(reRangeError);
    End;

  Function TAssocArray<Typ>.Delete(Const Name: String): Typ;
    Begin
      Result := Delete(GetIndex(Name));
    End;

End.

Es wird theoretisch einfach so angewendet

Delphi-Quellcode:

Uses AssocArray;

Type TTestRec = Record
    A:       String;
    X, Y, Z: Integer;
  End;

  TStringAssocArray  = TAssocArray<String>;
  TIntegerAssocArray = TAssocArray<Integer>;
  TTestAssocArray    = TAssocArray<TTestRec>;

Procedure Test;
  Var A: TStringAssocArray;

  Begin
    A['123'] := 'abc';

    If A[0] = A['123'] Then Beep;
  End;

und stellt praktisch ein assoziatives Array dar. :angel:

Nur leider bekomm ich beim Test eine komische Fehlermeldung. :wall:

Zitat:

[DCC Fehler] AssocArray.pas(149): E2506 Im interface-Abschnitt deklarierte Methode des parametrisierten Typs darf kein lokales Symbol '.2' verwenden

Und zwar genau 4 Mal in der Delete-Funktion.
Genauer gesagt bei den Zeilen mit MoveMemory und ZeroMemmory.

Nur da ist doch "nichts" anders, wie in der Insert-Funktion, wo nicht gemeckert wird? :gruebel:
(abgesehn von der Reinfolge der Source/Destination-Parameter)

Und dazu kommt noch, daß ich garnicht versteh was der genau will. :oops:

[himitsu]

OK, ich konnte es jetzt auf SizeOf(TRec) eingrenzen, was irgendwie mal geht und dann mal wieder nicht.
Und Array[1..SizeOf(Typ)] geht garnicht ... wollte eine Temp-Variable mit der selben Größe in der Move-Prozedur erstellen.

so ging es auch nicht

Delphi-Quellcode:

Type TAssocArray<Typ> = Record
  Private
    Type TRec = Record
        Name:  WideString;
        Value: Typ;
      End;
    Const RecSize = SizeOf(TRec);
    Var Data: Array of TRec;

da kam dann nur dieses raus

Zitat:

[DCC Fehler] AssocArray.pas(10): E2005 'TAssocArray<>.TRec' ist kein gültiger Typenbezeichner

nja, am Ende konnte ich mit einem Umweg über die Variable Data lösen
und hab überall jetzt einfach SizeOf(Data[0]) verwendet :angel:

aber dennoch komisch, warum SizeOf(TRec) erst geht (in .Insert) und dann plötzlich nicht mehr (in .Delete) :wall:

[jbg]

Zitat:

Zitat von himitsu

aber dennoch komisch, warum SizeOf(TRec) erst geht (in .Insert) und dann plötzlich nicht mehr (in .Delete) :wall:

Update 3 soll ja einige Bugfixes für die Generics enthalten. Lassen wir uns da einfach mal überraschen, ob Generics in Delphi 2009 doch noch nutzbar werden.

[Alter Mann]

Hi,

Mach die Hilfe auf und suche nach E2506.

Gruss

[himitsu]

Zitat:

Zitat von Alter Mann

Mach die Hilfe auf und suche nach E2506.

hast du das auch mal gemacht?

Zitat:

Zitat von OH

E2506: Explizite Spezialisierung ist nicht eindeutig: Template-Arg. müssen angegeben werden
Der folgende Programmcode erfordert explizite Template-Argumente:

Delphi-Quellcode:

template<class T> void foo(T);

template<class T> void foo(T *);

template<> void foo(int *); // Fehler, es muss 'foo<int>' oder 'foo<int *>' heißen

Also das klingt mehr nach einem Problem in der Definition des Generics

Ich hab aber Problemchem in der Implementierung
und diese treten auch noch nur sporatisch auf. :?




[add]
Also das ist aktuell mein kleines Testprogramm und die aktuelle Version liegt im Anhang.
Leider meckert der Compiler an unterschiedlichen Stellen und wenn man gleich nochmal compilert, wird oftmals plötzlich wo anders gemeckert. :?
Ansonsten wäre es eigentlich eine recht schicke Sache (wenn es denn vollständig liefe)

Delphi-Quellcode:

Program Project1; SysUtils, AssocArray;

Type TTestRec = Record
    A:       String;
    X, Y, Z: Integer;
  End;

  TStringAssocArray  = TAssocArray<String>;
  TIntegerAssocArray = TAssocArray<Integer>;
  TTestAssocArray    = TAssocArray<TTestRec>;

Var A: TStringAssocArray;
  B: TTestAssocArray;
  T: TTestRec;

Begin
  A['123']    := 'abc';
  A['456']    := 'def';
  A['alfred'] := 'xyz';

  If A[1] = A['456'] Then Beep;

  // A.SetLength(3);
  //
  // A.Length                  = 3
  // A.Name[1]                 = '123'
  // A.Value[1]     = A[1]     = 'abc'
  // A.Value['456'] = A['456'] = 'abc'
  // A.Index['456']            = 1
  //
  // A.Add('ghi', 'Name');
  // A.Add('ghi');
  // A.Insert('ghi', 3, 'Name');
  // A.Insert('ghi', 3);
  // A.Move(3, 2);
  // A.Delete(3);
  // A.Delete('alfred');

  B['test'] = T;
  If B[0] = T Then Beep;
End.

[edit=mkinzler]Delphi-Tag eingefügt Mfg, mkinzler[/edit]

[Assertor]

Hi,

Zitat:

Zitat von jbg

Update 3 soll ja einige Bugfixes für die Generics enthalten. Lassen wir uns da einfach mal überraschen, ob Generics in Delphi 2009 doch noch nutzbar werden.

Absolut Richtig!

@himitsu: Ich glaube fest daran, daß es an der Generics Unterstützung von D2009 liegt und dies bestimmt mit dem nächsten Update gehen wird!

Gruß Assertor

[himitsu]

mal sehn ob es besser ist, als Update2,das hat nach meinem Gefphl nix verbessert, nur verschlechtert :?

die Operatoren mag ich inzwischen ja schon und die Generics könnten mir gefallen, wenn sie mal richtig laufen :angel2:

[jaenicke]

Zitat:

Zitat von himitsu

und die Generics könnten mir gefallen, wenn sie mal richtig laufen :angel2:

Derweil gibts ja C# um Generics zu genießen. :mrgreen:

[ecotron]

Mit dem D2009 Update 3 kommt immer noch ein Fehler. Scheinbar gibt es ein Problem mit überladenen Default Properties und Generics.
Und wenn aber man Properties verschiebt oder Kleinigkeiten an andere Stelle ändert geht es manchmal.

Ganz seltsam ist auch dass man trotz Fehlermeldung eine Exe erzeugen kann. Einfach nach Projekt "Erzeugen" nochmals auf "Start" drücken.

[himitsu]

Zitat:

Zitat von ecotron

Scheinbar gibt es ein Problem mit überladenen Default Properties und Generics.

gut, das überladene Property könnte man ja notfalls als Variant-Parameter zusammenfassen, aber dann ging ein wenig die "Leistung" runter (halt wegen der Variantverwaltung),
oder man läßt den Zugriff via Index (Integer) weg, bzw. verlagert ihn (umbenennen)

Zitat:

Zitat von ecotron

Und wenn aber man Properties verschiebt oder Kleinigkeiten an andere Stelle ändert geht es manchmal.

Ganz seltsam ist auch dass man trotz Fehlermeldung eine Exe erzeugen kann. Einfach nach Projekt "Erzeugen" nochmals auf "Start" drücken.

sowas ist mir auch bei anderen Dingen schon paar Mal untergekommen. :shock: