Char-Array mal "einfach"

**himitsu**

OK, wie einige bemerkt haben, geht es ja nicht immer so leicht seinen Array's etwas zuzuweisen...

Delphi-Quellcode:

			var MyArray: Array[1..32] of Char;

// dieses geht ja meistens noch

MyArray := 'ne Konstante';

// aber hier zickt der Kompiler schon mal rum

MyArray := S;  // S is ein String

so, da kommt nun ein kleiner Record ins Spiel,
welcher das Array enthält und noch ein paar Operatoren verpaßt bekommt.

PS: TWideString ist 'ne Variable von mir ... hab die entweder als UnicodeString oder WideString definiert (je nach Delphi)

Auch hatte ich mir ein paar Operatoren gesparrt ... also in dieser Variante geht nur Folgendes:
(den Rest kann man sich aber leicht nachrüsten ... hatte halt für mein Projekt so ausgereicht)

markieren

Delphi-Quellcode:

			Var MyArrayRecord: TWideString32;

  S: String {or AnsiString, WideString od UnicodeString};

MyArrayRecord := 'constant';

MyArrayRecord := S;

S := MyArrayRecord;

If MyArrayRecord = 'abcde' then ...;

If MyArrayRecord <> 'abcde' then ...;

zusammenfalten · markieren

Delphi-Quellcode:

			Type TWideString32 = packed Record

    Data: Array[1..32] of WideChar;

    Class Operator Implicit(Const Value: AnsiString):  TWideString32;

    Class Operator Implicit(Const Value: TWideString): TWideString32;

    Class Operator Implicit(Const Value: TWideString32): TWideString;

    Class Operator Equal   (Const A: TWideString32; Const B: TWideString): Boolean;

    Class Operator NotEqual(Const A: TWideString32; Const B: TWideString): Boolean;

  End;

Class Operator TWideString32.Implicit(Const Value: AnsiString): TWideString32;

  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;

Class Operator TWideString32.Implicit(Const Value: TWideString): TWideString32;

  Begin

    If Length(Value) > Length(Result.Data) Then System.Error(reRangeError);

    Move(PWideChar(Value)^, Result.Data, Length(Value) * 2);

    If Length(Value) < Length(Result.Data) Then

      FillChar(Result.Data[Length(Value) + 1], (Length(Result.Data) - Length(Value)) * 2, 0);

  End;

