generischen Typen als "irgendeinen" String-Typen deklarieren

[himitsu]

Delphi-Quellcode:

type
  TMyClass = class
    procedure Test<typ>(S: typ);
  end;

procedure TMyClass.Test<typ>(S: typ);
var S2: String;
begin
  S2 := S;  <<<
end;

Zitat:

[DCC Fehler] Unit4.pas(32): E2010 Inkompatible Typen: 'string' und 'typ'

Wie kann ich jetzt innerhalv der Klasse den "typ" kompatibel zu String bekommen?
Man kann zwar z.B. so procedure Test<typ: class>(S: typ); sagen, daß es irgendeine Klasse sein wird,
aber wie kann man es zum String kompatibel machen?
(AnsiString, RawByteString, UnicodeString, String)

Ich wollte die Generics benutzen, um einige "ähnliche" Funktionen zu kombinieren.
Wobei sich dort nur ein paar Parameter so unterscheiden, daß sie einmal ANSI und dann auch mal als Unicode vorhanden sein können.

Da es einige Funktionen mit bis zu 3 String-Parametern gibt und ich absolut nicht die automatischen Stringumwandlungen, seitens Delphi, gebrauchen kann, gibt es da also öfters mal bis zu 3^3 = 9 Funktionen, welche alle fast den selben Inhalt besitzen.

[USchuster]

Die Vereinfachung, welche Du mit Generics erreichen möchtest, funktioniert leider nicht aufgrund des nicht vorhandenen Typsystems bzw. der nicht vorhandener Contraints für Stringtypen. Um die Verwendung von überladenen Methoden wirst Du leider nicht drumherum kommen.

Theoretisch könntest Du es analog zu folgendem Beispiel implementieren:

Delphi-Quellcode:

program ParameterizedStringMethodTest;

{$APPTYPE CONSOLE}

type
  TMyClass = class
    class procedure Test<T>(S: T);
  end;

  T1252String = type AnsiString(1252);

class procedure TMyClass.Test<T>(S: T);
var
  StringTypeInfo: Pointer;
begin
  StringTypeInfo := TypeInfo(T);
  if StringTypeInfo = TypeInfo(AnsiString) then
    WriteLn('AnsiString: ' + AnsiString(Pointer(@S)^))
  else
  if StringTypeInfo = TypeInfo(RawByteString) then
    WriteLn('RawByteString: ' + RawByteString(Pointer(@S)^))
  else
  if StringTypeInfo = TypeInfo(UnicodeString) then
    WriteLn('UnicodeString: ' + UnicodeString(Pointer(@S)^))
  else
  if StringTypeInfo = TypeInfo(ShortString) then
    WriteLn('ShortString: ' + ShortString(Pointer(@S)^))
  else
  if StringTypeInfo = TypeInfo(UTF8String) then
    WriteLn('UTF8String: ' + UTF8String(Pointer(@S)^))
  else
  if StringTypeInfo = TypeInfo(T1252String) then
    WriteLn('T1252String: ' + T1252String(Pointer(@S)^))
  else
    WriteLn('Unknown type');
end;

begin
  TMyClass.Test(AnsiString('Ansi'));
  TMyClass.Test(RawByteString('Raw'));
  TMyClass.Test(UnicodeString('Uni'));
  TMyClass.Test(string('string is Uni too'));
  TMyClass.Test(ShortString('Short'));
  TMyClass.Test(UTF8String('UTF8'));
  TMyClass.Test(T1252String('1252'));
  ReadLn;
end.

Der Output müsste so aussehen:

Code:

AnsiString: Ansi
RawByteString: Raw
UnicodeString: Uni
UnicodeString: string is Uni too
ShortString: Short
UTF8String: UTF8
T1252String: 1252

[HeZa]

Zitat von himitsu:

Wie kann ich jetzt innerhalv der Klasse den "typ" kompatibel zu String bekommen?

Der spontane Gedanke (so ohne groß nachzudenken oder gar zu testen): Verwende ToString von TObject

[himitsu]

Ich habe aber Strings und keine Objekte.

Aktuell umgeh ich den Compiler über wilde Pointervergewaltigungen und blöde IF-Kontrukte, wobei mir {$IF lieber wäre



Es wäre schön, wenn es wirklich endlich mal einen zweifasigen Compiler gäbe und dieser erst die Typenprüfungen macht, wenn er einen Typen übergeben bekommt.

[Uwe Raabe]

Zitat von himitsu:

Es wäre schön, wenn es wirklich endlich mal einen zweifasigen Compiler gäbe und dieser erst die Tüpenprüfungen macht, wenn er einen Typen übergeben bekommt.

Er hat Jehova gesagt

[ConstantGardener]

@Uwe

[ot]

...ist hier etwa Weibsvolk anwesend ?

Ps. Ich liebe diesen Film!

[himitsu]

So, fast alle Arbeit umsonst.

Mein Fazit:
Für eine gleichzeitige Ansi/Unicode-Programmierung ist diese besch** Generic-Implementierung absolut nicht zu gebrauchen.

Danke Emba, für eure tolle Arbeit.