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,
#endifLastCoreType = 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_DATASTREAMQVariant(QDataStream &s);
#endifQVariant(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_ASCIIQT_ASCII_CAST_WARN QVariant(const char *str);
#endifQVariant(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_VARIANTQVariant(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);
#endifQVariant(const QLocale &locale);
#ifndef QT_NO_REGEXPQVariant(const QRegExp &regExp);
#endif // QT_NO_REGEXP
#if QT_CONFIG(regularexpression)QVariant(const QRegularExpression &re);
#endif // QT_CONFIG(regularexpression)
#ifndef QT_BOOTSTRAPPEDQVariant(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);
#endifQVariant& operator=(const QVariant &other);
#ifdef Q_COMPILER_RVALUE_REFSinline 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; }
#endifinline 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_VARIANTQPoint toPoint() const;QPointF toPointF() const;QRect toRect() const;QSize toSize() const;QSizeF toSizeF() const;QLine toLine() const;QLineF toLineF() const;QRectF toRectF() const;
#endifQLocale toLocale() const;
#ifndef QT_NO_REGEXPQRegExp toRegExp() const;
#endif // QT_NO_REGEXP
#if QT_CONFIG(regularexpression)QRegularExpression toRegularExpression() const;
#endif // QT_CONFIG(regularexpression)
#ifndef QT_BOOTSTRAPPEDQUrl 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_DATASTREAMvoid load(QDataStream &ds);void save(QDataStream &ds) const;
#endifstatic 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 >= 201703Ltemplate<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);}
#endiftemplate<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;
#endifunion 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_DATASTREAMtypedef void (*f_load)(Private *, QDataStream &);typedef void (*f_save)(const Private *, QDataStream &);
#endiftypedef 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_DATASTREAMf_load load;f_save save;
#endiff_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_STREAMfriend 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:
#endifPrivate 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 constprivate:// force compile error, prevent QVariant(bool) to be calledinline 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 wantedinline 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*>();

VARIANT：变体数据类型

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;        //boolvParam.boolVal = true;cout<<vParam.boolVal<<endl;vParam.vt = VT_R8;        //doublevParam.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_I2operator long() const ;                            // Extracts a long from a VT_I4operator float() const ;                           // Extracts a float from a VT_R4operator double() const ;                          // Extracts a double from a VT_R8operator CY() const ;                              // Extracts a CY from a VT_CYoperator _bstr_t() const ;                         // Extracts a _bstr_t from a VT_BSTRoperator IDispatch*() const ;                      // Extracts a IDispatch* from a VT_DISPATCHoperator bool() const ;                            // Extracts a bool from a VT_BOOLoperator IUnknown*() const ;                       // Extracts a IUnknown* from a VT_UNKNOWNoperator DECIMAL() const ;                         // Extracts a DECIMAL from a VT_DECIMALoperator BYTE() const ;                            // Extracts a BTYE (unsigned char) from a VT_UI1operator VARIANT() const throw();operator char() const ;                            // Extracts a char from a VT_I1operator unsigned short() const ;                  // Extracts a unsigned short from a VT_UI2operator unsigned long() const ;                   // Extracts a unsigned long from a VT_UI4operator int() const ;                             // Extracts a int from a VT_INToperator unsigned int() const ;                    // Extracts a unsigned int from a VT_UINT
#if (_WIN32_WINNT >= 0x0501)operator __int64() const ;                         // Extracts a __int64 from a VT_I8operator 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
};

QVariant vs VARIANT相关推荐

关于QVariant 的学习一点分享
关于QVariant 的学习一点分享目录 **关于QVariant 的学习一点分享** Variant类的开发手册解读 QVariant 类的支持的类型: 常用函数: QVariant 变量在类之间 ...
QML基础类型之variant
通用属性类型. 变量类型是通用属性类型.它已过时,仅用于支持旧应用程序.新应用程序应改用var类型属性. 变量类型属性可以保存任何基本类型值: Item {property variant aNumb ...
QT之Variant
QVariant识别类型的注册 QVariant识别类型的注册 QVariant为一个万能的数据类型--可以作为许多类型互相之间进行自动转换.将C++变为弱数据类型成为可能--也是许多控件中用户定义数 ...
Qt文档阅读笔记-QVariant::value()与qvariant_cast解析及使用
目录官方解析博主栗子 QVariant::value()的小栗子 qvariant_cast小栗子 QVariant在容器中的使用官方解析 QVariant::value()与qvariant_ ...
Qt学习之路(51): QByteArray和QVariant
转:http://devbean.blog.51cto.com/448512/276235 前面我们在介绍QString的最后部分曾经提到了QByteArray这个类.现在我们就首先对这个类进行介绍. ...
QVariant类及QVariant与自定义数据类型转换的方法
这个类型相当于是Java里面的Object,它把绝大多数Qt提供的数据类型都封装起来,起到一个数据类型"擦除"的作用.比如我们的 table单元格可以是string,也可以是int ...
QString, QByteArray, 和 QVariant用法详解
转载地址:http://blog.chinaunix.net/uid-24205507-id-3262013.html QString, QByteArray, 和 QVariant这三个类和容器有许 ...
关于C++ variant 类型问题
一直想知道C++标准库有没有类似Qt下QVariant功能的类.整理了下网上关于这部分的说法: 1. std::variant 的实现是 C++17的, 使用需要考虑编译器的支持 2. _varian ...
QVariant与自定义类型互转之奇巧淫技
一.看图说话 QVariant原本就支持了很多的类型,如int.double.QString.QSize等. 那么,如何让QVariant支持自定义类型. 只需使用一条Q_DECLARE_METATY ...

QVariant vs VARIANT

VARIANT：变体数据类型

QVariant vs VARIANT相关推荐

最新文章

热门文章