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?

I have seen the VARIANT used as a declaration in C++ and was curious as to its purpose. What is its equivalent in C? Is it really needed in C?

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

Well I am trying to get better acquainted on serial communication in C and C++ and I have noticed the use of VARIANT declaration in several examples in C++ and I am curious as to its usage. Basically, I just want to know if I need it. I found that C++ sends out data in binary format so VARIANT is used to convert data to binary. I want to send Hex data through the serial port. Is it possible or do I have to convert it to Binary like in C++?

It seems to me you were looking at VB examples, rather than C or C++ examples.

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;

  };
};

---