Aide de classe et chaînes dans Delphi Win32

Question

Y a-t-il un moyen de mettre en œuvre le delphi actuel?

a) String (en classe) avec surcharge de l'opérateur (par exemple. +, =)

b) donc on pourrait ajouter des méthodes de chaîne personnalisée

Je déduis la chaîne de classe d'assistance est un type natif donc les aides de classe ne fonctionneront pas sans en configurant une classe, etc.

Answer 1

Cette solution n'est pas la meilleure pour écrire vos fonctions/procédures personnalisées?

Par exemple

Function StrToBase64(AString): string; 
Procedure StrToGridLayout(AString: string; AGrid: TDBGrid); 
Function ExtractWord(aString): string; 
Function GetStrColumn(aString: string; aCol: integer): string; 

Et si vous voulez regrouper ces fonctions/procédures qui résident dans la même unité dans les catégories fonctionnelles que vous pouvez utiliser les enregistrements pour cela:

TStringConversions = record 
    class Function StrToBase64(AString): string; 
    class Procedure StrToGridLayout(AString: string; AGrid: TDBGrid); 
end; 

TStringParsing = record 
    class Function ExtractWord(aString): string; 
    class Function GetStrColumn(aString: string; aCol: integer): string; 
end; 

Et puis, vous peut les appeler dans le code d'une manière beaucoup plus propre:

myFirstWord := TStringParsing.ExtractWord('Delphi is a very good tool'); 

HTH

Answer 2

Oui, chaîne est un type natif avec un peu de magie de compilateur spécial ajouté.

Je ne sais pas quelle surcharge d'opérateur vous voudriez. + et = fonctionnent déjà en tant qu'opérateurs de concaténation et d'égalité.

Cependant, j'ai pensé à faire quelque chose de similaire moi-même. Il peut fonctionner avec un type d'enregistrement avec des convertisseurs implicites et des opérateurs d'addition et d'égal surchargés (dans Win32 Delphi, seuls les enregistrements peuvent être surchargés par l'opérateur) (D2006 (2005) uniquement.)

Je suppose qu'il peut y avoir des performances frappé aussi bien.

La syntaxe serait quelque chose comme ce qui suit:

unit Unit1; 

interface 

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

type 
    TForm1 = class(TForm) 
    Button1: TButton; 
    procedure Button1Click(Sender: TObject); 
    private 
    { Private declarations } 
    public 
    { Public declarations } 
    end; 

    TString = record 
    private 
     Value : string; 
    public 
     class operator Add(a, b: TString): TString; 
     class operator Implicit(a: Integer): TString; 
     class operator Implicit(const s: string): TString; 
     class operator Implicit(ts: TString): String; 
     function IndexOf(const SubStr : string) : Integer; 
    end; 


var 
    Form1: TForm1; 

implementation 

class operator TString.Add(a, b : TString) : TString; 
begin 
    Result.Value := a.Value + b.Value; 
end; 

class operator TString.Implicit(a: Integer): TString; 
begin 
    Result.Value := IntToStr(a); 
end; 

class operator TString.Implicit(ts: TString): String; 
begin 
    Result := ts.Value; 
end; 

function TString.IndexOf(const SubStr : string) : Integer; 
begin 
    Result := Pos(SubStr, Value); 
end; 

class operator TString.Implicit(const s: string): TString; 
begin 
    Result.Value := s; 
end; 


{$R *.dfm} 

procedure TForm1.Button1Click(Sender: TObject); 
var 
    ts : TString; 
begin 
    ts := '1234'; 
    ShowMessage(ts); 
    ShowMessage(IntToStr(Ts.IndexOf('2'))); 
end; 

end. 

Apparemment, vous pouvez avoir des « aides record », ainsi, mais je ne l'ai jamais essayé moi-même.

Answer 3

Vous pouvez utiliser la surcharge d'opérateur dans Delphi (depuis Delphi 2006) uniquement sur les enregistrements ne se trouvant pas dans les classes, et non sur les types natifs intégrés comme les chaînes. La raison en est que Delphi n'a pas de garbage collection, donc la surcharge de l'opérateur est limitée aux types de valeur (les types qui ne vivent pas sur le tas).

Vous pouvez télécharger la relecture de ma session "Types nullullables avec enregistrements, méthodes et surcharge opérateur" au CodeRage III Replay download page. Recherchez simplement le nom de la session.

Il existe également un page with the download for the session samples and slides.

Il contient pas mal d'exemples qui vous aideront à démarrer, y compris une description de certains problèmes du compilateur Delphi 2006 qui ont été résolus dans Delphi 2007 et versions ultérieures.Voir également cette question: Can I overload operators for my own classes in Delphi?