让C++的对象支持多类型

 借助 C/C++ 的union，可以设计出近似弱类型的变量，同一类型的变量可以承载不同类型的数据。比如说一个对象A，可以按如下不同的类型使用：

A a = 1;

A b = 1.1;

A c = "abc";

A d = true;

使用的时候可以按照其真实的类型来使用。比如字符串c以调用c.size()获得其长度。

这个想法来源于两个开源库的基础数据类型设计，一个是xmlrpclib库中XmlRpcValue设计，一个是xpdf中Object设计。非常

的巧妙。核心在于定义一个union承载实际的数据，定义一个enum来标识数据实际的类型。
XmlRpcValue的数据承载部分设计为：

1.     union {
2.       bool          asBool;
3.       int           asInt;
4.       double        asDouble;
5.       struct tm*    asTime;
6.       std::string*  asString;
7.       BinaryData*   asBinary;
8.       ValueArray*   asArray;
9.       ValueStruct*  asStruct;
10.     } _value;

支持的类型如下定义：

1. enum Type {
2.       TypeInvalid,
3.       TypeBoolean,
4.       TypeInt,
5.       TypeDouble,
6.       TypeString,
7.       TypeDateTime,
8.       TypeBase64,
9.       TypeArray,
10.       TypeStruct
11.     };

在使用此类对象的时候，先设置该对象的类型，然后再根据实际的类型进行运算。其实质仍然是严格类型的。但是从使用者

的角度看来，却是弱类型的。
此类对象的使用会对效率和空间有一定的影响。但影响都不大。
时间方面的影响主要在于很多时候需要进行类型判定，若类型不匹配，则无法完成运算。值得注意的是，很多类型匹配可以

在编译期间完成。比如，XmpRpcValue a = 1; XmlRpcValue b = true;
空间方面主要是union分配空间是以最大的成员进行分配，但是如果大量使用指针，空间的多余耗费则不会很大。

 

xmlrpclib库中XmlRpcValue核心代码如下（已删除部分不相关代码）

