使用C++定义一个万能类型
分享一个类似于Qt中QVariant类。
目录：
1 类型定义
2 数值操作
3 万能类型包装
4 使用
——————————————————Begain——————————————————
类型定义
typedef.h
#ifndef TYPEDEF_H
#define TYPEDEF_H
#include <stdint.h>
#include <set> using namespace std; enum class VariantType : uint16_t
{
vt_empty = , //!< 类型为定义
vt_bool = , //!< bool类型
vt_i4 = , //!< int32_t 类型
vt_ui4 = , //!< uint32_t 类型
vt_i8 = , //!< int64_t 类型
vt_ui8 = , //!< uint64_t 类型
vt_r4 = , //!< float 类型
vt_r8 = , //!< double 类型
vt_bstr = , //!< const char* 类型
vt_set = 0x1000, //!< 集合类型，该类型的值需要用过特定函数获取，不能直接通过成员变量获取
}; struct VariantValue
{
uint16_t m_vt; //!< 值得类型,取值参看枚举VariantType，其中vt_set可以与其他值联合使用
union
{
bool m_bVal;
int32_t m_i4Val;
uint32_t m_ui4Val;
int64_t m_i8Val;
uint64_t m_ui8Val;
float m_r4Val;
double m_r8Val;
char* m_strVal;
void* m_pSetVal;
};
}; template<typename T>
void VariantSetValueDelete(set<T> *pSetValue)
{
if (pSetValue)
{
delete pSetValue;
pSetValue = nullptr;
}
} template<typename T>
void VariantSetValueCopy(VariantValue &toValue, const set<T> *pFromValue)
{
if (nullptr == pFromValue)
return; toValue.m_pSetVal = new set<T>(*pFromValue);
} template<typename T>
uint32_t VariantSetValueSize(set<T> *pSetValue)
{
return pSetValue ? static_cast<uint32_t>(pSetValue->size()) : ;
} template<typename T>
bool VariantSetValueAt(set<T> *pSetValue, uint32_t uIndex, T &subValue)
{
if (nullptr == pSetValue)
return false; auto it = pSetValue->begin(); advance(it, uIndex);
if (it == pSetValue->end())
return false; subValue = *it;
return true;
} template<typename T>
bool VariantSetValueAdd(set<T> *pSetValue, T value)
{
if (nullptr == pSetValue)
return false; auto it = pSetValue->find(value); if (it == pSetValue->end())
return false; pSetValue->insert(value);
return true;
} template<typename T>
bool VariantSetValueRemove(set<T> *pSetValue, T value)
{
if (nullptr == pSetValue)
return false; auto it = pSetValue->find(value); if (it == pSetValue->end())
return false; pSetValue->erase(it);
return true;
} #endif // TYPEDEF_H
数值操作
valueopt.h
#ifndef VALUEOPT_H
#define VALUEOPT_H
#include "typedef.h"
#include <stdint.h> void VariantValueInit(VariantValue &value); void VariantValueClear(VariantValue &value); void VariantValueCopy(VariantValue &toValue, const VariantValue &from); uint32_t VariantValueSetSize(const VariantValue &valueSet); bool VariantValueSetAt(const VariantValue &valueSet, uint32_t uIndex, VariantValue &value); bool VariantValueSetAdd(VariantValue &valueSet, const VariantValue &value); #endif // VALUEOPT_H
valueopt.cpp
#include <iostream> #include "valueopt.h"
#include <string.h>
#include <valueopt.h> using namespace std; void VariantValueInit(VariantValue &value)
{
memset(&value, , sizeof(value));
value.m_vt = (uint16_t)VariantType::vt_empty;
value.m_pSetVal = nullptr;
} void VariantValueClear(VariantValue &value)
{
if (value.m_vt & (uint16_t)VariantType::vt_set)
{
uint16_t uType = (uint16_t)value.m_vt & 0xff; switch ((VariantType)uType)
{
case VariantType::vt_bool:
VariantSetValueDelete(reinterpret_cast<set<bool> *>(value.m_pSetVal));
break;
case VariantType::vt_i4:
VariantSetValueDelete(reinterpret_cast<set<int32_t> *>(value.m_pSetVal));
break;
case VariantType::vt_ui4:
VariantSetValueDelete(reinterpret_cast<set<uint32_t> *>(value.m_pSetVal));
break;
case VariantType::vt_i8:
VariantSetValueDelete(reinterpret_cast<set<int64_t> *>(value.m_pSetVal));
break;
case VariantType::vt_ui8:
VariantSetValueDelete(reinterpret_cast<set<uint64_t> *>(value.m_pSetVal));
break;
case VariantType::vt_r4:
VariantSetValueDelete(reinterpret_cast<set<float> *>(value.m_pSetVal));
break;
case VariantType::vt_r8:
VariantSetValueDelete(reinterpret_cast<set<double> *>(value.m_pSetVal));
break;
case VariantType::vt_bstr:
VariantSetValueDelete(reinterpret_cast<set<string> *>(value.m_pSetVal));
break;
default:
break;
}
}
else
{
if (((uint16_t)VariantType::vt_bstr == value.m_vt) && value.m_strVal)
delete[]value.m_strVal;
} memset(&value, , sizeof(value));
value.m_vt = (uint16_t)VariantType::vt_empty;
} void VariantValueCopy(VariantValue &toValue, const VariantValue &from)
{
VariantValueClear(toValue); if (from.m_vt & (uint16_t)VariantType::vt_set)
{
uint16_t uType = (uint16_t)from.m_vt & 0xff; switch ((VariantType)uType)
{
case VariantType::vt_bool:
toValue.m_vt = from.m_vt;
VariantSetValueCopy(toValue, reinterpret_cast<set<bool> *>(from.m_pSetVal));
break;
case VariantType::vt_i4:
toValue.m_vt = from.m_vt;
VariantSetValueCopy(toValue, reinterpret_cast<set<int32_t> *>(from.m_pSetVal));
break;
case VariantType::vt_ui4:
toValue.m_vt = from.m_vt;
VariantSetValueCopy(toValue, reinterpret_cast<set<uint32_t> *>(from.m_pSetVal));
break;
case VariantType::vt_i8:
toValue.m_vt = from.m_vt;
VariantSetValueCopy(toValue, reinterpret_cast<set<int64_t> *>(from.m_pSetVal));
break;
case VariantType::vt_ui8:
toValue.m_vt = from.m_vt;
VariantSetValueCopy(toValue, reinterpret_cast<set<uint64_t> *>(from.m_pSetVal));
break;
case VariantType::vt_r4:
toValue.m_vt = from.m_vt;
VariantSetValueCopy(toValue, reinterpret_cast<set<float> *>(from.m_pSetVal));
break;
case VariantType::vt_r8:
toValue.m_vt = from.m_vt;
VariantSetValueCopy(toValue, reinterpret_cast<set<double> *>(from.m_pSetVal));
break;
case VariantType::vt_bstr:
toValue.m_vt = from.m_vt;
VariantSetValueCopy(toValue, reinterpret_cast<set<string> *>(from.m_pSetVal));
break;
default:
break;
}
}
else
{
if ((uint16_t)VariantType::vt_bstr == from.m_vt)
{
toValue.m_vt = from.m_vt;
if (nullptr != from.m_strVal)
{
uint32_t uLen = strlen(from.m_strVal); toValue.m_strVal = new char[uLen + ];
memcpy(toValue.m_strVal, from.m_strVal, uLen);
toValue.m_strVal[uLen] = '\0';
}
else
{
toValue.m_strVal = nullptr;
}
}
else
{
memcpy(&toValue, &from, sizeof(from));
}
}
} uint32_t VariantValueSetSize(const VariantValue &valueSet)
{
uint32_t uCount = ; if (valueSet.m_vt & (uint16_t)VariantType::vt_set)
{
uint16_t uType = (uint16_t)valueSet.m_vt & 0xff; switch ((VariantType)uType)
{
case VariantType::vt_bool:
uCount = VariantSetValueSize(reinterpret_cast<set<bool> *>(valueSet.m_pSetVal));
break;
case VariantType::vt_i4:
uCount = VariantSetValueSize(reinterpret_cast<set<int32_t> *>(valueSet.m_pSetVal));
break;
case VariantType::vt_ui4:
uCount = VariantSetValueSize(reinterpret_cast<set<uint32_t> *>(valueSet.m_pSetVal));
break;
case VariantType::vt_i8:
uCount = VariantSetValueSize(reinterpret_cast<set<int64_t> *>(valueSet.m_pSetVal));
break;
case VariantType::vt_ui8:
uCount = VariantSetValueSize(reinterpret_cast<set<uint64_t> *>(valueSet.m_pSetVal));
break;
case VariantType::vt_r4:
uCount = VariantSetValueSize(reinterpret_cast<set<float> *>(valueSet.m_pSetVal));
break;
case VariantType::vt_r8:
uCount = VariantSetValueSize(reinterpret_cast<set<double> *>(valueSet.m_pSetVal));
break;
case VariantType::vt_bstr:
uCount = VariantSetValueSize(reinterpret_cast<set<string> *>(valueSet.m_pSetVal));
break;
default:
break;
}
}
else
{
uCount = ;
} return uCount;
} bool VariantValueSetAt(const VariantValue &valueSet, uint32_t uIndex, VariantValue &value)
{
bool bResult = false; VariantValueClear(value);
if (valueSet.m_vt & (uint16_t)VariantType::vt_set)
{
VariantValue value; value.m_vt = (uint16_t)valueSet.m_vt & 0xff;
switch ((VariantType)value.m_vt)
{
case VariantType::vt_bool:
bResult = VariantSetValueAt(reinterpret_cast<set<bool> *>(valueSet.m_pSetVal), uIndex, value.m_bVal);
break;
case VariantType::vt_i4:
bResult = VariantSetValueAt(reinterpret_cast<set<int32_t> *>(valueSet.m_pSetVal), uIndex, value.m_i4Val);
break;
case VariantType::vt_ui4:
bResult = VariantSetValueAt(reinterpret_cast<set<uint32_t> *>(valueSet.m_pSetVal), uIndex, value.m_ui4Val);
break;
case VariantType::vt_i8:
bResult = VariantSetValueAt(reinterpret_cast<set<int64_t> *>(valueSet.m_pSetVal), uIndex, value.m_i8Val);
break;
case VariantType::vt_ui8:
bResult = VariantSetValueAt(reinterpret_cast<set<uint64_t> *>(valueSet.m_pSetVal), uIndex, value.m_ui8Val);
break;
case VariantType::vt_r4:
bResult = VariantSetValueAt(reinterpret_cast<set<float> *>(valueSet.m_pSetVal), uIndex, value.m_r4Val);
break;
case VariantType::vt_r8:
bResult = VariantSetValueAt(reinterpret_cast<set<double> *>(valueSet.m_pSetVal), uIndex, value.m_r8Val);
break;
case VariantType::vt_bstr:
{
string strValue; bResult = VariantSetValueAt(reinterpret_cast<set<string> *>(valueSet.m_pSetVal), uIndex, strValue);
if (bResult)
{
uint32_t uLen = (uint32_t)strValue.length(); value.m_strVal = new char[uLen + ];
memcpy(value.m_strVal, strValue.c_str(), uLen);
value.m_strVal[uLen] = '\0';
}
}
break;
default:
bResult = false;
break;
}
}
else
{
VariantValueCopy(value, valueSet);
} return bResult;
} bool VariantValueSetAdd(VariantValue &valueSet, const VariantValue &value)
{
bool bResult = false; if (valueSet.m_vt == (uint16_t)VariantType::vt_empty)
{
if (value.m_vt == (uint16_t)VariantType::vt_empty)
return false; valueSet.m_vt = (uint16_t)VariantType::vt_set | (uint16_t)value.m_vt;
} if (valueSet.m_vt & (uint16_t)VariantType::vt_set)
{
uint16_t uType = (uint16_t)valueSet.m_vt & 0xff; if (uType != (uint16_t)value.m_vt)
return false; switch ((VariantType)uType)
{
case VariantType::vt_bool:
if (nullptr == valueSet.m_pSetVal)
valueSet.m_pSetVal = new set<bool>();
bResult = VariantSetValueAdd(reinterpret_cast<set<bool> *>(valueSet.m_pSetVal), value.m_bVal);
break;
case VariantType::vt_i4:
if (nullptr == valueSet.m_pSetVal)
valueSet.m_pSetVal = new set<int32_t>();
bResult = VariantSetValueAdd(reinterpret_cast<set<int32_t> *>(valueSet.m_pSetVal), value.m_i4Val);
break;
case VariantType::vt_ui4:
if (nullptr == valueSet.m_pSetVal)
valueSet.m_pSetVal = new set<uint32_t>();
bResult = VariantSetValueAdd(reinterpret_cast<set<uint32_t> *>(valueSet.m_pSetVal), value.m_ui4Val);
break;
case VariantType::vt_i8:
if (nullptr == valueSet.m_pSetVal)
valueSet.m_pSetVal = new set<int64_t>();
bResult = VariantSetValueAdd(reinterpret_cast<set<int64_t> *>(valueSet.m_pSetVal), value.m_i8Val);
break;
case VariantType::vt_ui8:
if (nullptr == valueSet.m_pSetVal)
valueSet.m_pSetVal = new set<uint64_t>();
bResult = VariantSetValueAdd(reinterpret_cast<set<uint64_t> *>(valueSet.m_pSetVal), value.m_ui8Val);
break;
case VariantType::vt_r4:
if (nullptr == valueSet.m_pSetVal)
valueSet.m_pSetVal = new set<float>();
bResult = VariantSetValueAdd(reinterpret_cast<set<float> *>(valueSet.m_pSetVal), value.m_r4Val);
break;
case VariantType::vt_r8:
if (nullptr == valueSet.m_pSetVal)
valueSet.m_pSetVal = new set<double>();
bResult = VariantSetValueAdd(reinterpret_cast<set<double> *>(valueSet.m_pSetVal), value.m_r8Val);
break;
case VariantType::vt_bstr:
if (value.m_strVal)
{
if (nullptr == valueSet.m_pSetVal)
valueSet.m_pSetVal = new set<string>();
bResult = VariantSetValueAdd(reinterpret_cast<set<string> *>(valueSet.m_pSetVal), string(value.m_strVal));
}
else
{
bResult = false;
}
break;
default:
bResult = false;
break;
}
}
else
{
bResult = false;
} return bResult;
}
万能类型包装
CustomVariantValue.h
#ifndef CUSTOMVARIANTVALUE_H
#define CUSTOMVARIANTVALUE_H
#include <iostream>
#include <stdint.h>
#include <set>
#include <vector>
#include <cstring>
#include <typedef.h>
#include <assert.h>
using namespace std; class CustomVariantValue : private VariantValue
{
public:
CustomVariantValue();
CustomVariantValue(bool bValue);
CustomVariantValue(int32_t nValue);
CustomVariantValue(uint32_t uValue);
CustomVariantValue(int64_t nValue);
CustomVariantValue(uint64_t uValue);
CustomVariantValue(float fValue);
CustomVariantValue(double dValue);
CustomVariantValue(const char *pChar);
CustomVariantValue(const std::string &strChar);
CustomVariantValue(const std::vector<bool> &valueVector);
CustomVariantValue(const std::vector<int32_t> &valueVector);
CustomVariantValue(const std::vector<uint32_t> &valueVector);
CustomVariantValue(const std::vector<int64_t> &valueVector);
CustomVariantValue(const std::vector<uint64_t> &valueVector);
CustomVariantValue(const std::vector<float> &valueVector);
CustomVariantValue(const std::vector<double> &valueVector);
CustomVariantValue(const std::vector<std::string> &valueVector);
CustomVariantValue(const std::set<bool> &valueSet);
CustomVariantValue(const std::set<int32_t> &valueSet);
CustomVariantValue(const std::set<uint32_t> &valueSet);
CustomVariantValue(const std::set<int64_t> &valueSet);
CustomVariantValue(const std::set<uint64_t> &valueSet);
CustomVariantValue(const std::set<float> &valueSet);
CustomVariantValue(const std::set<double> &valueSet);
CustomVariantValue(const std::set<std::string> &valueSet);
CustomVariantValue(const VariantValue &value);
CustomVariantValue(const CustomVariantValue &other); public:
CustomVariantValue& operator = (bool bValue);
CustomVariantValue& operator = (int32_t nValue);
CustomVariantValue& operator = (uint32_t uValue);
CustomVariantValue& operator = (int64_t nValue);
CustomVariantValue& operator = (uint64_t uValue);
CustomVariantValue& operator = (float fValue);
CustomVariantValue& operator = (double dValue);
CustomVariantValue& operator = (const char *pChar);
CustomVariantValue& operator = (const std::string &strChar);
CustomVariantValue& operator = (const std::vector<bool> &valueVector);
CustomVariantValue& operator = (const std::vector<int32_t> &valueVector);
CustomVariantValue& operator = (const std::vector<uint32_t> &valueVector);
CustomVariantValue& operator = (const std::vector<int64_t> &valueVector);
CustomVariantValue& operator = (const std::vector<uint64_t> &valueVector);
CustomVariantValue& operator = (const std::vector<float> &valueVector);
CustomVariantValue& operator = (const std::vector<double> &valueVector);
CustomVariantValue& operator = (const std::vector<std::string> &valueVector);
CustomVariantValue& operator = (const std::set<bool> &valueSet);
CustomVariantValue& operator = (const std::set<int32_t> &valueSet);
CustomVariantValue& operator = (const std::set<uint32_t> &valueSet);
CustomVariantValue& operator = (const std::set<int64_t> &valueSet);
CustomVariantValue& operator = (const std::set<uint64_t> &valueSet);
CustomVariantValue& operator = (const std::set<float> &valueSet);
CustomVariantValue& operator = (const std::set<double> &valueSet);
CustomVariantValue& operator = (const std::set<std::string> &valueSet);
CustomVariantValue& operator = (const VariantValue &value);
CustomVariantValue& operator = (const CustomVariantValue &other); bool operator==(const VariantValue& value);
bool operator==(const CustomVariantValue& value); bool operator!=(const VariantValue& value);
bool operator!=(const CustomVariantValue& value); operator bool() const
{
assert((uint16_t)VariantType::vt_bool == m_vt);
return m_bVal;
} operator int32_t() const
{
assert((uint16_t)VariantType::vt_i4 == m_vt);
return m_i4Val;
} operator uint32_t() const
{
assert((uint16_t)VariantType::vt_ui4 == m_vt);
return m_ui4Val;
} operator int64_t() const
{
assert((uint16_t)VariantType::vt_i8 == m_vt);
return m_i8Val;
} operator uint64_t() const
{
assert((uint16_t)VariantType::vt_ui8 == m_vt);
return m_ui4Val;
} operator float() const
{
assert((uint16_t)VariantType::vt_r4 == m_vt);
return m_r4Val;
} operator double() const
{
assert((uint16_t)VariantType::vt_r8 == m_vt);
return m_r8Val;
} operator const char*() const
{
assert((uint16_t)VariantType::vt_bstr == m_vt);
return m_strVal;
} std::vector<bool> ToBoolArray() const;
std::vector<int32_t> ToInt32Array() const;
std::vector<uint32_t> ToUint32Array() const;
std::vector<int64_t> ToInt64Array() const;
std::vector<uint64_t> ToUint64Array() const;
std::vector<float> ToFloatArray() const;
std::vector<double> ToDoubleArray() const;
std::vector<std::string> ToStringArray() const; std::set<bool>& ToBoolSet();
std::set<int32_t>& ToInt32Set();
std::set<uint32_t>& ToUint32Set();
std::set<int64_t>& ToInt64Set();
std::set<uint64_t>& ToUint64Set();
std::set<float>& ToFloatSet();
std::set<double>& ToDoubleSet();
std::set<std::string>& ToStringSet(); private: private:
bool Compare(const VariantValue& value);
}; #endif // CUSTOMVARIANTVALUE_H
CustomVariantValue.cpp
#include "customvariantvalue.h"
#include "valueopt.h" namespace
{
template<typename T>
bool VariantSetValueComplie(std::set<T> *pSetValue1, std::set<T> *pSetValue2)
{
if ((nullptr == pSetValue1) && (nullptr == pSetValue2))
return true; if ((nullptr == pSetValue1) || (nullptr == pSetValue2))
return false; return (*pSetValue1) == (*pSetValue2);
}
} CustomVariantValue::CustomVariantValue()
{
VariantValueInit(*this);
} CustomVariantValue::CustomVariantValue(bool bValue)
{
m_vt = (uint16_t)VariantType::vt_bool;
m_bVal = bValue;
} CustomVariantValue::CustomVariantValue(int32_t nValue)
{
m_vt = (uint16_t)VariantType::vt_i4;
m_i4Val = nValue;
} CustomVariantValue::CustomVariantValue(uint32_t uValue)
{
m_vt = (uint16_t)VariantType::vt_ui4;
m_ui4Val = uValue;
} CustomVariantValue::CustomVariantValue(int64_t nValue)
{
m_vt = (uint16_t)VariantType::vt_i8;
m_i8Val = nValue;
} CustomVariantValue::CustomVariantValue(uint64_t uValue)
{
m_vt = (uint16_t)VariantType::vt_ui8;
m_ui8Val = uValue;
} CustomVariantValue::CustomVariantValue(float fValue)
{
m_vt = (uint16_t)VariantType::vt_r4;
m_r4Val = fValue;
} CustomVariantValue::CustomVariantValue(double dValue)
{
m_vt = (uint16_t)VariantType::vt_r8;
m_r8Val = dValue;
} CustomVariantValue::CustomVariantValue(const char *pChar)
{
m_vt = (uint16_t)VariantType::vt_bstr;
if (nullptr != pChar)
{
uint32_t uLen = strlen(pChar); m_strVal = new char[uLen + ];
memcpy(m_strVal, pChar, uLen);
m_strVal[uLen] = '\0';
}
else
{
m_strVal = nullptr;
}
} CustomVariantValue::CustomVariantValue(const std::string &strChar)
{
uint32_t uLen = static_cast<uint32_t>(strChar.length()); m_vt = (uint16_t)VariantType::vt_bstr;
if ( != uLen)
{
m_strVal = new char[uLen + ];
memcpy(m_strVal, strChar.c_str(), uLen);
m_strVal[uLen] = '\0';
}
else
{
m_strVal = nullptr;
}
} CustomVariantValue::CustomVariantValue(const std::vector<bool> &valueVector)
{
m_vt = (uint16_t)VariantType::vt_bool | (uint16_t)VariantType::vt_set;
auto pSetVal = new std::set<bool>();
for (auto value : valueVector)
pSetVal->insert(value);
m_pSetVal = pSetVal;
} CustomVariantValue::CustomVariantValue(const std::vector<int32_t> &valueVector)
{
m_vt = (uint16_t)VariantType::vt_i4 | (uint16_t)VariantType::vt_set;
auto pSetVal = new std::set<int32_t>();
for (auto value : valueVector)
pSetVal->insert(value);
m_pSetVal = pSetVal;
} CustomVariantValue::CustomVariantValue(const std::vector<uint32_t> &valueVector)
{
m_vt = (uint16_t)VariantType::vt_ui4 | (uint16_t)VariantType::vt_set;
auto pSetVal = new std::set<uint32_t>();
for (auto value : valueVector)
pSetVal->insert(value);
m_pSetVal = pSetVal;
} CustomVariantValue::CustomVariantValue(const std::vector<int64_t> &valueVector)
{
m_vt = (uint16_t)VariantType::vt_i8 | (uint16_t)VariantType::vt_set;
auto pSetVal = new std::set<int64_t>();
for (auto value : valueVector)
pSetVal->insert(value);
m_pSetVal = pSetVal;
} CustomVariantValue::CustomVariantValue(const std::vector<uint64_t> &valueVector)
{
m_vt = (uint16_t)VariantType::vt_ui8 | (uint16_t)VariantType::vt_set;
auto pSetVal = new std::set<uint64_t>();
for (auto value : valueVector)
pSetVal->insert(value);
m_pSetVal = pSetVal;
} CustomVariantValue::CustomVariantValue(const std::vector<float> &valueVector)
{
m_vt = (uint16_t)VariantType::vt_r4 | (uint16_t)VariantType::vt_set;
auto pSetVal = new std::set<float>();
for (auto value : valueVector)
pSetVal->insert(value);
m_pSetVal = pSetVal;
} CustomVariantValue::CustomVariantValue(const std::vector<double> &valueVector)
{
m_vt = (uint16_t)VariantType::vt_r8 | (uint16_t)VariantType::vt_set;
auto pSetVal = new std::set<double>();
for (auto value : valueVector)
pSetVal->insert(value);
m_pSetVal = pSetVal;
} CustomVariantValue::CustomVariantValue(const std::vector<std::string> &valueVector)
{
m_vt = (uint16_t)VariantType::vt_bstr | (uint16_t)VariantType::vt_set;
auto pSetVal = new std::set<std::string>();
for (auto value : valueVector)
pSetVal->insert(value);
m_pSetVal = pSetVal;
} CustomVariantValue::CustomVariantValue(const std::set<bool> &valueSet)
{
m_vt = (uint16_t)VariantType::vt_bool | (uint16_t)VariantType::vt_set;
m_pSetVal = new std::set<bool>(valueSet);
} CustomVariantValue::CustomVariantValue(const std::set<int32_t> &valueSet)
{
m_vt = (uint16_t)VariantType::vt_i4 | (uint16_t)VariantType::vt_set;
m_pSetVal = new std::set<int32_t>(valueSet);
} CustomVariantValue::CustomVariantValue(const std::set<uint32_t> &valueSet)
{
m_vt = (uint16_t)VariantType::vt_ui4 | (uint16_t)VariantType::vt_set;
m_pSetVal = new std::set<uint32_t>(valueSet);
} CustomVariantValue::CustomVariantValue(const std::set<int64_t> &valueSet)
{
m_vt = (uint16_t)VariantType::vt_i8 | (uint16_t)VariantType::vt_set;
m_pSetVal = new std::set<int64_t>(valueSet);
} CustomVariantValue::CustomVariantValue(const std::set<uint64_t> &valueSet)
{
m_vt = (uint16_t)VariantType::vt_ui8 | (uint16_t)VariantType::vt_set;
m_pSetVal = new std::set<uint64_t>(valueSet);
} CustomVariantValue::CustomVariantValue(const std::set<float> &valueSet)
{
m_vt = (uint16_t)VariantType::vt_r4 | (uint16_t)VariantType::vt_set;
m_pSetVal = new std::set<float>(valueSet);
} CustomVariantValue::CustomVariantValue(const std::set<double> &valueSet)
{
m_vt = (uint16_t)VariantType::vt_r8 | (uint16_t)VariantType::vt_set;
m_pSetVal = new std::set<double>(valueSet);
} CustomVariantValue::CustomVariantValue(const std::set<std::string> &valueSet)
{
m_vt = (uint16_t)VariantType::vt_bstr | (uint16_t)VariantType::vt_set;
m_pSetVal = new std::set<std::string>(valueSet);
} CustomVariantValue::CustomVariantValue(const VariantValue &value)
{
VariantValueInit(*this);
VariantValueCopy(*this, value);
} CustomVariantValue::CustomVariantValue(const CustomVariantValue &other)
{
VariantValueInit(*this);
VariantValueCopy(*this, other);
} CustomVariantValue& CustomVariantValue::operator = (bool bValue)
{
VariantValueClear(*this);
m_vt = (uint16_t)VariantType::vt_bool;
m_bVal = bValue;
return *this;
} CustomVariantValue& CustomVariantValue::operator = (int32_t nValue)
{
VariantValueClear(*this);
m_vt = (uint16_t)VariantType::vt_i4;
m_i4Val = nValue;
return *this;
} CustomVariantValue& CustomVariantValue::operator = (uint32_t uValue)
{
VariantValueClear(*this);
m_vt = (uint16_t)VariantType::vt_ui4;
m_ui4Val = uValue;
return *this;
} CustomVariantValue& CustomVariantValue::operator = (int64_t nValue)
{
VariantValueClear(*this);
m_vt = (uint16_t)VariantType::vt_i8;
m_i8Val = nValue;
return *this;
} CustomVariantValue& CustomVariantValue::operator = (uint64_t uValue)
{
VariantValueClear(*this);
m_vt = (uint16_t)VariantType::vt_ui8;
m_ui8Val = uValue;
return *this;
} CustomVariantValue& CustomVariantValue::operator = (float fValue)
{
VariantValueClear(*this);
m_vt = (uint16_t)VariantType::vt_r4;
m_r4Val = fValue;
return *this;
} CustomVariantValue& CustomVariantValue::operator = (double dValue)
{
VariantValueClear(*this);
m_vt = (uint16_t)VariantType::vt_r8;
m_r8Val = dValue;
return *this;
} CustomVariantValue& CustomVariantValue::operator = (const char *pChar)
{
VariantValueClear(*this);
m_vt = (uint16_t)VariantType::vt_bstr;
if (nullptr != pChar)
{
uint32_t uLen = strlen(pChar); m_strVal = new char[uLen + ];
memcpy(m_strVal, pChar, uLen);
m_strVal[uLen] = '\0';
}
else
{
m_strVal = nullptr;
} return *this;
} CustomVariantValue& CustomVariantValue::operator = (const std::string &strChar)
{
VariantValueClear(*this); uint32_t uLen = static_cast<uint32_t>(strChar.length()); m_vt = (uint16_t)VariantType::vt_bstr;
if ( != uLen)
{
m_strVal = new char[uLen + ];
memcpy(m_strVal, strChar.c_str(), uLen);
m_strVal[uLen] = '\0';
}
else
{
m_strVal = nullptr;
} return *this;
} CustomVariantValue& CustomVariantValue::operator = (const std::vector<bool> &valueVector)
{
VariantValueClear(*this);
m_vt = (uint16_t)VariantType::vt_bool | (uint16_t)VariantType::vt_set;
auto pSetVal = new std::set<bool>();
for (auto value : valueVector)
pSetVal->insert(value);
m_pSetVal = pSetVal; return *this;
} CustomVariantValue& CustomVariantValue::operator = (const std::vector<int32_t> &valueVector)
{
VariantValueClear(*this);
m_vt = (uint16_t)VariantType::vt_i4 | (uint16_t)VariantType::vt_set;
auto pSetVal = new std::set<int32_t>();
for (auto value : valueVector)
pSetVal->insert(value);
m_pSetVal = pSetVal; return *this;
} CustomVariantValue& CustomVariantValue::operator = (const std::vector<uint32_t> &valueVector)
{
VariantValueClear(*this);
m_vt = (uint16_t)VariantType::vt_ui4 | (uint16_t)VariantType::vt_set;
auto pSetVal = new std::set<uint32_t>();
for (auto value : valueVector)
pSetVal->insert(value);
m_pSetVal = pSetVal; return *this;
} CustomVariantValue& CustomVariantValue::operator = (const std::vector<int64_t> &valueVector)
{
VariantValueClear(*this);
m_vt = (uint16_t)VariantType::vt_i8 | (uint16_t)VariantType::vt_set;
auto pSetVal = new std::set<int64_t>();
for (auto value : valueVector)
pSetVal->insert(value);
m_pSetVal = pSetVal; return *this;
} CustomVariantValue& CustomVariantValue::operator = (const std::vector<uint64_t> &valueVector)
{
VariantValueClear(*this);
m_vt = (uint16_t)VariantType::vt_ui8 | (uint16_t)VariantType::vt_set;
auto pSetVal = new std::set<uint64_t>();
for (auto value : valueVector)
pSetVal->insert(value);
m_pSetVal = pSetVal; return *this;
} CustomVariantValue& CustomVariantValue::operator = (const std::vector<float> &valueVector)
{
VariantValueClear(*this);
m_vt = (uint16_t)VariantType::vt_r4 | (uint16_t)VariantType::vt_set;
auto pSetVal = new std::set<float>();
for (auto value : valueVector)
pSetVal->insert(value);
m_pSetVal = pSetVal; return *this;
} CustomVariantValue& CustomVariantValue::operator = (const std::vector<double> &valueVector)
{
VariantValueClear(*this);
m_vt = (uint16_t)VariantType::vt_r8 | (uint16_t)VariantType::vt_set;
auto pSetVal = new std::set<double>();
for (auto value : valueVector)
pSetVal->insert(value);
m_pSetVal = pSetVal; return *this;
} CustomVariantValue& CustomVariantValue::operator = (const std::vector<std::string> &valueVector)
{
VariantValueClear(*this);
m_vt = (uint16_t)VariantType::vt_bstr | (uint16_t)VariantType::vt_set;
auto pSetVal = new std::set<std::string>();
for (auto value : valueVector)
pSetVal->insert(value);
m_pSetVal = pSetVal; return *this;
} CustomVariantValue& CustomVariantValue::operator = (const std::set<bool> &valueSet)
{
VariantValueClear(*this);
m_vt = (uint16_t)VariantType::vt_bool | (uint16_t)VariantType::vt_set;
m_pSetVal = new std::set<bool>(valueSet);
return *this;
} CustomVariantValue& CustomVariantValue::operator = (const std::set<int32_t> &valueSet)
{
VariantValueClear(*this);
m_vt = (uint16_t)VariantType::vt_i4 | (uint16_t)VariantType::vt_set;
m_pSetVal = new std::set<int32_t>(valueSet);
return *this;
} CustomVariantValue& CustomVariantValue::operator = (const std::set<uint32_t> &valueSet)
{
VariantValueClear(*this);
m_vt = (uint16_t)VariantType::vt_ui4 | (uint16_t)VariantType::vt_set;
m_pSetVal = new std::set<uint32_t>(valueSet);
return *this;
} CustomVariantValue& CustomVariantValue::operator = (const std::set<int64_t> &valueSet)
{
VariantValueClear(*this);
m_vt = (uint16_t)VariantType::vt_i8 | (uint16_t)VariantType::vt_set;
m_pSetVal = new std::set<int64_t>(valueSet);
return *this;
} CustomVariantValue& CustomVariantValue::operator = (const std::set<uint64_t> &valueSet)
{
VariantValueClear(*this);
m_vt = (uint16_t)VariantType::vt_ui8 | (uint16_t)VariantType::vt_set;
m_pSetVal = new std::set<uint64_t>(valueSet);
return *this;
} CustomVariantValue& CustomVariantValue::operator = (const std::set<float> &valueSet)
{
VariantValueClear(*this);
m_vt = (uint16_t)VariantType::vt_r4 | (uint16_t)VariantType::vt_set;
m_pSetVal = new std::set<float>(valueSet);
return *this;
} CustomVariantValue& CustomVariantValue::operator = (const std::set<double> &valueSet)
{
VariantValueClear(*this);
m_vt = (uint16_t)VariantType::vt_r8 | (uint16_t)VariantType::vt_set;
m_pSetVal = new std::set<double>(valueSet);
return *this;
} CustomVariantValue& CustomVariantValue::operator = (const std::set<std::string> &valueSet)
{
VariantValueClear(*this);
m_vt = (uint16_t)VariantType::vt_bstr | (uint16_t)VariantType::vt_set;
m_pSetVal = new std::set<std::string>(valueSet);
return *this;
} CustomVariantValue& CustomVariantValue::operator = (const VariantValue &value)
{
if (this != &value)
{
VariantValueClear(*this);
VariantValueCopy(*this, value);
} return *this;
} CustomVariantValue& CustomVariantValue::operator = (const CustomVariantValue &other)
{
if (this != &other)
{
VariantValueClear(*this);
VariantValueCopy(*this, other);
} return *this;
} bool CustomVariantValue::operator==(const VariantValue& value)
{
return Compare(value);
} bool CustomVariantValue::operator==(const CustomVariantValue& value)
{
return Compare(value);
} bool CustomVariantValue::operator!=(const VariantValue& value)
{
return !Compare(value);
} bool CustomVariantValue::operator!=(const CustomVariantValue& value)
{
return !Compare(value);
} std::vector<bool> CustomVariantValue::ToBoolArray() const
{
std::vector<bool> arrayValue;
std::set<bool> *pSetVal = static_cast<std::set<bool> *>(m_pSetVal); if (pSetVal)
{
uint32_t i = ; assert(m_vt == (((uint16_t)VariantType::vt_bool) | (uint16_t)VariantType::vt_set));
arrayValue.resize(pSetVal->size());
for (auto subValue : *pSetVal)
arrayValue[i++] = subValue;
}
else
{
assert(m_vt == (uint16_t)VariantType::vt_empty);
} return arrayValue;
} std::vector<int32_t> CustomVariantValue::ToInt32Array() const
{
std::vector<int32_t> arrayValue;
std::set<int32_t> *pSetVal = static_cast<std::set<int32_t> *>(m_pSetVal); if (pSetVal)
{
uint32_t i = ; assert(m_vt == (((uint16_t)VariantType::vt_i4) | (uint16_t)VariantType::vt_set));
arrayValue.resize(pSetVal->size());
for (auto subValue : *pSetVal)
arrayValue[i++] = subValue;
}
else
{
assert(m_vt == (uint16_t)VariantType::vt_empty);
} return arrayValue;
} std::vector<uint32_t> CustomVariantValue::ToUint32Array() const
{
std::vector<uint32_t> arrayValue;
std::set<uint32_t> *pSetVal = static_cast<std::set<uint32_t> *>(m_pSetVal); if (pSetVal)
{
uint32_t i = ; assert(m_vt == (((uint16_t)VariantType::vt_ui4) | (uint16_t)VariantType::vt_set));
arrayValue.resize(pSetVal->size());
for (auto subValue : *pSetVal)
arrayValue[i++] = subValue;
}
else
{
assert(m_vt == (uint16_t)VariantType::vt_empty);
} return arrayValue;
} std::vector<int64_t> CustomVariantValue::ToInt64Array() const
{
std::vector<int64_t> arrayValue;
std::set<int64_t> *pSetVal = static_cast<std::set<int64_t> *>(m_pSetVal); if (pSetVal)
{
uint32_t i = ; assert(m_vt == (((uint16_t)VariantType::vt_i8) | (uint16_t)VariantType::vt_set));
arrayValue.resize(pSetVal->size());
for (auto subValue : *pSetVal)
arrayValue[i++] = subValue;
}
else
{
assert(m_vt == (uint16_t)VariantType::vt_empty);
} return arrayValue;
} std::vector<uint64_t> CustomVariantValue::ToUint64Array() const
{
std::vector<uint64_t> arrayValue;
std::set<uint64_t> *pSetVal = static_cast<std::set<uint64_t> *>(m_pSetVal); if (pSetVal)
{
uint32_t i = ; assert(m_vt == (((uint16_t)VariantType::vt_ui8) | (uint16_t)VariantType::vt_set));
arrayValue.resize(pSetVal->size());
for (auto subValue : *pSetVal)
arrayValue[i++] = subValue;
}
else
{
assert(m_vt == (uint16_t)VariantType::vt_empty);
} return arrayValue;
} std::vector<float> CustomVariantValue::ToFloatArray() const
{
std::vector<float> arrayValue;
std::set<float> *pSetVal = static_cast<std::set<float> *>(m_pSetVal); if (pSetVal)
{
uint32_t i = ; assert(m_vt == (((uint16_t)VariantType::vt_r4) | (uint16_t)VariantType::vt_set));
arrayValue.resize(pSetVal->size());
for (auto subValue : *pSetVal)
arrayValue[i++] = subValue;
}
else
{
assert(m_vt == (uint16_t)VariantType::vt_empty);
} return arrayValue;
} std::vector<double> CustomVariantValue::ToDoubleArray() const
{
std::vector<double> arrayValue;
std::set<double> *pSetVal = static_cast<std::set<double> *>(m_pSetVal); if (pSetVal)
{
uint32_t i = ; assert(m_vt == (((uint16_t)VariantType::vt_r8) | (uint16_t)VariantType::vt_set));
arrayValue.resize(pSetVal->size());
for (auto subValue : *pSetVal)
arrayValue[i++] = subValue;
}
else
{
assert(m_vt == (uint16_t)VariantType::vt_empty);
} return arrayValue;
} std::vector<std::string> CustomVariantValue::ToStringArray() const
{
std::vector<std::string> arrayValue;
std::set<std::string> *pSetVal = static_cast<std::set<std::string> *>(m_pSetVal); if (pSetVal)
{
uint32_t i = ; assert(m_vt == (((uint16_t)VariantType::vt_bstr) | (uint16_t)VariantType::vt_set));
arrayValue.resize(pSetVal->size());
for (auto subValue : *pSetVal)
arrayValue[i++] = subValue;
}
else
{
assert(m_vt == (uint16_t)VariantType::vt_empty);
} return arrayValue;
} std::set<bool>& CustomVariantValue::ToBoolSet()
{
if (nullptr == m_pSetVal)
{
assert(m_vt == (uint16_t)VariantType::vt_empty);
m_vt = (((uint16_t)VariantType::vt_bool) | (uint16_t)VariantType::vt_set);
m_pSetVal = new std::set<bool>();
}
else
{
assert(m_vt == (((uint16_t)VariantType::vt_bool) | (uint16_t)VariantType::vt_set));
} return *static_cast<std::set<bool> *>(m_pSetVal);
} std::set<int32_t>& CustomVariantValue::ToInt32Set()
{
if (nullptr == m_pSetVal)
{
assert(m_vt == (uint16_t)VariantType::vt_empty);
m_vt = (((uint16_t)VariantType::vt_i4) | (uint16_t)VariantType::vt_set);
m_pSetVal = new std::set<int32_t>();
}
else
{
assert(m_vt == (((uint16_t)VariantType::vt_i4) | (uint16_t)VariantType::vt_set));
} return *static_cast<std::set<int32_t> *>(m_pSetVal);
} std::set<uint32_t>& CustomVariantValue::ToUint32Set()
{
if (nullptr == m_pSetVal)
{
assert(m_vt == (uint16_t)VariantType::vt_empty);
m_vt = (((uint16_t)VariantType::vt_ui4) | (uint16_t)VariantType::vt_set);
m_pSetVal = new std::set<uint32_t>();
}
else
{
assert((m_vt == (((uint16_t)VariantType::vt_ui4) | (uint16_t)VariantType::vt_set)));
} return *static_cast<std::set<uint32_t> *>(m_pSetVal);
} std::set<int64_t>& CustomVariantValue::ToInt64Set()
{
if (nullptr == m_pSetVal)
{
assert(m_vt == (uint16_t)VariantType::vt_empty);
m_vt = (((uint16_t)VariantType::vt_i8) | (uint16_t)VariantType::vt_set);
m_pSetVal = new std::set<int64_t>();
}
else
{
assert(m_vt == (((uint16_t)VariantType::vt_i8) | (uint16_t)VariantType::vt_set));
} return *static_cast<std::set<int64_t> *>(m_pSetVal);
} std::set<uint64_t>& CustomVariantValue::ToUint64Set()
{
if (nullptr == m_pSetVal)
{
assert(m_vt == (uint16_t)VariantType::vt_empty);
m_vt = (((uint16_t)VariantType::vt_ui8) | (uint16_t)VariantType::vt_set);
m_pSetVal = new std::set<uint64_t>();
}
else
{
assert(m_vt == (((uint16_t)VariantType::vt_ui8) | (uint16_t)VariantType::vt_set));
}
return *static_cast<std::set<uint64_t> *>(m_pSetVal);
} std::set<float>& CustomVariantValue::ToFloatSet()
{
if (nullptr == m_pSetVal)
{
assert(m_vt == (uint16_t)VariantType::vt_empty);
m_vt = (((uint16_t)VariantType::vt_r4) | (uint16_t)VariantType::vt_set);
m_pSetVal = new std::set<float>();
}
else
{
assert(m_vt == (((uint16_t)VariantType::vt_r4) | (uint16_t)VariantType::vt_set));
} return *static_cast<std::set<float> *>(m_pSetVal);
} std::set<double>& CustomVariantValue::ToDoubleSet()
{
if (nullptr == m_pSetVal)
{
assert(m_vt == (uint16_t)VariantType::vt_empty);
m_vt = (((uint16_t)VariantType::vt_r8) | (uint16_t)VariantType::vt_set);
m_pSetVal = new std::set<double>();
}
else
{
assert(m_vt == (((uint16_t)VariantType::vt_r8) | (uint16_t)VariantType::vt_set));
} return *static_cast<std::set<double> *>(m_pSetVal);
} std::set<std::string>& CustomVariantValue::ToStringSet()
{
if (nullptr == m_pSetVal)
{
assert(m_vt == (uint16_t)VariantType::vt_empty);
m_vt = (((uint16_t)VariantType::vt_bstr) | (uint16_t)VariantType::vt_set);
m_pSetVal = new std::set<std::string>();
}
else
{
assert(m_vt == (((uint16_t)VariantType::vt_bstr) | (uint16_t)VariantType::vt_set));
}
return *static_cast<std::set<std::string> *>(m_pSetVal);
} bool CustomVariantValue::Compare(const VariantValue& value)
{
if (m_vt != value.m_vt)
return false; if (m_vt & (uint16_t)VariantType::vt_set)
{
uint16_t uType = (uint16_t)value.m_vt & 0xff;
bool bResult = false; switch ((VariantType)uType)
{
case VariantType::vt_bool:
bResult = VariantSetValueComplie(reinterpret_cast<std::set<bool> *>(m_pSetVal), reinterpret_cast<std::set<bool> *>(value.m_pSetVal));
break;
case VariantType::vt_i4:
bResult = VariantSetValueComplie(reinterpret_cast<std::set<int32_t> *>(m_pSetVal), reinterpret_cast<std::set<int32_t> *>(value.m_pSetVal));
break;
case VariantType::vt_ui4:
bResult = VariantSetValueComplie(reinterpret_cast<std::set<uint32_t> *>(m_pSetVal), reinterpret_cast<std::set<uint32_t> *>(value.m_pSetVal));
break;
case VariantType::vt_i8:
bResult = VariantSetValueComplie(reinterpret_cast<std::set<int64_t> *>(m_pSetVal), reinterpret_cast<std::set<int64_t> *>(value.m_pSetVal));
break;
case VariantType::vt_ui8:
bResult = VariantSetValueComplie(reinterpret_cast<std::set<uint64_t> *>(m_pSetVal), reinterpret_cast<std::set<uint64_t> *>(value.m_pSetVal));
break;
case VariantType::vt_r4:
bResult = VariantSetValueComplie(reinterpret_cast<std::set<float> *>(m_pSetVal), reinterpret_cast<std::set<float> *>(value.m_pSetVal));
break;
case VariantType::vt_r8:
bResult = VariantSetValueComplie(reinterpret_cast<std::set<double> *>(m_pSetVal), reinterpret_cast<std::set<double> *>(value.m_pSetVal));
break;
case VariantType::vt_bstr:
bResult = VariantSetValueComplie(reinterpret_cast<std::set<std::string> *>(m_pSetVal), reinterpret_cast<std::set<std::string> *>(value.m_pSetVal));
break;
default:
assert(false);
break;
} return bResult;
}
else
{
if (m_vt != (uint16_t)VariantType::vt_bstr)
{
return == memcmp(this, &value, sizeof(value));
}
else
{
if ((nullptr == m_strVal) && (nullptr == value.m_strVal))
return true; if ((nullptr == m_strVal) || (nullptr == value.m_strVal))
return false; return == strcmp(m_strVal, value.m_strVal);
}
}
}
使用
main.cpp
#include <iostream>
#include <CustomVariantValue.h> using namespace std; int main(int argc, char *argv[])
{ CustomVariantValue vInt = ;
CustomVariantValue vBool = true; int rvInt = vInt;
cout<<rvInt<<endl; if(vInt == vBool)
cout<<"vInt == vBool"<<endl;
else
cout<<"vInt!=vBool"<<endl;
return ;
}
——
使用C++定义一个万能类型的更多相关文章
- 黑马基础阶段测试题：定义一个int类型的数组，数组中元素为｛5，7，3，9，4｝。求出数组中的最小值，并判断最小值是否为偶数，如果是偶数则输出“最小值为偶数”，如果不是偶数则输出“最小值为奇数”。打印如下：
package com.swift; import java.util.Arrays; public class ArrayTest { public static void main(String[ ...
- 编写Java程序，方法练习题__构建英雄类，定义一个int类型的变量output，表示英雄的血量
返回本章节 返回作业目录 需求说明: 定义一个int类型的变量output,表示英雄的血量,当battle()方法执行一次,output变量值减少10.在控制台随机输入一个小于100的整数,将该整数值 ...
- C++ 定义一个指针类型
#include <iostream>using namespace std; int main(){ int a= 10; //定义变量a int * p ; //定义个指针P p = ...
- java怎么定义一个二维数组？
java中使用 [][] 来定义二维数组 定义数组时也可同时初始化下面是一些例子float[][] numthree; //定义一个float类型的2维数组numthree=new float[5][ ...
- CREATE AGGREGATE - 定义一个新的聚集函数
SYNOPSIS CREATE AGGREGATE name ( BASETYPE = input_data_type, SFUNC = sfunc, STYPE = state_data_type ...
- Entity Framework 6 Recipes 2nd Edition（11-5）译 -> 从”模型定义”函数返回一个匿名类型
11-5. 从”模型定义”函数返回一个匿名类型 问题 想创建一个返回一个匿名类型的”模型定义”函数 解决方案 假设已有游客(Visitor) 预订(reservation)房间(hotel ) 的模型 ...
- Entity Framework 6 Recipes 2nd Edition（11-6）译 -> 从一个”模型定义”函数里返回一个复杂类型
11-6.从一个”模型定义”函数里返回一个复杂类型 问题 想要从一个”模型定义”函数返回一个复杂类型 解决方案 假设我们有一个病人(patient)和他们访客(visit)的模型,如 Figure 1 ...
- #定义一个方法get_num(num),num参数是列表类型，判断列表里面的元素为数字类型。其他类型则报错，并且返回一个偶数列表：（注：列表里面的元素为偶数）。
#定义一个方法get_num(num),num参数是列表类型,判断列表里面的元素为数字类型.其他类型则报错,并且返回一个偶数列表:(注:列表里面的元素为偶数). def get_num(num): i ...
- 信1705-2 软工作业最大重复词查询思路： （1）将文章（一个字符串存储）按空格进行拆分（split）后，存储到一个字符串（单词）数组中。 （2）定义一个Map，key是字符串类型，保存单词；value是数字类型，保存该单词出现的次数。 （3）遍历（1）中得到的字符串数组，对于每一个单词，考察Map的key中是否出现过该单词，如果没出现过，map中增加一个元素，key为该单词，value为1（
通过学习学会了文本的访问,了解一点哈希表用途.经过网上查找做成了下面查询文章重复词的JAVA程序. 1 思 思路: (1)将文章(一个字符串存储)按空格进行拆分(split)后,存储到一个字符串(单词 ...
随机推荐
- element-ui 时间设置 获取固定的时间格式
<el-date-picker v-model="time1" type="daterange" start-placeholder="开始日期 ...
- ubuntu svn 安装
deepin@deepin:~$ sudo apt-get install rabbitvcs-rabbitvcs-cli rabbitvcs-core rabbitvcs-gedit rabbitv ...
- 威联通212 http 在密码正确的情况下无法登录问题解决
*现象: 1.putty 可以正常登录 2.smb可以正常登录 3.http 提示密码错误或无效 *解决办法: 1.通过putty ssh登录到设备 2.执行以下代码 [~] # cp /etc/ ...
- （二）Spring框架之JDBC的基本使用（p6spy插件的使用）
案例一: 用Spring IOC方式使用JDBC Test_2.java package jdbc; import java.lang.Thread.State; import java.sql.Co ...
- 改善C#程序的方法
写在开头: http://www.cnblogs.com/luminji 157个建议_勘误表 一:属性 属性和方法一样.也可以是virtual和abstract. 条款2:运行时常量(read ...
- Django rest-framework框架-组件之视图
视图: a. django class Test(View): ... b. rest_framework class Test(APIView): ... c. GenericAPIView 一般不 ...
- JavaScript--常用对象的属性及方法（2）
Array对象(数组) 数组最常用属性:length 获取数组的元素个数 方法: toString() 将数组转换为字符串 var arr = ["武汉市","成都市&q ...
- stm32 红外
相关文章:http://blog.csdn.net/zhangxuechao_/article/details/75039906 举例 u8 ir_tick() //记录高电平时间 { u8 i = ...
- EditText编辑框
<?xml version="1.0" encoding="utf-8"?> <LinearLayout xmlns:android=&quo ...
- window下redis的安装和使用
1.下载及安装redis 下载地址:https://github.com/dmajkic/redis/downloads 找到对应的版本下载安装 打开cmd窗口,用cd命令进入到安装redis的根目录 ...