QVariant 是一個變體資料型別類 ，封裝了類似c++ VARIANT 這種結構體的資料型別！
QVariant 這個型別充當著最常見的資料型別的聯合。QVariant 可以儲存很多Qt的資料型別，包括QBrush、QColor、QCursor、QDateTime、QFont、QKeySequence、 QPalette、QPen、QPixmap、QPoint、QRect、QRegion、QSize和QString，並且還有C++基本型別，如 int、float等。
當然，如果支援的型別沒有想要的，沒關係，QVariant也可以支援自定義的資料型別。被QVariant儲存的資料型別需要有一個預設的建構函式和一個拷貝建構函式。為了實現這個功能，首先必須使用Q_DECLARE_METATYPE()宏。通常會將這個宏放在類的宣告所在標頭檔案的下面：
Q_DECLARE_METATYPE(MyClass)
class Q_CORE_EXPORT QVariant
{
public:
enum Type {
Invalid = QMetaType::UnknownType,
Bool = QMetaType::Bool,
Int = QMetaType::Int,
UInt = QMetaType::UInt,
LongLong = QMetaType::LongLong,
ULongLong = QMetaType::ULongLong,
Double = QMetaType::Double,
Char = QMetaType::QChar,
Map = QMetaType::QVariantMap,
List = QMetaType::QVariantList,
String = QMetaType::QString,
StringList = QMetaType::QStringList,
ByteArray = QMetaType::QByteArray,
BitArray = QMetaType::QBitArray,
Date = QMetaType::QDate,
Time = QMetaType::QTime,
DateTime = QMetaType::QDateTime,
Url = QMetaType::QUrl,
Locale = QMetaType::QLocale,
Rect = QMetaType::QRect,
RectF = QMetaType::QRectF,
Size = QMetaType::QSize,
SizeF = QMetaType::QSizeF,
Line = QMetaType::QLine,
LineF = QMetaType::QLineF,
Point = QMetaType::QPoint,
PointF = QMetaType::QPointF,
RegExp = QMetaType::QRegExp,
RegularExpression = QMetaType::QRegularExpression,
Hash = QMetaType::QVariantHash,
EasingCurve = QMetaType::QEasingCurve,
Uuid = QMetaType::QUuid,
#if QT_CONFIG(itemmodel)
ModelIndex = QMetaType::QModelIndex,
PersistentModelIndex = QMetaType::QPersistentModelIndex,
#endif
LastCoreType = QMetaType::LastCoreType,
Font = QMetaType::QFont,
Pixmap = QMetaType::QPixmap,
Brush = QMetaType::QBrush,
Color = QMetaType::QColor,
Palette = QMetaType::QPalette,
Image = QMetaType::QImage,
Polygon = QMetaType::QPolygon,
Region = QMetaType::QRegion,
Bitmap = QMetaType::QBitmap,
Cursor = QMetaType::QCursor,
KeySequence = QMetaType::QKeySequence,
Pen = QMetaType::QPen,
TextLength = QMetaType::QTextLength,
TextFormat = QMetaType::QTextFormat,
Matrix = QMetaType::QMatrix,
Transform = QMetaType::QTransform,
Matrix4x4 = QMetaType::QMatrix4x4,
Vector2D = QMetaType::QVector2D,
Vector3D = QMetaType::QVector3D,
Vector4D = QMetaType::QVector4D,
Quaternion = QMetaType::QQuaternion,
PolygonF = QMetaType::QPolygonF,
Icon = QMetaType::QIcon,
LastGuiType = QMetaType::LastGuiType,
SizePolicy = QMetaType::QSizePolicy,
UserType = QMetaType::User,
LastType = 0xffffffff // need this so that gcc >= 3.4 allocates 32 bits for Type
};
QVariant() Q_DECL_NOTHROW : d() {}
~QVariant();
QVariant(Type type);
QVariant(int typeId, const void *copy);
QVariant(int typeId, const void *copy, uint flags);
QVariant(const QVariant &other);
#ifndef QT_NO_DATASTREAM
QVariant(QDataStream &s);
#endif
QVariant(int i);
QVariant(uint ui);
QVariant(qlonglong ll);
QVariant(qulonglong ull);
QVariant(bool b);
QVariant(double d);
QVariant(float f);
#ifndef QT_NO_CAST_FROM_ASCII
QT_ASCII_CAST_WARN QVariant(const char *str);
#endif
QVariant(const QByteArray &bytearray);
QVariant(const QBitArray &bitarray);
QVariant(const QString &string);
QVariant(QLatin1String string);
QVariant(const QStringList &stringlist);
QVariant(QChar qchar);
QVariant(const QDate &date);
QVariant(const QTime &time);
QVariant(const QDateTime &datetime);
QVariant(const QList<QVariant> &list);
QVariant(const QMap<QString,QVariant> &map);
QVariant(const QHash<QString,QVariant> &hash);
#ifndef QT_NO_GEOM_VARIANT
QVariant(const QSize &size);
QVariant(const QSizeF &size);
QVariant(const QPoint &pt);
QVariant(const QPointF &pt);
QVariant(const QLine &line);
QVariant(const QLineF &line);
QVariant(const QRect &rect);
QVariant(const QRectF &rect);
#endif
QVariant(const QLocale &locale);
#ifndef QT_NO_REGEXP
QVariant(const QRegExp ®Exp);
#endif // QT_NO_REGEXP
#if QT_CONFIG(regularexpression)
QVariant(const QRegularExpression &re);
#endif // QT_CONFIG(regularexpression)
#ifndef QT_BOOTSTRAPPED
QVariant(const QUrl &url);
QVariant(const QEasingCurve &easing);
QVariant(const QUuid &uuid);
QVariant(const QJsonValue &jsonValue);
QVariant(const QJsonObject &jsonObject);
QVariant(const QJsonArray &jsonArray);
QVariant(const QJsonDocument &jsonDocument);
#endif // QT_BOOTSTRAPPED
#if QT_CONFIG(itemmodel)
QVariant(const QModelIndex &modelIndex);
QVariant(const QPersistentModelIndex &modelIndex);
#endif
QVariant& operator=(const QVariant &other);
#ifdef Q_COMPILER_RVALUE_REFS
inline QVariant(QVariant &&other) Q_DECL_NOTHROW : d(other.d)
{ other.d = Private(); }
inline QVariant &operator=(QVariant &&other) Q_DECL_NOTHROW
{ qSwap(d, other.d); return *this; }
#endif
inline void swap(QVariant &other) Q_DECL_NOTHROW { qSwap(d, other.d); }
Type type() const;
int userType() const;
const char *typeName() const;
bool canConvert(int targetTypeId) const;
bool convert(int targetTypeId);
inline bool isValid() const;
bool isNull() const;
void clear();
void detach();
inline bool isDetached() const;
int toInt(bool *ok = nullptr) const;
uint toUInt(bool *ok = nullptr) const;
qlonglong toLongLong(bool *ok = nullptr) const;
qulonglong toULongLong(bool *ok = nullptr) const;
bool toBool() const;
double toDouble(bool *ok = nullptr) const;
float toFloat(bool *ok = nullptr) const;
qreal toReal(bool *ok = nullptr) const;
QByteArray toByteArray() const;
QBitArray toBitArray() const;
QString toString() const;
QStringList toStringList() const;
QChar toChar() const;
QDate toDate() const;
QTime toTime() const;
QDateTime toDateTime() const;
QList<QVariant> toList() const;
QMap<QString, QVariant> toMap() const;
QHash<QString, QVariant> toHash() const;
#ifndef QT_NO_GEOM_VARIANT
QPoint toPoint() const;
QPointF toPointF() const;
QRect toRect() const;
QSize toSize() const;
QSizeF toSizeF() const;
QLine toLine() const;
QLineF toLineF() const;
QRectF toRectF() const;
#endif
QLocale toLocale() const;
#ifndef QT_NO_REGEXP
QRegExp toRegExp() const;
#endif // QT_NO_REGEXP
#if QT_CONFIG(regularexpression)
QRegularExpression toRegularExpression() const;
#endif // QT_CONFIG(regularexpression)
#ifndef QT_BOOTSTRAPPED
QUrl toUrl() const;
QEasingCurve toEasingCurve() const;
QUuid toUuid() const;
QJsonValue toJsonValue() const;
QJsonObject toJsonObject() const;
QJsonArray toJsonArray() const;
QJsonDocument toJsonDocument() const;
#endif // QT_BOOTSTRAPPED
#if QT_CONFIG(itemmodel)
QModelIndex toModelIndex() const;
QPersistentModelIndex toPersistentModelIndex() const;
#endif
#ifndef QT_NO_DATASTREAM
void load(QDataStream &ds);
void save(QDataStream &ds) const;
#endif
static const char *typeToName(int typeId);
static Type nameToType(const char *name);
void *data();
const void *constData() const;
inline const void *data() const { return constData(); }
template<typename T>
inline void setValue(const T &value);
template<typename T>
inline T value() const
{ return qvariant_cast<T>(*this); }
template<typename T>
static inline QVariant fromValue(const T &value)
{ return qVariantFromValue(value); }
#if QT_HAS_INCLUDE(<variant>) && __cplusplus >= 201703L
template<typename... Types>
static inline QVariant fromStdVariant(const std::variant<Types...> &value)
{
if (value.valueless_by_exception())
return QVariant();
return std::visit([](const auto &arg) { return fromValue(arg); }, value);
}
#endif
template<typename T>
bool canConvert() const
{ return canConvert(qMetaTypeId<T>()); }
public:
struct PrivateShared
{
inline PrivateShared(void *v) : ptr(v), ref(1) { }
void *ptr;
QAtomicInt ref;
};
struct Private
{
inline Private() Q_DECL_NOTHROW : type(Invalid), is_shared(false), is_null(true)
{ data.ptr = nullptr; }
// Internal constructor for initialized variants.
explicit inline Private(uint variantType) Q_DECL_NOTHROW
: type(variantType), is_shared(false), is_null(false)
{}
#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
Private(const Private &other) Q_DECL_NOTHROW
: data(other.data), type(other.type),
is_shared(other.is_shared), is_null(other.is_null)
{}
Private &operator=(const Private &other) Q_DECL_NOTHROW = default;
#endif
union Data
{
char c;
uchar uc;
short s;
signed char sc;
ushort us;
int i;
uint u;
long l;
ulong ul;
bool b;
double d;
float f;
qreal real;
qlonglong ll;
qulonglong ull;
QObject *o;
void *ptr;
PrivateShared *shared;
} data;
uint type : 30;
uint is_shared : 1;
uint is_null : 1;
};
public:
typedef void (*f_construct)(Private *, const void *);
typedef void (*f_clear)(Private *);
typedef bool (*f_null)(const Private *);
#ifndef QT_NO_DATASTREAM
typedef void (*f_load)(Private *, QDataStream &);
typedef void (*f_save)(const Private *, QDataStream &);
#endif
typedef bool (*f_compare)(const Private *, const Private *);
typedef bool (*f_convert)(const QVariant::Private *d, int t, void *, bool *);
typedef bool (*f_canConvert)(const QVariant::Private *d, int t);
typedef void (*f_debugStream)(QDebug, const QVariant &);
struct Handler {
f_construct construct;
f_clear clear;
f_null isNull;
#ifndef QT_NO_DATASTREAM
f_load load;
f_save save;
#endif
f_compare compare;
f_convert convert;
f_canConvert canConvert;
f_debugStream debugStream;
};
inline bool operator==(const QVariant &v) const
{ return cmp(v); }
inline bool operator!=(const QVariant &v) const
{ return !cmp(v); }
inline bool operator<(const QVariant &v) const
{ return compare(v) < 0; }
inline bool operator<=(const QVariant &v) const
{ return compare(v) <= 0; }
inline bool operator>(const QVariant &v) const
{ return compare(v) > 0; }
inline bool operator>=(const QVariant &v) const
{ return compare(v) >= 0; }
protected:
friend inline bool operator==(const QVariant &, const QVariantComparisonHelper &);
#ifndef QT_NO_DEBUG_STREAM
friend Q_CORE_EXPORT QDebug operator<<(QDebug, const QVariant &);
#endif
// ### Qt6: FIXME: Remove the special Q_CC_MSVC handling, it was introduced to maintain BC for QTBUG-41810 .
#if !defined(Q_NO_TEMPLATE_FRIENDS) && !defined(Q_CC_MSVC)
template<typename T>
friend inline T qvariant_cast(const QVariant &);
template<typename T> friend struct QtPrivate::QVariantValueHelper;
protected:
#else
public:
#endif
Private d;
void create(int type, const void *copy);
bool cmp(const QVariant &other) const;
int compare(const QVariant &other) const;
bool convert(const int t, void *ptr) const; // ### Qt6: drop const
private:
// force compile error, prevent QVariant(bool) to be called
inline QVariant(void *) Q_DECL_EQ_DELETE;
// QVariant::Type is marked as \obsolete, but we don't want to
// provide a constructor from its intended replacement,
// QMetaType::Type, instead, because the idea behind these
// constructors is flawed in the first place. But we also don't
// want QVariant(QMetaType::String) to compile and falsely be an
// int variant, so delete this constructor:
QVariant(QMetaType::Type) Q_DECL_EQ_DELETE;
// These constructors don't create QVariants of the type associcated
// with the enum, as expected, but they would create a QVariant of
// type int with the value of the enum value.
// Use QVariant v = QColor(Qt::red) instead of QVariant v = Qt::red for
// example.
QVariant(Qt::GlobalColor) Q_DECL_EQ_DELETE;
QVariant(Qt::BrushStyle) Q_DECL_EQ_DELETE;
QVariant(Qt::PenStyle) Q_DECL_EQ_DELETE;
QVariant(Qt::CursorShape) Q_DECL_EQ_DELETE;
#ifdef QT_NO_CAST_FROM_ASCII
// force compile error when implicit conversion is not wanted
inline QVariant(const char *) Q_DECL_EQ_DELETE;
#endif
public:
typedef Private DataPtr;
inline DataPtr &data_ptr() { return d; }
inline const DataPtr &data_ptr() const { return d; }
};excample:
//普通使用
QVariant var;
var.setValue(12);
int data=var.toInt();自定義型別：
struct ST_TYPE
{
EN_RESULT_TYPE en_type;
QString msg;
ST_TYPE(EN_RESULT_TYPE _en_type, QString _msg) :en_type(_en_type), msg(_msg) {}
ST_TYPE() {}
};
//註冊自定義型別，待註冊的自定義型別必須有不帶引數的建構函式
Q_DECLARE_METATYPE(ST_TYPE)
//使用
ST_TYPE st(EN_DEV_SN, QString(resultBuf));
QVariant data;
data.setValue(st);指標用法：
//儲存
QVariant var=QVariant::fromValue((void*)event);
//獲取
QPaintEvent* e=(QPaintEvent*)var.value<void*>();typedef /* [wire_marshal] */ struct tagVARIANT VARIANT;
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;
} ;
typedef VARIANT *LPVARIANT;
typedef VARIANT VARIANTARG;
typedef VARIANT *LPVARIANTARG;VARIANT資料結構包含兩個域。vt域描述了第二個域的資料型別。為了使多種型別能夠在第二個域中出現，我們定義了一個聯合結構。所以，第二個域的名稱隨著vt域中輸入值的不同而改變。用於指定vt域值情況的常數在聯合的定義中以每一行的註釋形式給出
int lValue = 888;
VARIANT vParam;
vParam.vt = VT_I4;
vParam.lVal = lValue;
vParam.vt = VT_BOOL; //bool
vParam.boolVal = true;
cout<<vParam.boolVal<<endl;
vParam.vt = VT_R8; //double
vParam.dblVal = 3.23;
cout<<vParam.dblVal<<endl;
相關的 vt型別 定義如下
enum VARENUM
{
VT_EMPTY = 0,
VT_NULL = 1,
VT_I2 = 2,
VT_I4 = 3,
VT_R4 = 4,
VT_R8 = 5,
VT_CY = 6,
VT_DATE = 7,
VT_BSTR = 8,
VT_DISPATCH = 9,
VT_ERROR = 10,
VT_BOOL = 11,
VT_VARIANT = 12,
VT_UNKNOWN = 13,
VT_DECIMAL = 14,
VT_I1 = 16,
VT_UI1 = 17,
VT_UI2 = 18,
VT_UI4 = 19,
VT_I8 = 20,
VT_UI8 = 21,
VT_INT = 22,
VT_UINT = 23,
VT_VOID = 24,
VT_HRESULT = 25,
VT_PTR = 26,
VT_SAFEARRAY = 27,
VT_CARRAY = 28,
VT_USERDEFINED = 29,
VT_LPSTR = 30,
VT_LPWSTR = 31,
VT_RECORD = 36,
VT_INT_PTR = 37,
VT_UINT_PTR = 38,
VT_FILETIME = 64,
VT_BLOB = 65,
VT_STREAM = 66,
VT_STORAGE = 67,
VT_STREAMED_OBJECT = 68,
VT_STORED_OBJECT = 69,
VT_BLOB_OBJECT = 70,
VT_CF = 71,
VT_CLSID = 72,
VT_VERSIONED_STREAM = 73,
VT_BSTR_BLOB = 0xfff,
VT_VECTOR = 0x1000,
VT_ARRAY = 0x2000,
VT_BYREF = 0x4000,
VT_RESERVED = 0x8000,
VT_ILLEGAL = 0xffff,
VT_ILLEGALMASKED = 0xfff,
VT_TYPEMASK = 0xfff
} ;主要分為兩步：第一步是確定輸入資料的型別，根據自己需要的型別在第一張vt域的值圖中找到對應的值型別，初始化vt域值：
vParam.vt = xxxx; //對應的值型別，如int型就是VT_I4 要考慮32、64位元第二步就是根據第二張資料內容標識圖根據之前vt域確定的資料型別找到成員對其進行賦值：
vParam.lVal = 100999; //int型對應的成員識別符號為lVal，對var.lVal成員賦值100999
_variant_t 類是對VARIANT的一個繼承與封裝，這就與 QVariant基本功能類似了
class _variant_t : public ::tagVARIANT {
public:
// Constructors
//
_variant_t() throw();
_variant_t(const VARIANT& varSrc) ;
_variant_t(const VARIANT* pSrc) ;
_variant_t(const _variant_t& varSrc) ;
_variant_t(VARIANT& varSrc, bool fCopy) ; // Attach VARIANT if !fCopy
_variant_t(short sSrc, VARTYPE vtSrc = VT_I2) ; // Creates a VT_I2, or a VT_BOOL
_variant_t(long lSrc, VARTYPE vtSrc = VT_I4) ; // Creates a VT_I4, a VT_ERROR, or a VT_BOOL
_variant_t(float fltSrc) throw(); // Creates a VT_R4
_variant_t(double dblSrc, VARTYPE vtSrc = VT_R8) ; // Creates a VT_R8, or a VT_DATE
_variant_t(const CY& cySrc) throw(); // Creates a VT_CY
_variant_t(const _bstr_t& bstrSrc) ; // Creates a VT_BSTR
_variant_t(const wchar_t *pSrc) ; // Creates a VT_BSTR
_variant_t(const char* pSrc) ; // Creates a VT_BSTR
_variant_t(IDispatch* pSrc, bool fAddRef = true) throw(); // Creates a VT_DISPATCH
_variant_t(bool boolSrc) throw(); // Creates a VT_BOOL
_variant_t(IUnknown* pSrc, bool fAddRef = true) throw(); // Creates a VT_UNKNOWN
_variant_t(const DECIMAL& decSrc) throw(); // Creates a VT_DECIMAL
_variant_t(BYTE bSrc) throw(); // Creates a VT_UI1
_variant_t(char cSrc) throw(); // Creates a VT_I1
_variant_t(unsigned short usSrc) throw(); // Creates a VT_UI2
_variant_t(unsigned long ulSrc) throw(); // Creates a VT_UI4
_variant_t(int iSrc) throw(); // Creates a VT_INT
_variant_t(unsigned int uiSrc) throw(); // Creates a VT_UINT
#if (_WIN32_WINNT >= 0x0501)
_variant_t(__int64 i8Src) throw(); // Creates a VT_I8
_variant_t(unsigned __int64 ui8Src) throw(); // Creates a VT_UI8
#endif
// Destructor
//
~_variant_t() throw() ;
// Extractors
//
operator short() const ; // Extracts a short from a VT_I2
operator long() const ; // Extracts a long from a VT_I4
operator float() const ; // Extracts a float from a VT_R4
operator double() const ; // Extracts a double from a VT_R8
operator CY() const ; // Extracts a CY from a VT_CY
operator _bstr_t() const ; // Extracts a _bstr_t from a VT_BSTR
operator IDispatch*() const ; // Extracts a IDispatch* from a VT_DISPATCH
operator bool() const ; // Extracts a bool from a VT_BOOL
operator IUnknown*() const ; // Extracts a IUnknown* from a VT_UNKNOWN
operator DECIMAL() const ; // Extracts a DECIMAL from a VT_DECIMAL
operator BYTE() const ; // Extracts a BTYE (unsigned char) from a VT_UI1
operator VARIANT() const throw();
operator char() const ; // Extracts a char from a VT_I1
operator unsigned short() const ; // Extracts a unsigned short from a VT_UI2
operator unsigned long() const ; // Extracts a unsigned long from a VT_UI4
operator int() const ; // Extracts a int from a VT_INT
operator unsigned int() const ; // Extracts a unsigned int from a VT_UINT
#if (_WIN32_WINNT >= 0x0501)
operator __int64() const ; // Extracts a __int64 from a VT_I8
operator unsigned __int64() const ; // Extracts a unsigned __int64 from a VT_UI8
#endif
// Assignment operations
//
_variant_t& operator=(const VARIANT& varSrc) ;
_variant_t& operator=(const VARIANT* pSrc) ;
_variant_t& operator=(const _variant_t& varSrc) ;
_variant_t& operator=(short sSrc) ; // Assign a VT_I2, or a VT_BOOL
_variant_t& operator=(long lSrc) ; // Assign a VT_I4, a VT_ERROR or a VT_BOOL
_variant_t& operator=(float fltSrc) ; // Assign a VT_R4
_variant_t& operator=(double dblSrc) ; // Assign a VT_R8, or a VT_DATE
_variant_t& operator=(const CY& cySrc) ; // Assign a VT_CY
_variant_t& operator=(const _bstr_t& bstrSrc) ; // Assign a VT_BSTR
_variant_t& operator=(const wchar_t* pSrc) ; // Assign a VT_BSTR
_variant_t& operator=(const char* pSrc) ; // Assign a VT_BSTR
_variant_t& operator=(IDispatch* pSrc) ; // Assign a VT_DISPATCH
_variant_t& operator=(bool boolSrc) ; // Assign a VT_BOOL
_variant_t& operator=(IUnknown* pSrc) ; // Assign a VT_UNKNOWN
_variant_t& operator=(const DECIMAL& decSrc) ; // Assign a VT_DECIMAL
_variant_t& operator=(BYTE bSrc) ; // Assign a VT_UI1
_variant_t& operator=(char cSrc) ; // Assign a VT_I1
_variant_t& operator=(unsigned short usSrc) ; // Assign a VT_UI2
_variant_t& operator=(unsigned long ulSrc) ; // Assign a VT_UI4
_variant_t& operator=(int iSrc) ; // Assign a VT_INT
_variant_t& operator=(unsigned int uiSrc) ; // Assign a VT_UINT
#if (_WIN32_WINNT >= 0x0501)
_variant_t& operator=(__int64 i8Src) ; // Assign a VT_I8
_variant_t& operator=(unsigned __int64 ui8Src) ; // Assign a VT_UI8
#endif
// Comparison operations
//
bool operator==(const VARIANT& varSrc) const throw();
bool operator==(const VARIANT* pSrc) const throw();
bool operator!=(const VARIANT& varSrc) const throw();
bool operator!=(const VARIANT* pSrc) const throw();
// Low-level operations
//
void Clear() ;
void Attach(VARIANT& varSrc) ;
VARIANT Detach() throw();
VARIANT& GetVARIANT() throw();
VARIANT* GetAddress() ;
void ChangeType(VARTYPE vartype, const _variant_t* pSrc = NULL) ;
void SetString(const char* pSrc) ; // used to set ANSI string
};