用DELPHI这么多年，连这个我都不会啊！大家给看看吧！

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);
                        varString:   (VString: Pointer);
                        varAny:      (VAny: Pointer);
                        varArray:    (VArray: PVarArray);
                        varByRef:    (VPointer: Pointer);
                     );
                  1: (VLongs: array[0..2] of LongInt);
               );
            2: (VWords: array [0..6] of Word);
            3: (VBytes: array [0..13] of Byte);
          );
      1: (RawData: array [0..3] of LongInt);
  end;请问一下里面的Case Integer　of 中的Integer是什么东西，整型数？！应当怎么解释！谢　谢

解决方案 »

  1.   

    就是整型数，写成IntegerVar更容易理解些
      

  2.   

    那么DELPHI在编译的时候以什么做为基准的呢怎么辨别0还是1　呢
      

  3.   

    unit System; { Predefined constants, types, procedures, }
                 { and functions (such as True, Integer, or }
                 { Writeln) do not have actual declarations.}
                 { Instead they are built into the compiler }
                 { and are treated as if they were declared }
                 { at the beginning of the System unit. 就是说这些东西是看语句是没有意义的（such as True, Integer, or Writeln ）
    是编译器在编译之前就定义好了的，
    再说System是不能通过编译的，
    我也不太清楚，以下高手下吧
      

  4.   

    那么DELPHI在编译的时候以什么做为基准的呢？他不编译这个单元，
    Instead they are built into the compiler 
    内置到编译器？
      

  5.   

    具体怎么实现，是delphi的事了，都写了也不现实啊，就像TObject类，只些出一部份而已
      

  6.   

    To RaulWhite  这个里仅仅是个变体记录，判断域必须是有个有序类型，同时在对这个变体记录类型的变量进行操作前肯定是对判断域的内容已经实现设置的，到了这里自然有了判断的依据！
      

  7.   

    爆龙说的难啊，我不太理解~><~
    我在查资料，可能是我对RTTI东西有点敏感，
    慢慢看，RTTI我有很多理解不了，不求甚解
    有没有些书籍讲点这个的
      

  8.   

    可否这样理解
    V: Variant;
    I: Integer;
    S: String;V := I (Integer = varInteger);
    v := S (Integer = varString);
    I := V (Integer = varInteger);
      

  9.   

    我觉得应该是编译器编译时进行Integer型的辨别
    然后再进行编译
      

  10.   

    和RTTI没有关系变体记录,Pascal时代就有了,多种数据类型共用记录中相同的数据块储存信息
      

  11.   

    看样子大部份人不是对变体类型理解不了　而是看不懂定义
    但下面的代码和楼主的变体类型有多少区别啊？
    TCMMouseWheel = record
        Msg: Cardinal;
        ShiftState: TShiftState;
        Unused: Byte;
        WheelDelta: SmallInt;
        case Integer of
          0: (
            XPos: Smallint;
            YPos: Smallint);
          1: (
            Pos: TSmallPoint;
            Result: Longint);
      end;
    这里的Integer又作何解释，问题见：http://expert.csdn.net/Expert/topic/2453/2453388.xml?temp=.5412561
      

  12.   

    跟C 的union是一回事, 就是共享一段内存, 这块数据可以以不同的方式取出来用
      

  13.   

    以前没用过C，这几天Delphi里的概念有些不太明白，
    就多了解了点C，Delphi和C虽然在表现手法上不一样，
    但概念多数还是相通的(嘿嘿~~幸好公司有几个VC高手)。
    看了C的union，就明白Integer是什么东西了。
      

  14.   

    我对这个问题的理解是这样的：
        Case Integer of
          1 : ...
          2 : ...
          ...
      在这里Integer和下面的1、2……对应，完全是在源代码级让程序员看起来结构清晰，容易看懂，编译器并不对它处理，也不占相应的内存空间；1、2……后面的变量共用同一快内存空间，具体使用要由程序员自己进行控制。如果采用下面的格式：
        Case Tag: Integer of
          1 : ...
          2 : ...
          ...
        Tag是实实在在的占了一个Integer的内存空间，程序员对内存共享部分进行控制的时候使用Tag会比较方便。
        至于变体类型，Delphi没有使用Tag，而是单独定义了 VType域，围绕VType生成了大量控制代码。
      

  15.   

    case Integer of 是一个union，同一个层次的成员共享相同的一块内存区域，整个union数据长度取决于最长的一个成员长度（当然不同的成员还可以含有一个union），数据的有效性以及变量具体表达什么内容必须要程序员自己来控制，也可以再用一个辅助变量来标示，通过访问这个变量来判断union的内容。windows平台下面的Variant就是这样表示的struct tagVARIANT  {
       VARTYPE vt;
       unsigned short wReserved1;
       unsigned short wReserved2;
       unsigned short wReserved3;
       union {
          Byte                    bVal;                 // VT_UI1.
          Short                   iVal;                 // VT_I2.
          long                    lVal;                 // VT_I4.
          float                   fltVal;               // VT_R4.
          double                  dblVal;               // VT_R8.
          VARIANT_BOOL            boolVal;              // VT_BOOL.
          SCODE                   scode;                // VT_ERROR.
          CY                      cyVal;                // VT_CY.
          DATE                    date;                 // VT_DATE.
          BSTR                    bstrVal;              // VT_BSTR.
          DECIMAL                 FAR* pdecVal          // VT_BYREF|VT_DECIMAL.
          IUnknown                FAR* punkVal;         // VT_UNKNOWN.
          IDispatch               FAR* pdispVal;        // VT_DISPATCH.
          SAFEARRAY               FAR* parray;          // VT_ARRAY|*.
          Byte                    FAR* pbVal;           // VT_BYREF|VT_UI1.
          short                   FAR* piVal;           // VT_BYREF|VT_I2.
          long                    FAR* plVal;           // VT_BYREF|VT_I4.
          float                   FAR* pfltVal;         // VT_BYREF|VT_R4.
          double                  FAR* pdblVal;         // VT_BYREF|VT_R8.
          VARIANT_BOOL            FAR* pboolVal;        // VT_BYREF|VT_BOOL.
          SCODE                   FAR* pscode;          // VT_BYREF|VT_ERROR.
          CY                      FAR* pcyVal;          // VT_BYREF|VT_CY.
          DATE                    FAR* pdate;           // VT_BYREF|VT_DATE.
          BSTR                    FAR* pbstrVal;        // VT_BYREF|VT_BSTR.
          IUnknown                FAR* FAR* ppunkVal;   // VT_BYREF|VT_UNKNOWN.
          IDispatch               FAR* FAR* ppdispVal;  // VT_BYREF|VT_DISPATCH.
          SAFEARRAY               FAR* FAR* pparray;    // VT_ARRAY|*.
          VARIANT                 FAR* pvarVal;         // VT_BYREF|VT_VARIANT.
          void                    FAR* byref;           // Generic ByRef.
          char                    cVal;                 // VT_I1.
          unsigned short          uiVal;                // VT_UI2.
          unsigned long           ulVal;                // VT_UI4.
          int                     intVal;               // VT_INT.
          unsigned int            uintVal;              // VT_UINT.
          char FAR *              pcVal;                // VT_BYREF|VT_I1.
          unsigned short FAR *    puiVal;               // VT_BYREF|VT_UI2.
          unsigned long FAR *     pulVal;               // VT_BYREF|VT_UI4.
          int FAR *               pintVal;              // VT_BYREF|VT_INT.
          unsigned int FAR *      puintVal;             //VT_BYREF|VT_UINT.
       };
    };
     delphi下面的OleVariant数据类型其实就是windows下面的Variant，一模一样，不信可以打开variants等底层单元瞧瞧源代码：）。你会看到许多的vt
      

  16.   

    楼主的意思不是不理解变体记录类型，而是琢磨不透Case Integer of的“Integer”的含义，我也困扰了一段时间，后来就按上面能自圆其说地理解了。
    Dephi中定义变体类型的时候，不用Tag而用VType，想必是为了和Windows下的Variant结构统一了
      

  17.   

    去看我的贴子:
    http://expert.csdn.net/Expert/topic/2460/2460034.xml?temp=.9504358