Einzelnen Beitrag anzeigen

Benutzerbild von himitsu
himitsu

Registriert seit: 11. Okt 2003
Ort: Elbflorenz
43.240 Beiträge
 
Delphi 12 Athens
 
#5

AW: Ole Automation? Variants? Was ist das?

  Alt 24. Dez 2013, 14:11
In Delphi wird der Vaiant mehr wie ein Record verwaltet.

Du kannst das mit den Record Operatoren vergleichen, wo in dem Variant schon automatische Konvertierungen integriert sind.
Aber eigentlich ist das ein Windows-Typ, ähnlich dem WideString, welcher im Delphi entsprechend weggekapselt ist.

Delphi-Quellcode:
var
  X: Variant;

X := 123;
ShowMessage(IntToStr(X));
ShowMessage(X);

X := 'abc';
ShowMessage(X);

X := '789';
ShowMessage(X);
ShowMessage(IntToStr(X + 210));
Die Unit Variants wäre noch interessant, wo viele Funktionen drin sind, um die Typen manuell umzuwandeln oder um zu prüfen welcher Typ grade im Variant steckt.
Und falls man selber den Variant erweitern will, dann könnte man beim TVariantManager weiter suchen.

Bissl was zum Aufbau, falls dich das interessiert (system.pas):
Delphi-Quellcode:
  varEmpty = $0000; { vt_empty        0 }
  varNull = $0001; { vt_null         1 }
  varSmallint = $0002; { vt_i2           2 }
  varInteger = $0003; { vt_i4           3 }
  varSingle = $0004; { vt_r4           4 }
  varDouble = $0005; { vt_r8           5 }
  varCurrency = $0006; { vt_cy           6 }
  varDate = $0007; { vt_date         7 }
  varOleStr = $0008; { vt_bstr         8 }
  varDispatch = $0009; { vt_dispatch     9 }
  varError = $000A; { vt_error       10 }
  varBoolean = $000B; { vt_bool        11 }
  varVariant = $000C; { vt_variant     12 }
  varUnknown = $000D; { vt_unknown     13 }
//varDecimal = $000E; { vt_decimal 14 } {UNSUPPORTED as of v6.x code base}
//varUndef0F = $000F; { undefined 15 } {UNSUPPORTED per Microsoft}
  varShortInt = $0010; { vt_i1          16 }
  varByte = $0011; { vt_ui1         17 }
  varWord = $0012; { vt_ui2         18 }
  varLongWord = $0013; { vt_ui4         19 }
  varInt64 = $0014; { vt_i8          20 }
  varUInt64 = $0015; { vt_ui8         21 }
  varRecord = $0024; { VT_RECORD      36 }
{  if adding new items, update Variants' varLast, BaseTypeMap and OpTypeMap }

  varStrArg = $0048; { vt_clsid        72 }
  varObject = $0049; {                 73 }
  varUStrArg = $004A; {                 74 }
  varString = $0100; { Pascal string  256 } {not OLE compatible }
  varAny = $0101; { Corba any      257 } {not OLE compatible }
  varUString = $0102; { Unicode string 258 } {not OLE compatible }
  // custom types range from $110 (272) to $7FF (2047)

  varTypeMask = $0FFF;
  varArray = $2000;
  varByRef = $4000;

  TVarData = packed record
    case Integer of
      0: (VType: TVarType;
          case Integer of
            0: (Reserved1: Word;
                case Integer of
                  0: (Reserved2, Reserved3: Word;
                      case Integer of
                        varSmallInt: (VSmallInt: SmallInt);
                        varInteger: (VInteger: Integer);
                        varSingle: (VSingle: Single);
                        varDouble: (VDouble: Double);
                        varCurrency: (VCurrency: Currency);
                        varDate: (VDate: TDateTime);
                        varOleStr: (VOleStr: PWideChar);
                        varDispatch: (VDispatch: Pointer);
                        varError: (VError: HRESULT);
                        varBoolean: (VBoolean: WordBool);
                        varUnknown: (VUnknown: Pointer);
                        varShortInt: (VShortInt: ShortInt);
                        varByte: (VByte: Byte);
                        varWord: (VWord: Word);
                        varLongWord: (VLongWord: LongWord);
                        varInt64: (VInt64: Int64);
                        varUInt64: (VUInt64: UInt64);
                        varString: (VString: Pointer);
                        varAny: (VAny: Pointer);
                        varArray: (VArray: PVarArray);
                        varByRef: (VPointer: Pointer);
                        varUString: (VUString: Pointer);
                        varRecord: (VRecord: TVarRecord);
                        //$ffff: (VLargest: TLargestVarData);
                     );
                  1: (VLongs: array[0..{$IFDEF CPUX64}4{$ELSE}2{$ENDIF}] of LongInt);
               );
            2: (VWords: array [0..{$IFDEF CPUX64}10{$ELSE}6{$ENDIF}] of Word);
            3: (VBytes: array [0..{$IFDEF CPUX64}21{$ELSE}13{$ENDIF}] of Byte);
          );
      1: (RawData: array [0..{$IFDEF CPUX64}5{$ELSE}3{$ENDIF}] of LongInt);
  end;
Garbage Collector ... Delphianer erzeugen keinen Müll, also brauchen sie auch keinen Müllsucher.
my Delphi wish list : BugReports/FeatureRequests

Geändert von himitsu (24. Dez 2013 um 14:21 Uhr)
  Mit Zitat antworten Zitat