简单的数值 variant

可改变真实类型的 class variant

　　在我完成了 class variant 的第一版后，我想继续完成另一种不同的
variant，这也是看了强大的 boost::variant 后的打算。然而在有了一点点的
初步的想法后，发现我写不下去了，原因很简单，没的目标了。

　　我的第一版的 variant（以下只说 variant）目标很明确：提供一种可以变
化在基本的几种数值类型（int、double 等）上的动态类型。具体说，就是任一
个 variant 的变量如 var，都可以参加 +、-、*、/、% 等运算，但其结果，则
依 var 的真实类型而不同。

　　比如：

  variant var;
  var.set_type (variant_int);   // 设置其真实类型为 int 类型
  var = 1.5;   // var == 1
  var *= 2;    // var == 2

  var.set_type (variant_double);  // 设为 double 型
  var = 1.5;   // var == 1.5
  var /= 0.5;  // var == 3.0

　　variant 可以支持的类型有：int、long、float 和 double；支持与这四种
类型的变量的进行算术运算和比较运算。很不幸，variant 不能与这四种类型之
外的类型进行运算。

　　一、设定类型和赋值

　　在构造函数里，variant(variant_typeid) 和 variant(const string&) 可
以指定类型；而 template variant(type value) 可以由 type 的类型指定。成
员函数 set_typeid() 可以随时设定类型，用 get_typeid() 则可以得到类型的
variant_typeid 值。

　　operator = 可以改变值，但不改变类型；assign() 赋值并改变类型。
template set_value(type) 把源数据当成 type 型变量再赋值，不改变类型；
相应有 template get_value() 可以取值。这些函数里，只有 assign() 是改变
类型的。

　　二、算术运算

　　支持的算术运算有：+、-、*、/、%，以及相应的 += 等运算符。但是注意
float 和 double 并没有 % 运算，对这个运行时错误我并没有处理（我不知道
怎样处理好）。

　　这些算术运算，对需有一则是 variant 即可。但对于 += 这样的运算符，
似乎左边必须是 variant。

　　三、比较运算

　　比较运算支持所有的六种运算，但最终的实现是只有 == 和 < 两种，剩下
四种都可以由这两种变化而来。

　　四、类型自动转换

　　variant 参加各种运算，必然会遇到如 int 与 double 运算的这种情况，
这时就要类型转换了。我的设定是：int -> long -> double 和 float ->
double。可能更应该是 int -> long -> float -> double，但我对 float 实在
是有偏见，实在要打压它。

　　实现：

　　最开始我是用一个 union 去实现的，结果发现并不好，于是变用动态分配
内存的办法，用一个 void* 指向存储单元，而 void* 也便于转换。在 variant
里，有两个数据成员，void* _value 和 variant_typeid _type，_value 指向
真实的存储空间，而 _type 则指定了真实的类型。

　　new_variant(variant_typeid type) 用来分配一个 type 类型的空间，返
回值就是空间的地址。template new_constructor() 分
配并构造一个 type 类型的变量。new_variant() 只是用 switch 语句转而调用
new_constructor()。相似的，有 delete_variant() 和 delete_destructor()，
删除一个变量。

　　这里存在有大量的 variant_typeid 到真实类型的转换，还有真实类型到
variant_typeid 的转换，这两项工作分别由 template struct typeid2type 和
template struct type2typeid 完成。对于 int、long、float 和 double 之外
的类型，这两个工具均会报错。

　　template get_reference() 是用来取得 variant 真实变量的引用的，可是
我觉得它的身份很尴尬，只好在内部使用。觉得这个函数是很重要的，真正要改
变值都要靠这个。这这个函数绝不能用错了（其实哪一个都不能错啊）。

　　template set_value(value) 可以设置 variant
的值，主要是一个 switch 语句，根据 variant 真实类型的不一样而选择合适
的语句：

  switch (_type)
  {
  case variant_int:
    get_reference () = value;
    break;
  ...
  }

　　如果真实类型是 int，那么执行时会选择 variant_int 支路，结果会是正
确的。但是，如果不是 int，也要求 variant_int 支路必须可以编译通过，则
要求 int 必须有从 type 到 int 的赋值运算符。推广开来就是，所有 variant
支持的类型，必须有相同的一系列运算符或方法，而且它们之间必须是可想互转
换的，这是 variant 最大的限制。

　　对于 template get_value() 来说，需要知道返回值的类型，以正确运作。

