- 01
- 02
- 03
- 04
- 05
- 06
- 07
- 08
- 09
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
typedef union Variant
{
public:
Variant() {}
Variant(signed int val) :
v_int(val)
{}
operator signed int &() { return const_cast<signed int&>(this->operator const signed int &()); }
operator const signed int&() const { return v_int; }
Variant(unsigned int val) :
v_uint(val)
{}
operator unsigned int &() { return const_cast<unsigned int&>(this->operator const unsigned int &()); }
operator const unsigned int &() const { return v_uint; }
Variant(char val) :
v_char(val)
{}
operator char &() { return const_cast<char&>(this->operator const char &()); }
operator const char&() const { return v_char; }
Variant(double val) :
v_float(val)
{}
operator double &() { return const_cast<double&>(this->operator const double &()); }
operator const double &() const { return v_float; }
Variant(void *val) :
v_ptr(val)
{}
operator void*& () { return const_cast<void*&>(this->operator void *&()); }
operator const void* const& () const { return v_ptr; }
static size_t getValueSize(const Type::OfType &type)
{
size_t result = 0;
switch ( type )
{
case Type::Pointer:
case Type::CharPtr:
case Type::IntPtr:
case Type::UIntPtr:
case Type::RealPtr:
case Type::String:
result = sizeof(v_ptr);
break;
case Type::Char:
result = sizeof(v_char);
break;
case Type::Int:
result = sizeof(v_int);
break;
case Type::UInt:
result = sizeof(v_uint);
break;
case Type::Real:
result = sizeof(v_float);
break;
case Type::Void:
result = 0;
break;
}
return result;
}
private:
void* v_ptr;
char v_char;
unsigned int v_uint;
signed int v_int;
double v_float;
} Variant;
Follow us!
самому стыдно, да? )
но оно же работает?
в настоящем варианте их на один только char должно быть 3:
1)char
2)signed char
3)unsigned char
неа. тогда придёться кастить через указатель. это не тако уж плохое решение
вообще, ума не приложу, где этот паттерн может понадобится?
я реализовывал подобный паттерн, когда делал свой интерпретатор слабо-типизированного языка... для совместимости виртуального типа со стандартными цпп-шными типами... во всяких интерфейсах к объектам может еще пригодиться... да много где, если так подумать)
Кстати, как такой вариант будет работать для классов? Их же из-за автодеструкторов нельзя в юнионы писать.