1.   class XmlRpcValue {
2.   public:
3.     enum Type {
4.       TypeInvalid,
5.       TypeBoolean,
6.       TypeInt,
7.       TypeDouble,
8.       TypeString,
9.       TypeDateTime,
10.       TypeBase64,
11.       TypeArray,
12.       TypeStruct
13.     };
15.     // Non-primitive types
16.     typedef std::vector<char> BinaryData;
17.     typedef std::vector ValueArray;
18.     typedef std::map ValueStruct;
21.     //! Constructors
22.     XmlRpcValue() : _type(TypeInvalid) { _value.asBinary = 0; }
23.     XmlRpcValue(bool value) : _type(TypeBoolean) { _value.asBool = value; }
24.     XmlRpcValue(int value)  : _type(TypeInt) { _value.asInt = value; }
25.     XmlRpcValue(double value)  : _type(TypeDouble) { _value.asDouble = value; }
27.     XmlRpcValue(std::string const& value) : _type(TypeString) 
28.     { _value.asString = new std::string(value); }
30.     XmlRpcValue(const char* value)  : _type(TypeString)
31.     { _value.asString = new std::string(value); }
33.     XmlRpcValue(struct tm* value)  : _type(TypeDateTime) 
34.     { _value.asTime = new struct tm(*value); }
37.     XmlRpcValue(void* value, int nBytes)  : _type(TypeBase64)
38.     {
39.       _value.asBinary = new BinaryData((char*)value, ((char*)value)+nBytes);
40.     }
42.     //! Construct from xml, beginning at *offset chars into the string, updates offset
43.     XmlRpcValue(std::string const& xml, int* offset) : _type(TypeInvalid)
44.     { if ( ! fromXml(xml,offset)) _type = TypeInvalid; }
46.     //! Copy
47.     XmlRpcValue(XmlRpcValue const& rhs) : _type(TypeInvalid) { *this = rhs; }
49.     //! Destructor (make virtual if you want to subclass)
50.     /*virtual*/ ~XmlRpcValue() { invalidate(); }
52.     //! Erase the current value
53.     void clear() { invalidate(); }
55.     // Operators
56.     XmlRpcValue& operator=(XmlRpcValue const& rhs);
57.     XmlRpcValue& operator=(int const& rhs) { return operator=(XmlRpcValue(rhs)); }
58.     XmlRpcValue& operator=(double const& rhs) { return operator=(XmlRpcValue(rhs)); }
59.     XmlRpcValue& operator=(const char* rhs) { return operator=(XmlRpcValue(std::string(rhs))); }
61.     bool operator==(XmlRpcValue const& other) const;
62.     bool operator!=(XmlRpcValue const& other) const;
64.     operator bool&()          { assertTypeOrInvalid(TypeBoolean); return _value.asBool; }
65.     operator int&()           { assertTypeOrInvalid(TypeInt); return _value.asInt; }
66.     operator double&()        { assertTypeOrInvalid(TypeDouble); return _value.asDouble; }
67.     operator std::string&()   { assertTypeOrInvalid(TypeString); return *_value.asString; }
68.     operator BinaryData&()    { assertTypeOrInvalid(TypeBase64); return *_value.asBinary; }
69.     operator struct tm&()     { assertTypeOrInvalid(TypeDateTime); return *_value.asTime; }
71.     XmlRpcValue const& operator[](int i) const { assertArray(i+1); return _value.asArray->at(i); }
72.     XmlRpcValue& operator[](int i)             { assertArray(i+1); return _value.asArray->at(i); }
74.     XmlRpcValue& operator[](std::string const& k) { assertStruct(); return (*_value.asStruct)[k]; }
75.     XmlRpcValue& operator[](const char* k) { assertStruct(); std::string s(k); return (*_value.asStruct)[s]; 
77. }
79.     // Accessors
80.     //! Return true if the value has been set to something.
81.     bool valid() const { return _type != TypeInvalid; }
83.     //! Return the type of the value stored. /see Type.
84.     Type const &getType() const { return _type; }
86.     //! Return the size for string, base64, array, and struct values.
87.     int size() const;
89.     //! Specify the size for array values. Array values will grow beyond this size if needed.
90.     void setSize(int size)    { assertArray(size); }
92.     //! Check for the existence of a struct member by name.
93.     bool hasMember(const std::string& name) const;
95.     // Type tag and values
96.     Type _type;
98.     // At some point I will split off Arrays and Structs into
99.     // separate ref-counted objects for more efficient copying.
100.     union {
101.       bool          asBool;
102.       int           asInt;
103.       double        asDouble;
104.       struct tm*    asTime;
105.       std::string*  asString;
106.       BinaryData*   asBinary;
107.       ValueArray*   asArray;
108.       ValueStruct*  asStruct;
109.     } _value;
110.     
111.   };

 

xpdf中Object的核心代码如下

 