　　对于有算术运算和比较运算来说，如果运算的类型不匹配的话，则要提升到
一个较高的类型，然后再进行去算。函数 update_typeid() 就是用来计算提升
后的类型的，按照 int->long->double 和 float->double 的原则。

　　算术运算和比较运算，是借助 plus_variant(right)、minus_variant()、
equal_variant()、less_variant() 等这些函数实现的，这些函数都有一个特点
就是，要求 this->_type 等级不低于 right._type。重载的那些如 + 运算符，
都是先建立一个类型等级高的临时 variant temp，然后再调用
temp.plus_variant (right) 来完成运算。这样做唯一的是为了让运算不丢失精
度，以与语法要求相似。

　　对于这种 variant 来说，重要的是找准真实类型并正确实施运算。我的实
现实在是使蛮力，感叹 boost::variant 的精彩。

源代码：

// number variant implementation
// Copyright (C) 2004, BenBear
//
// This file is a class of number variant. This library is free
// software; you can redistribute it and/or modify it under the terms
// of the GNU General Public License as published by the Free Software
// Foundation; either version 2, or (at your option) any later
// version.
// This library is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this library; see the file COPYING.  If not, write to
// the Free Software Foundation, 59 Temple Place - Suite 330, Boston,
// MA 02111-1307, USA.
#ifndef variant_cpp
#define variant_cpp
#include
/* 动态类型的类 */
class variant;
/* 为每一种支持的类型分配一个 id */
enum variant_typeid
  {
    //variant_notype,
    variant_int,     /* int 型 */
    variant_long,    /* long 型 */
    variant_float,   /* float 型 */
    variant_double   /* double 型 */
  };
/* 从类型到类型 id 的转换 */
template struct typeid2type;
template struct type2typeid;
/* 求两种类型运算时要转化的更高一级类型 */
variant_typeid
update_typeid (variant_typeid left, variant_typeid right);
template <> struct typeid2type
{ typedef int value_type; };
template <> struct typeid2type
{ typedef long value_type; };
template <> struct typeid2type
{ typedef float value_type; };
template <> struct typeid2type
{ typedef double value_type; };
template <> struct type2typeid
{ static const variant_typeid type_id = variant_int; };
template <> struct type2typeid
{ static const variant_typeid type_id = variant_long; };
template <> struct type2typeid
{ static const variant_typeid type_id = variant_float; };
template <> struct type2typeid
{ static const variant_typeid type_id = variant_double; };
/* variant 动态类型 */
class variant
{
private:
  void* _value;          /* 指向分配的变量 */
  variant_typeid _type;  /* 当前的类型 */
private:
  /* 取得真实变量的引用，类型由 type 给出，应该保证参数是正确的 */
  template
  typename typeid2type ::value_type&
  get_reference ()
  {
    typedef typename typeid2type ::value_type value_type;
    return *static_cast (_value);
  }
 
  /* 取常引用 */
  template
  const typename typeid2type ::value_type &
  get_reference () const
  {
    typedef typename typeid2type ::value_type value_type;
    return *static_cast (_value);
  }
 
