Generics mit Konstanten?

[himitsu]

Ich wollt nur mal Fragen, ob soetwas überhaupt möglich ist
und wenn ja, wie man es umsetzen könnte.
(eventuell auch in anderen Sprachen)

Es geht hier speziell um den Parameter Size.

Der Syntax-Highlighter von Delphi hat ja erstmal nix gegen das Size, aber der Compiler mag es dann nicht

Delphi-Quellcode:

type TMyGeneric<Typ; Size> = Class
  Data: Array[1..Size] of Typ;
  ...


TMyClass = TMyGeneric<Char, 8>;

[mkinzler]

Und wenn du einen dynamischer Array verwendest, und Size als Parameter des Konstruktors?

[jfheins]

Würde ich auch empfehlen.

Mein VS 2008 sagt mir folgendes:

Code:

public class TMyGeneric<Typ, Size>
    {
        Typ[] Array;

        public TMyGeneric()
        { 
            Array = new Typ[Size];
        }
    }

Zitat:

Fehler 1 "Size" ist ein(e) "Typparameter", wird aber wie ein(e) "Variable" verwendet. C:\Users\Julius\Documents\Visual Studio 2008\Projects\Test 3\Form1.cs 86 29 Test 3

Womit er ja auch recht hat - denn da muss ja ein Integerwert hin und kein Typ

[himitsu]

Zitat von mkinzler:

Und wenn du einen dynamischer Array verwendest, und Size als Parameter des Konstruktors?

dann müßte ich ein DynamicArray verwenden und kein StaticArray und das wäre in meinem Fall nicht möglich gewesen.

Delphi scheint ja erstmal als Generic-Parameter nur Typen sehn zu wollen.




ich wollte das Ganze speziell für sowas verwenden ...
hier hab ich es zwar schonmal (mit leicht unschönder Definition) geschafft,
daß der Kompiler ohne zu meckern drübergeht,
aber sobals ich in der Implementierung das Data verwenden will, dann wird nur noch gemeckert, vonwegen "[DCC Fehler] ...: E2008 Inkompatible Typen"

Delphi-Quellcode:

{$IF Defined(UnicodeString) and (SizeOf(Char) = 2)} {$DEFINE UseUnicodeString} {$ELSE} {$UNDEF UseUnicodeString} {$IFEND}

Type TWideString = {$IFDEF UseUnicodeString}UnicodeString{$ELSE}WideString{$ENDIF};
  TGenericWideString<Typ> = packed Record
    Data: Typ;
    Class Operator Implicit(Const Value: AnsiString):              TGenericWideString<Typ>;
    Class Operator Implicit(Const Value: TWideString):             TGenericWideString<Typ>;
    Class Operator Implicit(Const Value: TGenericWideString<Typ>): TWideString;
    Class Operator Equal   (Const A: TGenericWideString<Typ>; Const B: TWideString): Boolean;
    Class Operator NotEqual(Const A: TGenericWideString<Typ>; Const B: TWideString): Boolean;
  End;

  TWideString8 = TGenericWideString<Array[1..8] of WideChar>;  // die unschöne Definition

Class Operator TGenericWideString<Typ>.Implicit(Const Value: AnsiString): TGenericWideString<Typ>;
  Var S: TWideString;

  Begin
    S := TWideString(Value);
    If Length(S) > Length(Result.Data) Then System.Error(reRangeError);
    Move(PWideChar(S)^, Result.Data, Length(S) * 2);
    If Length(S) < Length(Result.Data) Then
      FillChar(Result.Data[Length(S) + 1], (Length(Result.Data) - Length(S)) * 2, 0);
  End;

aber so hätte die Verwendung mir schon besser gefallen

Delphi-Quellcode:

type 
  TWideString8  = TGenericWideString<WideChar, 8>;
  TWideString32 = TGenericWideString<WideChar, 32>;

// oder sogar nur
  TWideString8  = TGenericWideString<8>;
  TWideString32 = TGenericWideString<32>;