1. enum ObjType {
2.   // simple objects
3.   objBool,          // boolean
4.   objInt,           // integer
5.   objReal,          // real
6.   objString,            // string
7.   objName,          // name
8.   objNull,          // null
10.   // complex objects
11.   objArray,         // array
12.   objDict,          // dictionary
13.   objStream,            // stream
14.   objRef,           // indirect reference
16.   // special objects
17.   objCmd,           // command name
18.   objError,         // error return from Lexer
19.   objEOF,           // end of file return from Lexer
20.   objNone           // uninitialized object
21. };
23. class Object {
24. public:
26.   // Default constructor.
27.   Object():
28.     type(objNone) {}
30.   // Initialize an object.
31.   Object *initBool(GBool boolnA)
32.     { initObj(objBool); booln = boolnA; return this; }
33.   Object *initInt(int intgA)
34.     { initObj(objInt); intg = intgA; return this; }
35.   Object *initReal(double realA)
36.     { initObj(objReal); real = realA; return this; }
37.   Object *initString(GString *stringA)
38.     { initObj(objString); string = stringA; return this; }
39.   Object *initName(char *nameA)
40.     { initObj(objName); name = copyString(nameA); return this; }
41.   Object *initNull()
42.     { initObj(objNull); return this; }
43.   Object *initArray(XRef *xref);
44.   Object *initDict(XRef *xref);
45.   Object *initDict(Dict *dictA);
46.   Object *initStream(Stream *streamA);
47.   Object *initRef(int numA, int genA)
48.     { initObj(objRef); ref.num = numA; ref.gen = genA; return this; }
49.   Object *initCmd(char *cmdA)
50.     { initObj(objCmd); cmd = copyString(cmdA); return this; }
51.   Object *initError()
52.     { initObj(objError); return this; }
53.   Object *initEOF()
54.     { initObj(objEOF); return this; }
56.   // Copy an object.
57.   Object *copy(Object *obj);
59.   // If object is a Ref, fetch and return the referenced object.
60.   // Otherwise, return a copy of the object.
61.   Object *fetch(XRef *xref, Object *obj);
63.   // Free object contents.
64.   void free();
66.   // Type checking.
67.   ObjType getType() { return type; }
68.   GBool isBool() { return type == objBool; }
69.   GBool isInt() { return type == objInt; }
70.   GBool isReal() { return type == objReal; }
71.   GBool isNum() { return type == objInt || type == objReal; }
72.   GBool isString() { return type == objString; }
73.   GBool isName() { return type == objName; }
74.   GBool isNull() { return type == objNull; }
75.   GBool isArray() { return type == objArray; }
76.   GBool isDict() { return type == objDict; }
77.   GBool isStream() { return type == objStream; }
78.   GBool isRef() { return type == objRef; }
79.   GBool isCmd() { return type == objCmd; }
80.   GBool isError() { return type == objError; }
81.   GBool isEOF() { return type == objEOF; }
82.   GBool isNone() { return type == objNone; }
84.   // Special type checking.
85.   GBool isName(char *nameA)
86.     { return type == objName && !strcmp(name, nameA); }
87.   GBool isDict(char *dictType);
88.   GBool isStream(char *dictType);
89.   GBool isCmd(char *cmdA)
90.     { return type == objCmd && !strcmp(cmd, cmdA); }
92.   // Accessors.  NB: these assume object is of correct type.
93.   GBool getBool() { return booln; }
94.   int getInt() { return intg; }
95.   double getReal() { return real; }
96.   double getNum() { return type == objInt ? (double)intg : real; }
97.   GString *getString() { return string; }
98.   char *getName() { return name; }
99.   Array *getArray() { return array; }
100.   Dict *getDict() { return dict; }
101.   Stream *getStream() { return stream; }
102.   Ref getRef() { return ref; }
103.   int getRefNum() { return ref.num; }
104.   int getRefGen() { return ref.gen; }
105.   char *getCmd() { return cmd; }
107.   // Array accessors.
108.   int arrayGetLength();
109.   void arrayAdd(Object *elem);
110.   Object *arrayGet(int i, Object *obj);
111.   Object *arrayGetNF(int i, Object *obj);
113.   // Dict accessors.
114.   int dictGetLength();
115.   void dictAdd(char *key, Object *val);
116.   GBool dictIs(char *dictType);
117.   Object *dictLookup(char *key, Object *obj);
118.   Object *dictLookupNF(char *key, Object *obj);
119.   char *dictGetKey(int i);
120.   Object *dictGetVal(int i, Object *obj);
121.   Object *dictGetValNF(int i, Object *obj);
123.   // Stream accessors.
124.   GBool streamIs(char *dictType);
125.   void streamReset();
126.   void streamClose();
127.   int streamGetChar();
128.   int streamLookChar();
129.   char *streamGetLine(char *buf, int size);
130.   Guint streamGetPos();
131.   void streamSetPos(Guint pos, int dir = 0);
132.   Dict *streamGetDict();
133. private:
135.   ObjType type;         // object type
136.   union {           // value for each type:
137.     GBool booln;        //   boolean
138.     int intg;           //   integer
139.     double real;        //   real
140.     GString *string;        //   string
141.     char *name;         //   name
142.     Array *array;       //   array
143.     Dict *dict;         //   dictionary
144.     Stream *stream;     //   stream
145.     Ref ref;            //   indirect reference
146.     char *cmd;          //   command
147.   };
148. };