  /* 分配并构造一个确定类型的变量（好象不够灵活） */
  template
  void*
  new_constructor ()
  {
    typedef typename typeid2type ::value_type value_type;
    return new value_type;
  }
  /* 回收并析构一个变量 */
  template
  void
  delete_destructor (void* ptr)
  {
    typedef typename typeid2type ::value_type value_type;
    delete static_cast (ptr);
  }
  /* 根据类型 id 初始化一个新的变量，返回变量的地址 */
  void*
  new_variant (variant_typeid type)
  {
    switch (type)
      {
      case variant_int:
return new_constructor ();
break;
      case variant_long:
return new_constructor ();
break;
      case variant_float:
return new_constructor ();
break;
       case variant_double:
return new_constructor ();
break;
     }
  }
  /* 删除一个变量，类型 id 为 type */
  void
  delete_variant (variant_typeid type, void* ptr)
  {
    switch (type)
      {
      case variant_int:
delete_destructor (ptr);
break;
      case variant_long:
delete_destructor (ptr);
break;
      case variant_float:
delete_destructor (ptr);
break;
      case variant_double:
delete_destructor (ptr);
break;
      }
  }
public:
  explicit variant (variant_typeid var_type = variant_int);
  explicit variant (const std::string& var_type);
  template
  variant (type value);
  ~variant ();
  variant (const variant& var);
  /* 赋值，但不改变类型 */
  variant& operator = (const variant& var);
  template
  variant& operator = (type value);
  /* 改变类型并赋值 */
  variant&
  assign (const variant& var);
  template
  variant&
  assign (type t);
  /* 改变类型为 type 所指定的类型 */
  variant&
  set_typeid (variant_typeid type);
  /* 取得当前的类型 */
  variant_typeid
  get_typeid () const;
  /* 把当前变量清空，暂不用 */
  /*void
    clear ();*/
  /* 取变量的值，并转换成 type 指定的类型 */
  template
  typename typeid2type ::value_type
  get_value () const
  {
    typedef typename typeid2type ::value_type value_type;
    switch (_type)
      {
      case variant_int:
return static_cast (get_reference ());
break;
      case variant_long:
return static_cast (get_reference ());
break;
      case variant_float:
return static_cast (get_reference ());
break;
      case variant_double:
return static_cast (get_reference ());
break;
      }
  }
  /* 给 t 赋值 */
  template
  void
  get_value (type& t) const
  {
    const variant_typeid type_id = type2typeid ::type_id;
    t = get_value ();
  }
  /* 设定变量的值 */
  template
  void
  set_value (typename typeid2type ::value_type value)
  {
    typedef typename typeid2type ::value_type value_type;
    typedef typeid2type ::value_type int_type;
    typedef typeid2type ::value_type long_type;
    typedef typeid2type ::value_type float_type;
    typedef typeid2type ::value_type double_type;
    switch (_type)
      {
      case variant_int:
get_reference () = static_cast (value);
break;
      case variant_long:
get_reference () = static_cast (value);
break;
      case variant_float:
get_reference () = static_cast (value);
break;
      case variant_double:
get_reference () = static_cast (value);
break;
      }
  }
 
private:
  /* 以下几个函数，从加法、减法一直到等于、小于比较，都是假定 *this 的
     类型等级要高于 right 的类型 */
  /* 加法运算，*this += right */
  void
  plus_variant (const variant& right)
  {
    switch (_type)
      {
      case variant_int:
get_reference () += right.get_value ();
break;
      case variant_long:
get_reference () += right.get_value ();
break;
      case variant_float:
get_reference () += right.get_value ();
break;
      case variant_double:
get_reference () += right.get_value ();
break;
      }
  }
  /* 减法运算，*this -= right */
  void
  minus_variant (const variant& right)
  {
    switch (_type)
      {
      case variant_int:
get_reference () -= right.get_value ();
break;
      case variant_long:
get_reference () -= right.get_value ();
break;
      case variant_float:
get_reference () -= right.get_value ();
break;
      case variant_double:
get_reference () -= right.get_value ();
break;
      }
  }
  /* 乘法运算，*this *= right */
  void
  multi_variant (const variant& right)
  {
    switch (_type)
      {
      case variant_int:
get_reference () *= right.get_value ();
break;
      case variant_long:
get_reference () *= right.get_value ();
break;
      case variant_float:
get_reference () *= right.get_value ();
break;
      case variant_double:
get_reference () *= right.get_value ();
break;
      }
  }
  /* 除法运算，*this /= right */
  void
  div_variant (const variant& right)
  {
    switch (_type)
      {
      case variant_int:
get_reference () /= right.get_value ();
break;
      case variant_long:
get_reference () /= right.get_value ();
break;
      case variant_float:
get_reference () /= right.get_value ();
break;
      case variant_double:
get_reference () /= right.get_value ();
break;
      }
  }
  /* 求余运算，*this %= right */
  void
  mod_variant (const variant& right)
  {
    switch (_type)
      {
      case variant_int:
get_reference () %= right.get_value ();
break;
      case variant_long:
get_reference () %= right.get_value ();
break;
/* 对浮点数没有求余运算，怎么处理？抛出异常？ */
/*
case variant_float:
   get_reference () %= right.get_value ();
   break;
case variant_double:
   get_reference () %= right.get_value ();
   break;
*/
      }
  }
  /* 等于比较，*this == right */
  bool
  equal_variant (const variant& right)
  {
    switch (_type)
      {
      case variant_int:
return (get_reference ()
  == right.get_value ());
break;
      case variant_long:
return (get_reference ()
  == right.get_value ());
break;
      case variant_float:
return (get_reference ()
  == right.get_value ());
break;
      case variant_double:
return (get_reference ()
  == right.get_value ());
break;
      }
  }
  /* 小于比较，*this < right */
  bool
  less_variant (const variant& ri