devbox
不正经
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

编程实战：类C语法的编译型脚本解释器（二）Token和变量_c--语言token类型

作者：不正经 | 2024-05-29 05:21:50

赞

踩

c--语言token类型

初级代码游戏的专栏介绍与文章目录-CSDN博客

我的github：codetoys，所有代码都将会位于ctfc库中。已经放入库中我会指出在库中的位置。

这些代码大部分以Linux为目标但部分代码是纯C++的，可以在任何平台上使用。

系列入口：编程实战：类C语法的编译型脚本解释器（系列）-CSDN博客

        现在开始解释所有的设计思想和与源代码。先从外围入手，最后会进入到一个巨大的解析语法的类。

        本文介绍TOKEN和变量。

目录

一、TOKEN

1.1 定义Token类型

1.2 将脚本拆解为Token

1.3 TryGetKeyword识别关键字

1.4 TryGetNumber识别数值

1.5 其余TryGetXXXX略 

二、变量

一、TOKEN

1.1 定义Token类型

        token是编程语言的基本单元，是最小单位，包括分隔符、标识符、操作符、关键字、数字、字符串字面值，不包括空白。在C和类C语法中，空白字符包括换行都会被忽略（但预处理程序并非如此，所以预处理是额外的东西）。

        所有编译程序首先都会把源代码分解成一系列token，本代码也是如此。token的相关定义如下：

  1. 	enum { TOKEN_BUF_LEN = 128 };//仅用于预定义的关键字、运算符，其它标识符任意长度
  2. 	//语法标记，去除空白之后的每个元素
  3. 	struct Token
  4. 	{
  5. 		enum types { DELIMITER = 0, OPERATOR, IDENTIFIER, NUMBER, KEYWORD, STRING };
  6.  
  7. 		types type;//类型
  8. 		string text;//文本
  9. 		size_t pos;//在源代码中的位置
  10.  
  11. 		Token(types _type, char const* _text, size_t _pos) :type(_type), text(_text), pos(_pos) {}
  12.  
  13. 		string ToString()const
  14. 		{
  15. 			STATIC_C const char typestr[][TOKEN_BUF_LEN] = { "DELIMITER","OPERATOR","IDENTIFIER","NUMBER","KEYWORD","STRING" };//必须与types对应
  16. 			char buf[TOKEN_BUF_LEN * 2];
  17. 			string ret;
  18. 			sprintf(buf, "%03ld %-12s ", pos, typestr[type]);
  19. 			ret = buf;
  20. 			ret += text.c_str();
  21. 			return ret;
  22. 		}
  23. 	};

        每个Token包含类型和文本（对应源代码中的表现形式），同时为了调试需要，增加了pos记录在脚本中的位置。

1.2 将脚本拆解为Token

        作为编译的第一步，显然是将源代码分解为token。

        这一步由一个类来实现：

  1. class CTokens
  2. {
  3. 		public:
  4. 			vector<Token > m_tokens;//解析出的语法元素
  5. 			bool ToTokens(string& source)
  6. 			{
  7. 				string::size_type pos = 0;
  8. 				while (GetToken(source, pos));
  9. 				return true;
  10. 			}
  11. };

        解析出的token保存在m_tokens中，而函数ToTokens()仅仅是循环调用GetToken()解析出一个一个token而已。 

        GetToken()是关键的主控函数：

  1. 			bool GetToken(string& source, string::size_type& pos)
  2. 			{
  3. 				Token::types type;
  4. 				string token;
  5. 				char c;
  6. 				bool isInComment = false;
  7. 				while (pos < source.size())
  8. 				{
  9. 					c = source[pos];
  10. 					if (isInComment)
  11. 					{
  12. 						if ('\n' == c)
  13. 						{
  14. 							isInComment = false;
  15. 						}
  16. 						++pos;
  17. 						continue;
  18. 					}
  19. 					if ('/' == c && pos + 1 < source.size() && '/' == source[pos + 1])
  20. 					{
  21. 						isInComment = true;
  22. 						pos += 2;
  23. 						continue;
  24. 					}
  25. 					if (!IsBlank(c))break;
  26. 					++pos;
  27. 				}
  28. 				if (source.size() == pos)return false;
  29. 				if (TryGetKeyword(source.c_str(), pos, token))
  30. 				{
  31. 					type = Token::KEYWORD;
  32. 				}
  33. 				else if (TryGetNumber(source.c_str(), pos, token))
  34. 				{
  35. 					type = Token::NUMBER;
  36. 				}
  37. 				else if (TryGetString(source.c_str(), pos, token))
  38. 				{
  39. 					type = Token::STRING;
  40. 				}
  41. 				else if (TryGetDelimiter(source.c_str(), pos, token))
  42. 				{
  43. 					type = Token::DELIMITER;
  44. 				}
  45. 				else if (TryGetOperator(source.c_str(), pos, token))
  46. 				{
  47. 					type = Token::OPERATOR;
  48. 				}
  49. 				else if (TryGetIdentifier(source.c_str(), pos, token))
  50. 				{
  51. 					type = Token::IDENTIFIER;
  52. 				}
  53. 				else
  54. 				{
  55. 					CmyException::Throw(__FILE__, __LINE__, source.c_str(), pos, "无法识别的符号");
  56. 					return false;
  57. 				}
  58. 				m_tokens.push_back(Token(type, token.c_str(), pos - token.size()));
  59. 				return true;
  60. 			}

        这个函数的流程不复杂，先跳过注释（仅支持单行注释），然后依次尝试每种token，每种尝试如果成功会修改当前位置pos（通过引用参数），如果失败则不会修改pos。

        TryGetXXXX这一组函数每个都不复杂，不过调用顺序有名堂，关键字是最优先的，这就保证关键字不可能被用作变量名。

