Thread: VARIANT function or variable?

Can anyone tell what the VARIANT function or variable is used for?Is it really needed to send serial commands using C++?

VARIANT is not part of standard C. I'd imagine if the name is actually VARIANT it is really a macro anyways. can you provide more information as to help you better?

VARIANT is not part of standard C++ either. So again, can you provide some more information as to help you better?

C and C++ have no standard means of performing serial communication. Whatever method you are reading about is some specific OS.

All data is binary, your statement about sending hex data does not make sense. Do you want to send a string that looks like "0xff0xde" or numerical values? If so numbers have no base, simply their representation does.

You should probably learn C or C++ before attempting to do things specific to your OS. And reading code is generally not a decent way to learn the language.

VARIANT is pure Windoze. It's meant to be a variable "datatype" that holds or references everything windows defines - from interfaces to ints. You cannot use it outside of windoze, AFAIK.

From MSDN:

Code:

typedef struct tagVARIANT VARIANT;
typedef struct tagVARIANT VARIANTARG;
struct tagVARIANT
    {
    union 
        {
        struct __tagVARIANT
            {
            VARTYPE vt;
            WORD wReserved1;
            WORD wReserved2;
            WORD wReserved3;
            union 
                {
                LONGLONG llVal;
                LONG lVal;
                BYTE bVal;
                SHORT iVal;
                FLOAT fltVal;
                DOUBLE dblVal;
                VARIANT_BOOL boolVal;
                _VARIANT_BOOL bool;
                SCODE scode;
                CY cyVal;
                DATE date;
                BSTR bstrVal;
                IUnknown *punkVal;
                IDispatch *pdispVal;
                SAFEARRAY *parray;
                BYTE *pbVal;
                SHORT *piVal;
                LONG *plVal;
                LONGLONG *pllVal;
                FLOAT *pfltVal;
                DOUBLE *pdblVal;
                VARIANT_BOOL *pboolVal;
                _VARIANT_BOOL *pbool;
                SCODE *pscode;
                CY *pcyVal;
                DATE *pdate;
                BSTR *pbstrVal;
                IUnknown **ppunkVal;
                IDispatch **ppdispVal;
                SAFEARRAY **pparray;
                VARIANT *pvarVal;
                PVOID byref;
                CHAR cVal;
                USHORT uiVal;
                ULONG ulVal;
                ULONGLONG ullVal;
                INT intVal;
                UINT uintVal;
                DECIMAL *pdecVal;
                CHAR *pcVal;
                USHORT *puiVal;
                ULONG *pulVal;
                ULONGLONG *pullVal;
                INT *pintVal;
                UINT *puintVal;
                struct __tagBRECORD
                    {
                    PVOID pvRecord;
                    IRecordInfo *pRecInfo;
                    }    __VARIANT_NAME_4;
                }    __VARIANT_NAME_3;
            }    __VARIANT_NAME_2;
        DECIMAL decVal;
        }    __VARIANT_NAME_1;
struct tagVARIANT  
   {
    union 
       {
       struct __tagVARIANT
       {
          VARTYPE vt;
          WORD wReserved1;
          WORD wReserved2;
          WORD wReserved3;
   union {
      LONGLONG                llval;             // VT_I8. 
      LONG                    lVal;              // VT_I4.
      BYTE                    bVal;              // VT_UI1.
      SHORT                   iVal;              // VT_I2.
      FLOAT                   fltVal;            // VT_R4.
      DOUBLE                  dblVal;            // VT_R8.
      VARIANT_BOOL            boolVal;           // VT_BOOL.
      _VARIANT_BOOL           bool;
      SCODE                   scode;             // VT_ERROR.
      CY                      cyVal;             // VT_CY.
      DATE                    date;              // VT_DATE.
      BSTR                    bstrVal;           // VT_BSTR.
      IUnknown                * punkVal;         // VT_UNKNOWN.
      IDispatch               * pdispVal;        // VT_DISPATCH.
      SAFEARRAY               * parray;          // VT_ARRAY|*.
      BYTE                    * pbVal;           // VT_BYREF|VT_UI1.
      SHORT                   * piVal;           // VT_BYREF|VT_I2.
      LONG                    * plVal;           // VT_BYREF|VT_I4.
      LONGLONG                * pllVal;          // VT_BYREF|VT_I8.
      FLOAT                   * pfltVal;         // VT_BYREF|VT_R4.
      DOUBLE                  * pdblVal;         // VT_BYREF|VT_R8.
      VARIANT_BOOL            * pboolVal;        // VT_BYREF|VT_BOOL.
      _VARIANT_BOOL           * pbool;
      SCODE                   * pscode;          // VT_BYREF|VT_ERROR.
      CY                      * pcyVal;          // VT_BYREF|VT_CY.
      DATE                    * pdate;           // VT_BYREF|VT_DATE.
      BSTR                    * pbstrVal;        // VT_BYREF|VT_BSTR.
      IUnknown                ** ppunkVal;       // VT_BYREF|VT_UNKNOWN.
      IDispatch               ** ppdispVal;      // VT_BYREF|VT_DISPATCH.
      SAFEARRAY               ** pparray;        // VT_ARRAY|*.
      VARIANT                 * pvarVal;         // VT_BYREF|VT_VARIANT.
      PVOID                   * byref;           // Generic ByRef.
      CHAR                    cVal;              // VT_I1.
      USHORT                  uiVal;             // VT_UI2.
      ULONG                   ulVal;             // VT_UI4.
      ULONGLONG               ullVal;            // VT_UI8.
      INT                     intVal;            // VT_INT.
      UINT                    uintVal;           // VT_UINT.
      DECIMAL                 * pdecVal          // VT_BYREF|VT_DECIMAL.
      CHAR                    * pcVal;           // VT_BYREF|VT_I1.
      USHORT                  * puiVal;          // VT_BYREF|VT_UI2.
      ULONG                   * pulVal;          // VT_BYREF|VT_UI4.
      ULONGLONG               * pullVal;         // VT_BYREF|VT_UI8.
      INT                     * pintVal;         // VT_BYREF|VT_INT.
      UINT                    * puintVal;        // VT_BYREF|VT_UINT.
      struct __tagBRECORD
      {
      PVOID                   pvRecord;
      IRecordInfo             *pRecInfo;
      }    __VARIANT_NAME_4;
   }    __VARIANT_NAME_3;
  }    __VARIANT_NAME_2;
  DECIMAL decVal;
}    __VARIANT_NAME_1;

   };
};