Class Operator TWideString32.Implicit(Const Value: TWideString32): TWideString;

  Var i: Integer;

  Begin

    i := 0;

    While (i < Length(Value.Data)) and (Value.Data[i + Low(Value.Data)] <> #0) do Inc(i);

    SetLength(Result, i);

    Move(Value.Data, PWideChar(Result)^, i * 2);

  End;

Class Operator TWideString32.Equal(Const A: TWideString32; Const B: TWideString): Boolean;

  Var S: TWideString;

  Begin

    S := A;

    Result := S = B;

  End;

Class Operator TWideString32.NotEqual(Const A: TWideString32; Const B: TWideString): Boolean;

  Begin

    Result := not (A = B);

  End;

hier noch 'ne kleine Ansi-Variante

zusammenfalten · markieren

Delphi-Quellcode:

			Type TAnsiString32 = packed Record

    Data: Array[1..32] of AnsiChar;

    Class Operator Implicit(Const Value: AnsiString):    TAnsiString32;

    Class Operator Implicit(Const Value: TAnsiString32): AnsiString;

    Class Operator Equal   (Const A: TAnsiString32; Const B: AnsiString): Boolean;

    Class Operator NotEqual(Const A: TAnsiString32; Const B: AnsiString): Boolean;

  End;

Class Operator TAnsiString32.Implicit(Const Value: AnsiString): TAnsiString32;

  Begin

    If Length(Value) > Length(Result.Data) Then System.Error(reRangeError);

    Move(PAnsiChar(Value)^, Result.Data, Length(Value));

    If Length(Value) < Length(Result.Data) Then

      FillChar(Result.Data[Length(Value) + 1], (Length(Result.Data) - Length(Value)), 0);

  End;

Class Operator TAnsiString32.Implicit(Const Value: TAnsiString32): AnsiString;

  Var i: Integer;

  Begin

    i := 0;

    While (i < Length(Value.Data)) and (Value.Data[i + Low(Value.Data)] <> #0) do Inc(i);

    SetLength(Result, i);

    Move(Value.Data, PAnsiChar(Result)^, i);

  End;

Class Operator TAnsiString32.Equal(Const A: TAnsiString32; Const B: AnsiString): Boolean;

  Var S: AnsiString;

  Begin

    S := A;

    Result := S = B;

  End;

Class Operator TAnsiString32.NotEqual(Const A: TAnsiString32; Const B: AnsiString): Boolean;

  Begin

    Result := not (A = B);

  End;

hatte auch mal versucht 'nen Template zusammenzubasteln, aber muß da wohl noch etwas lernen ...

zusammenfalten · markieren

Delphi-Quellcode:

			<?xml version="1.0" encoding="utf-8" ?>

<codetemplate   xmlns="http://schemas.borland.com/Delphi/2005/codetemplates"

            version="1.0.0">

   <template name="TWideStringX" invoke="manual">

      <description>

        WideChar-Array

      </description>

      <author>

        himitsu

      </author>

      <point name="size">

         <text>

            32

         </text>

         <hint>

            Größe des Arrays

         </hint>

      </point>

      <point name="name">

         <script language="Delphi">

            InvokeCodeCompletion;

         </script>

         <text>

            TWideString32

         </text>

         <hint>

            Name des Records

         </hint>

      </point>

      <code language="Delphi" context="typedecl" delimiter="|"><![CDATA[   Type |name| = packed Record

         Data: Array[1..|size|] of WideChar;

         Class Operator Implicit(Const Value: AnsiString):  |name|;

         Class Operator Implicit(Const Value: WideString): |name|;

         Class Operator Implicit(Const Value: |name|): WideString;

         Class Operator Equal   (Const A: |name|; Const B: WideString): Boolean;

         Class Operator NotEqual(Const A: |name|; Const B: WideString): Boolean;

      End;]]>

      </code>

      <code language="Delphi" context="decl" delimiter="|"><![CDATA[   Class Operator |name|.Implicit(Const Value: AnsiString): |name|;

      Var S: WideString;

      Begin

         S := WideString(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;

   Class Operator |name|.Implicit(Const Value: WideString): |name|;

      Begin

         If Length(Value) > Length(Result.Data) Then System.Error(reRangeError);

         Move(PWideChar(Value)^, Result.Data, Length(Value) * 2);

         If Length(Value) < Length(Result.Data) Then

            FillChar(Result.Data[Length(Value) + 1], (Length(Result.Data) - Length(Value)) * 2, 0);

      End;

   Class Operator |name|.Implicit(Const Value: |name|): WideString;

      Var i: Integer;

      Begin

         i := 0;

         While (i < Length(Value.Data)) and (Value.Data[i + Low(Value.Data)] <> #0) do Inc(i);

         SetLength(Result, i);

         Move(Value.Data, PWideChar(Result)^, i * 2);

      End;

   Class Operator |name|.Equal(Const A: |name|; Const B: WideString): Boolean;

      Var S: WideString;

      Begin

         S := A;

         Result := S = B;

      End;

   Class Operator |name|.NotEqual(Const A: |name|; Const B: WideString): Boolean;

      Begin

         Result := not (A = B);

      End;]]>

      </code>

   </template>

</codetemplate>

Wie man womöglich am Template sieht, reicht es, wenn man für jede Array-Länge erstmal 'ne eigene Recorddefinition braucht (also sollte man sich auf ein paar gebräuchliche Längen einigen/beschränken).
Dabei muß aber nur in der Definition die Länge und der Typen-Name geändert werden

Für die Ansi-Variante macht sich ein ShortString vermutlich etwas besser (bei maximal 255 Zeichen).

Ansonsten läßt sich dieser Record fast wie ein "normaler" String benutzen, ohne das man sich noch um etwas kümmern muß.

Char-Array mal "einfach"

Char-Array mal "einfach"

Forumregeln