1.3 TryGetKeyword识别关键字

        这个复杂一些，由几个函数组合而成：

  1. 			//headset最后一个必须是空串
  2. 			bool IsStartWith(char const* str, char const (*headset)[TOKEN_BUF_LEN], string& ret)const
  3. 			{
  4. 				long i = 0;
  5. 				ret = "";
  6. 				while (headset[i][0] != '\0')
  7. 				{
  8. 					size_t keylen = strlen(headset[i]);
  9. 					if (0 == strncmp(headset[i], str, keylen))
  10. 					{
  11. 						if (ret.size() < strlen(headset[i]))ret = headset[i];
  12. 					}
  13. 					++i;
  14. 				}
  15. 				return ret.size() != 0;
  16. 			}
  17. 			bool IsKeyword(char const* str, string& key)const
  18. 			{
  19. 				STATIC_C char const buf[][TOKEN_BUF_LEN] = {
  20. 					"asm","default","float","operator","static_cast","union",
  21. 					"auto","delete","for","private","struct","unsigned",
  22. 					"bool","do","friend","protected","switch","using",
  23. 					"break","double","goto","public","template","virtual",
  24. 					"case","dynamic_cast","if","register","this","void",
  25. 					"catch","else","inline","reinterpret_cast","throw","volatile",
  26. 					"char","enum","int","return","true","wchar_t",
  27. 					"class","explicit","long","short","try","while",
  28. 					"const","export","mutable","signed","typedef",
  29. 					"const_cast","extern","namespace","sizeof","typeid",
  30. 					"continue","false","new","static","typename","string",
  31. 					""
  32. 				};//必须以空串结尾
  33. 				return IsStartWith(str, buf, key);
  34. 			}
  35. 			bool TryGetKeyword(char const* source, string::size_type& pos, string& ret)
  36. 			{
  37. 				string key;
  38. 				string nextkey;
  39. 				size_t keylen;
  40. 				if (IsKeyword(source + pos, key))
  41. 				{
  42. 					keylen = key.size();
  43. 					if ('\0' == source[pos + keylen] || IsBlank(source[pos + keylen]) || IsDelimiter(source[pos + keylen]) || IsOperator(source + pos + keylen, nextkey))
  44. 					{
  45. 						ret = key;
  46. 						pos += keylen;
  47. 						return true;
  48. 					}
  49. 				}
  50. 				return false;
  51. 			}

         规则其实也很简单：以关键字开头并且其后是{空白、分隔符、操作符}则为一个关键字。

1.4 TryGetNumber识别数值

        数值是由数字或点开始的字母数字小数点的串，同时还需要符合一些规则，代码里分两步进行，第一步识别出串，第二步则将串根据各种规则转换为数值：

  1. 			//以数字或点开头的串
  2. 			bool TryGetNumber(char const* source, string::size_type& pos, string& ret)
  3. 			{
  4. 				ret = "";
  5. 				char c = source[pos];
  6. 				if (c >= '0' && c <= '9' || c == '.' && source[pos + 1] >= '0' && source[pos + 1] <= '9')
  7. 				{
  8. 					while ((c = source[pos]) != '\0')
  9. 					{
  10. 						if (c >= '0' && c <= '9' || c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z' || '.' == c || '_' == c)
  11. 						{
  12. 						}
  13. 						else
  14. 						{
  15. 							break;
  16. 						}
  17. 						ret += c;
  18. 						++pos;
  19. 					}
  20. 				}
  21. 				return ret.size() != 0;
  22. 			}
  23. 			bool NumberToVariable(char const* source, Variable& var)
  24. 			{
  25. 				char* endptr;
  26. 				if (IsCharIn('.', source) || IsCharIn('e', source) || IsCharIn('E', source))
  27. 				{
  28. 					var.type = Variable::DOUBLE;
  29. 					var.dValue = strtod(source, &endptr);
  30. 				}
  31. 				else
  32. 				{
  33. 					var.type = Variable::LONG;
  34. 					long prefix = 0;
  35. 					long radix = 10;
  36. 					if (strlen(source) >= 1 && '0' == source[0])
  37. 					{
  38. 						if (strlen(source) >= 2 && ('x' == source[1] || 'X' == source[1]))
  39. 						{
  40. 							radix = 16;
  41. 							prefix = 2;
  42. 						}
  43. 						else
  44. 						{
  45. 							radix = 8;
  46. 							prefix = 1;
  47. 						}
  48. 					}
  49. 					var.lValue = strtol(source + prefix, &endptr, radix);
  50. 				}
  51. 				if (strlen(endptr) != 0)
  52. 				{
  53. 					if (Variable::DOUBLE == var.type && (0 == stricmp(endptr, "f") || 0 == stricmp(endptr, "l"))
  54. 						|| Variable::LONG == var.type && (0 == stricmp(endptr, "u") || 0 == stricmp(endptr, "l") || 0 == stricmp(endptr, "i64")))
  55. 					{
  56. 						return true;
  57. 					}
  58. 					string str;
  59. 					str = "数值常量格式错误 ";
  60. 					str += endptr;
  61. 					CException::Throw(__FILE__, __LINE__, source, endptr - source, str.c_str());
  62. 					return false;
  63. 				}
  64. 				return true;
  65. 			}

1.5 其余TryGetXXXX略 

二、变量

        我非常痛恨无类型变量，比如JavaScript，所以我在这个脚本里面使用强类型。

        变量类型做了简化，分为long、double和string。通过一个类存储所有的变量，代码如下：

  1. 	//变量
  2. 	struct Variable
  3. 	{
  4. 		enum types { NULLVARIABLE = 0, LONG, DOUBLE, STRING };
  5. 		types type;
  6. 		bool isconst;
  7. 		long lValue;
  8. 		double dValue;
  9. 		string strValue;
  10.  
  11. 		Variable() :type(NULLVARIABLE), isconst(false), lValue(0), dValue(0.) {}
  12. 		bool isNull() { return type == NULLVARIABLE; }
  13. 		bool isNumber() { return type == LONG || type == DOUBLE; }
  14. 		bool isString() { return type == STRING; }
  15. 		void clear()
  16. 		{
  17. 			type = NULLVARIABLE;
  18. 			isconst = false;
  19. 			lValue = 0;
  20. 			dValue = 0;
  21. 			strValue = "";
  22. 		}
  23. 		void initvalue()
  24. 		{
  25. 			lValue = 0;
  26. 			dValue = 0;
  27. 			strValue = "";
  28. 		}
  29. 		Variable& operator = (long v)
  30. 		{
  31. 			char buf[256];
  32. 			if (NULLVARIABLE == type)type = LONG;
  33. 			switch (type)
  34. 			{
  35. 			case LONG:lValue = v; break;
  36. 			case DOUBLE:dValue = v; break;
  37. 			case STRING:
  38. 				sprintf(buf, "%ld", v);
  39. 				strValue = buf;
  40. 				break;
  41. 			default:break;
  42. 			}
  43. 			return *this;
  44. 		}
  45. 		Variable& operator = (double v)
  46. 		{
  47. 			char buf[256];
  48. 			if (NULLVARIABLE == type)type = DOUBLE;
  49. 			switch (type)
  50. 			{
  51. 			case LONG:lValue = (long)v; break;
  52. 			case DOUBLE:dValue = v; break;
  53. 			case STRING:
  54. 				gcvt(v, 200, buf);
  55. 				strValue = buf;
  56. 				break;
  57. 			default:break;
  58. 			}
  59. 			return *this;
  60. 		}
  61. 		Variable& operator = (string const& v)
  62. 		{
  63. 			if (NULLVARIABLE == type)type = STRING;
  64. 			switch (type)
  65. 			{
  66. 			case LONG:lValue = atol(v.c_str()); break;
  67. 			case DOUBLE:dValue = atof(v.c_str()); break;
  68. 			case STRING:strValue = v; break;
  69. 			default:break;
  70. 			}
  71. 			return *this;
  72. 		}
  73. 		Variable& operator = (Variable const& v)
  74. 		{
  75. 			if (NULLVARIABLE == type)type = v.type;
  76. 			switch (type)
  77. 			{
  78. 			case LONG:lValue = v.GetLong(); break;
  79. 			case DOUBLE:dValue = v.GetDouble(); break;
  80. 			case STRING:strValue = v.GetString(); break;
  81. 			default:break;
  82. 			}
  83. 			return *this;
  84. 		}
  85. 		Variable operator-()const
  86. 		{
  87. 			Variable tmp = *this;
  88. 			switch (type)
  89. 			{
  90. 			case LONG:tmp.lValue = -lValue; break;
  91. 			case DOUBLE:tmp.dValue = -dValue; break;
  92. 			default:break;
  93. 			}
  94. 			return tmp;
  95. 		}
  96. 		//eva=true则是为赋值提升，结果以左边为准
  97. 		static types typeUpgrade(types a, types b, bool eva = false)
  98. 		{
  99. 			if (NULLVARIABLE == a || NULLVARIABLE == b)return NULLVARIABLE;
  100. 			if (LONG == a && LONG == b)return LONG;
  101. 			if (STRING == a && STRING == b)return STRING;
  102. 			if (DOUBLE == a && DOUBLE == b)return DOUBLE;
  103. 			if (!eva)
  104. 			{
  105. 				if (DOUBLE == a && LONG == b)return DOUBLE;
  106. 				if (LONG == a && DOUBLE == b)return DOUBLE;
  107. 			}
  108. 			else
  109. 			{
  110. 				if (DOUBLE == a && LONG == b)return DOUBLE;
  111. 				if (LONG == a && DOUBLE == b)return LONG;
  112. 			}
  113. 			return NULLVARIABLE;
  114. 		}
  115. 		long GetLong()const
  116. 		{
  117. 			string tmp;
  118. 			switch (type)
  119. 			{
  120. 			case LONG: return lValue;
  121. 			case DOUBLE: return (long)dValue;
  122. 			case STRING: tmp = strValue; return atol(tmp.c_str());
  123. 			default:return 0;
  124. 			}
  125. 		}
  126. 		double GetDouble()const
  127. 		{
  128. 			string tmp;
  129. 			switch (type)
  130. 			{
  131. 			case LONG: return lValue;
  132. 			case DOUBLE: return dValue;
  133. 			case STRING: tmp = strValue; return atof(tmp.c_str());
  134. 			default:return 0.;
  135. 			}
  136. 		}
  137. 		bool GetBool()const
  138. 		{
  139. 			switch (type)
  140. 			{
  141. 			case LONG: return 0 != lValue;
  142. 			case DOUBLE: return 0 != dValue;
  143. 			default:return false;
  144. 			}
  145. 		}
  146. 		string GetString()const
  147. 		{
  148. 			char buf[256];
  149. 			switch (type)
  150. 			{
  151. 			case LONG: sprintf(buf, "%ld", lValue); return buf;
  152. 			case DOUBLE: gcvt(dValue, 200, buf); return buf;
  153. 			case STRING: return strValue;
  154. 			default:return "";
  155. 			}
  156. 		}
  157. 		Variable operator+(Variable const& b)const
  158. 		{
  159. 			Variable tmp = *this;
  160. 			tmp.type = typeUpgrade(type, b.type);
  161. 			switch (tmp.type)
  162. 			{
  163. 			case LONG:tmp.lValue = GetLong() + b.GetLong(); break;
  164. 			case DOUBLE:tmp.dValue = GetDouble() + b.GetDouble(); break;
  165. 			case STRING:tmp.strValue = GetString() + b.GetString(); break;
  166. 			default:break;
  167. 			}
  168. 			return tmp;
  169. 		}
  170. 		Variable operator-(Variable const& b)const
  171. 		{
  172. 			Variable tmp = *this;
  173. 			tmp.type = typeUpgrade(type, b.type);
  174. 			switch (tmp.type)
  175. 			{
  176. 			case LONG:tmp.lValue = GetLong() - b.GetLong(); break;
  177. 			case DOUBLE:tmp.dValue = GetDouble() - b.GetDouble(); break;
  178. 			default:break;
  179. 			}
  180. 			return tmp;
  181. 		}
  182. 		Variable operator*(Variable const& b)const
  183. 		{
  184. 			Variable tmp = *this;
  185. 			tmp.type = typeUpgrade(type, b.type);
  186. 			switch (tmp.type)
  187. 			{
  188. 			case LONG:tmp.lValue = GetLong() * b.GetLong(); break;
  189. 			case DOUBLE:tmp.dValue = GetDouble() * b.GetDouble(); break;
  190. 			default:break;
  191. 			}
  192. 			return tmp;
  193. 		}
  194. 		Variable operator/(Variable const& b)const
  195. 		{
  196. 			Variable tmp = *this;
  197. 			tmp.type = typeUpgrade(type, b.type);
  198. 			switch (tmp.type)
  199. 			{
  200. 			case LONG:
  201. 			{
  202. 				if (0 == b.GetLong())throw "div zero";
  203. 				tmp.lValue = GetLong() / b.GetLong(); break;
  204. 			}
  205. 			case DOUBLE:
  206. 			{
  207. 				if (0 == b.GetDouble())throw "div zero";
  208. 				tmp.dValue = GetDouble() / b.GetDouble(); break;
  209. 			}
  210. 			default:break;
  211. 			}
  212. 			return tmp;
  213. 		}
  214. 		Variable operator%(Variable const& b)const
  215. 		{
  216. 			Variable tmp = *this;
  217. 			tmp.type = typeUpgrade(type, b.type);
  218. 			switch (tmp.type)
  219. 			{
  220. 			case LONG:
  221. 			{
  222. 				if (0 == b.GetLong())throw "mod zero";
  223. 				tmp.lValue = GetLong() % b.GetLong(); break;
  224. 			}
  225. 			default:break;
  226. 			}
  227. 			return tmp;
  228. 		}
  229. 		Variable operator>(Variable const& b)const
  230. 		{
  231. 			Variable tmp = *this;
  232. 			tmp.type = LONG;
  233. 			switch (typeUpgrade(type, b.type))
  234. 			{
  235. 			case LONG:tmp.lValue = GetLong() > b.GetLong(); break;
  236. 			case DOUBLE:tmp.lValue = GetDouble() > b.GetDouble(); break;
  237. 			case STRING:tmp.lValue = GetString() > b.GetString(); break;
  238. 			default:break;
  239. 			}
  240. 			return tmp;
  241. 		}
  242. 		Variable operator<(Variable const& b)const
  243. 		{
  244. 			Variable tmp = *this;
  245. 			tmp.type = LONG;
  246. 			switch (typeUpgrade(type, b.type))
  247. 			{
  248. 			case LONG:tmp.lValue = GetLong() < b.GetLong(); break;
  249. 			case DOUBLE:tmp.lValue = GetDouble() < b.GetDouble(); break;
  250. 			case STRING:tmp.lValue = GetString() < b.GetString(); break;
  251. 			default:break;
  252. 			}
  253. 			return tmp;
  254. 		}
  255. 		Variable operator>=(Variable const& b)const
  256. 		{
  257. 			Variable tmp = *this;
  258. 			tmp.type = LONG;
  259. 			switch (typeUpgrade(type, b.type))
  260. 			{
  261. 			case LONG:tmp.lValue = GetLong() >= b.GetLong(); break;
  262. 			case DOUBLE:tmp.lValue = GetDouble() >= b.GetDouble(); break;
  263. 			case STRING:tmp.lValue = GetString() >= b.GetString(); break;
  264. 			default:break;
  265. 			}
  266. 			return tmp;
  267. 		}
  268. 		Variable operator<=(Variable const& b)const
  269. 		{
  270. 			Variable tmp = *this;
  271. 			tmp.type = LONG;
  272. 			switch (typeUpgrade(type, b.type))
  273. 			{
  274. 			case LONG:tmp.lValue = GetLong() <= b.GetLong(); break;
  275. 			case DOUBLE:tmp.lValue = GetDouble() <= b.GetDouble(); break;
  276. 			case STRING:tmp.lValue = GetString() <= b.GetString(); break;
  277. 			default:break;
  278. 			}
  279. 			return tmp;
  280. 		}
  281. 		Variable operator==(Variable const& b)const
  282. 		{
  283. 			Variable tmp = *this;
  284. 			tmp.type = LONG;
  285. 			switch (typeUpgrade(type, b.type))
  286. 			{
  287. 			case LONG:tmp.lValue = GetLong() == b.GetLong(); break;
  288. 			case DOUBLE:tmp.lValue = GetDouble() == b.GetDouble(); break;
  289. 			case STRING:tmp.lValue = GetString() == b.GetString(); break;
  290. 			default:break;
  291. 			}
  292. 			return tmp;
  293. 		}
  294. 		Variable operator!=(Variable const& b)const
  295. 		{
  296. 			Variable tmp = *this;
  297. 			tmp.type = LONG;
  298. 			switch (typeUpgrade(type, b.type))
  299. 			{
  300. 			case LONG:tmp.lValue = GetLong() != b.GetLong(); break;
  301. 			case DOUBLE:tmp.lValue = GetDouble() != b.GetDouble(); break;
  302. 			case STRING:tmp.lValue = GetString() != b.GetString(); break;
  303. 			default:break;
  304. 			}
  305. 			return tmp;
  306. 		}
  307. 		Variable operator&&(Variable const& b)const
  308. 		{
  309. 			Variable tmp = *this;
  310. 			tmp.type = LONG;
  311. 			switch (typeUpgrade(type, b.type))
  312. 			{
  313. 			case LONG:tmp.lValue = GetLong() && b.GetLong(); break;
  314. 			case DOUBLE:tmp.lValue = GetDouble() && b.GetDouble(); break;
  315. 			default:break;
  316. 			}
  317. 			return tmp;
  318. 		}
  319. 		Variable operator||(Variable const& b)const
  320. 		{
  321. 			Variable tmp = *this;
  322. 			tmp.type = LONG;
  323. 			switch (typeUpgrade(type, b.type))
  324. 			{
  325. 			case LONG:tmp.lValue = GetLong() || b.GetLong(); break;
  326. 			case DOUBLE:tmp.lValue = GetDouble() || b.GetDouble(); break;
  327. 			default:break;
  328. 			}
  329. 			return tmp;
  330. 		}
  331. 		static char const* TypeStr(types type)
  332. 		{
  333. 			STATIC_C const char typestr[][TOKEN_BUF_LEN] = { "NULLVARIABLE","LONG","DOUBLE","STRING" };//必须与types对应
  334. 			if(type>=0 && type<4)return typestr[type];
  335. 			else
  336. 			{
  337. 				static char buf[256];
  338. 				sprintf(buf, "错误的类型 %d", type);
  339. 				//cout << buf << endl; exit(0);
  340. 				return buf;
  341. 			}
  342. 		}
  343. 		string ToString(long level = 0)const
  344. 		{
  345. 			string ret;
  346. 			char buf[256];
  347. 			string prefix;
  348. 			prefix.assign(level * 4, ' ');
  349. 			switch (type)
  350. 			{
  351. 			case LONG:sprintf(buf, "%ld", lValue); break;
  352. 			case DOUBLE:gcvt(dValue, 200, buf); break;
  353. 			case STRING:strcpy(buf, strValue.c_str()); break;
  354. 			default:sprintf(buf, "NULL"); break;
  355. 			}
  356. 			ret = prefix + " ";
  357. 			ret += (isconst ? "常量" : "变量");
  358. 			ret += "类型 ";
  359. 			ret += TypeStr(type);
  360. 			ret += " : ";
  361. 			ret += buf;
  362. 			return ret;
  363. 		}
  364. 	};

        没有使用union，直接用类型和三个变量来存储，空间当然是有浪费的，但是没人知道啊。

        重载了各种类型的相互操作，都很简单，只是繁琐。

        成员变量：

类型变量名功能
enum typestype实际存储的类型
boolisconst是否是常量，常量不允许修改
longlValuetype为LONG时使用
doubledValuetype为DOUBLE时使用
stringstrValuetype为STRING时使用

        这个类没有太多需要解释的，只是作为一个基础数据结构存在。

（这里是本文结束，但不是整个系列的结束）

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/不正经/article/detail/640729
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号