变体转换系统

Question

我编写了一个变体类，它将用作动态语言中的主要类型，最终将允许 256 种不同类型的值（标头是无符号字节，实际只使用 20 个）。我现在想实现类型之间的转换/转换。

我最初的想法是一个查找表，但是所需的内存量使其实现起来不切实际。

有哪些替代方案？现在，我正在考虑根据其他人的研究和建议进一步采用三种方法：

1. 将类型分组为更大的子集，例如数字或集合或其他。
2. 创建一个具有 CanCast(from, to) 和 Cast(Variant) 方法的转换接口，并允许将实现该接口的类添加到列表中，然后可以检查该列表以查看是否有任何转换类可以执行转换。
3. 与（1）类似，但制作多个母版，并且铸造是从原始类型到母版然后再到最终类型的两步过程。

最好的系统是什么？

编辑：我已经添加了赏金，因为我仍然不确定最好的系统，当前的答案非常好，并且肯定得到了我的+1，但一定有人已经做到了这一点并且可以说出最好的方法是什么。

Answer 1

我的系统非常“重”（大量代码），但速度非常快，而且功能非常丰富（跨平台 C++）。我不确定您希望您的设计走多远，但这是我所做的最重要的部分：

DatumState - 持有“枚举”的类“ type”，加上本机值，它是所有原始类型（包括 void*）之间的“联合”。此类与所有类型分离，可用于任何本机/原始类型以及“引用”void* 类型。由于“enum”还具有“VALUE_OF”和“REF_TO”上下文，因此此类可以呈现为“完全包含”float（或某些原始类型），或“引用但不拥有”float（或某些原始类型）。 （我实际上有“VALUE_OF”、“REF_TO”和“PTR_TO”上下文，因此我可以逻辑地存储值，一个不能为空的引用，或者一个可能为空或不为空的指针，我知道我需要它删除或不删除。）

Datum - 完全包含 DatumState 的类，但它扩展了其接口以适应各种“众所周知”的类型（例如 MyDate、MyColor、MyFileName 等）。已知类型实际上存储在 DatumState 成员内的 void* 中。但是，由于 DatumState 的“enum”部分具有“VALUE_OF”和“REF_TO”上下文，它可以表示“指向 MyDate 的指针”或“MyDate 的值”。

DatumStateHandle - 使用（众所周知的）类型参数化的帮助程序模板类（例如 MyDate、MyColor、< code>MyFileName 等）这是 Datum 使用的访问器从众所周知的类型中提取状态。默认实现适用于大多数类，但任何具有特定访问语义的类都只会覆盖该模板类中一个或多个成员函数的特定模板参数化/实现。

宏、辅助函数和其他一些支持内容 - 简化将众所周知的类型“添加”到我的 Datum/Variant 中，我发现将逻辑集中到几个宏中，提供一些支持功能（例如运算符重载），并在代码中建立一些其他约定很方便。

作为此实现的“副作用”，我获得了很多好处，包括引用和值语义、所有类型上的“null”选项以及对所有类型的异构容器的支持。

例如，您可以创建一组整数并对它们进行索引：

int my_ints[10];
Datum d(my_ints, 10/*count*/);
for(long i = 0; i < d.count(); ++i)
{
  d[i] = i;
}

类似地，某些数据类型通过字符串或枚举进行索引：

MyDate my_date = MyDate::GetDateToday();
Datum d(my_date);
cout << d["DAY_OF_WEEK"] << endl;
cout << d[MyDate::DAY_OF_WEEK] << endl; // alternative

我可以存储项目集（本机）或集合Datum< /code>s（包装每个项目）。对于任何一种情况，我都可以递归地“展开”：

MyDate my_dates[10];
Datum d(my_dates, 10/*count*/);
for(long i = 0; i < d.count(); ++i)
{
  cout << d[i][MyDate::DAY_OF_WEEK] << endl;
}

有人可能会说我的“REF_TO”和“VALUE_OF”语义太过分了，但它们对于“set-unwrapping”至关重要”。

我已经用九种不同的设计完成了这个“Variant”的事情，我当前的是“最重的”（大多数代码），但我最喜欢的一个（几乎是速度最快的一个相当小的对象足迹），并且我已经弃用了其他八种设计供我使用。

我的设计的“缺点”是：

1. 对象是通过以下方式访问的 ：
   来自 void* 的 static_cast<>()
   （类型安全并且相当快，但是
   需要间接；但，
   副作用是设计支持
   存储“null”。）
2. 编译时间较长，因为
   曝光的知名类型
   通过 Datum 接口（但是你
   如果您不这样做，可以使用 DatumState
   想要众所周知的类型 API）。

无论您的设计如何，我都会推荐以下内容：

1. 使用“enum”或其他东西来告诉
   你的“类型”，与
   “值”。 （我知道你可以压缩
   它们变成一个“int”或其他东西
   带位包装，但那就是
   访问速度慢并且非常棘手
   保持新类型
   介绍。）

2. 依靠模板或其他东西来集中操作，
   特定类型的机制
   （覆盖）处理（假设你想
   处理重要的类型）。

游戏的名称是“添加新类型时简化维护”（或者至少对我来说是这样）。就像一篇好的学期论文一样，如果您不断地删除所需的代码，那么重写、重写、重写来保留或增加您的功能是一个非常好的主意。维护系统（例如，最大限度地减少使新类型适应现有Variant基础设施所需的工作）。

祝你好运！

Answer 2

做过类似的事情。

您可以在“标头”中添加另一个字节，指示其真正存储的类型。

C 风格编程语言示例：

typedef
enum VariantInternalType {
  vtUnassigned = 0;
  vtByte = 1;
  vtCharPtr = 2; // <-- "plain c" string
  vtBool = 3;
  // other supported data types
}

// --> real data
typedef
struct VariantHeader {
  void* Reserved; // <-- your data (byte or void*)
  VariantInternalType VariantInternalType;  
}

// --> hides real data
typedef
  byte[sizeof(VariantHeader)] Variant;

// allocates & assign a byte data type to a variant
Variant ByteToVar(byte value)
{
  VariantHeader MyVariantHeader;
  Variant MyVariant;

  MyVariantHeader.VariantInternalType = VariantInternalType.vtByte;
  MyVariantHeader.Reserved = value;  

  memcpy (&MyVariant, &MyVariantHeader, sizeof(Variant));

  return myVariant;
}

// allocates & assign a char array data type to a variant
Variant CharPtrToVar(char* value)
{
  VariantHeader MyVariantHeader;
  Variant MyVariant;

  MyVariantHeader.VariantInternalType = VariantInternalType.vtByte;
  MyVariantHeader.Reserved = strcpy(value);  

  // copy exposed struct type data to hidden array data
  memcpy(&MyVariant, &MyVariantHeader, sizeof(Variant));

  return myVariant;
}

// deallocs memory for any internal data type
void freeVar(Variant &myVariant)
{
  VariantHeader MyVariantHeader;

  // copy exposed struct type data to hidden array data
  memcpy(&MyVariantHeader, &MyVariant, sizeof(VariantHeader));

  switch (MyVariantHeader.VariantInternalType) {
    case vtCharPtr:
      strfree(MyVariantHeader.reserved);
    break;

    // other types

    default:
    break;
  }

  // copy exposed struct type data to hidden array data
  memcpy(&MyVariant, &MyVariantHeader, sizeof(Variant));
}

bool isVariantType(Variant &thisVariant, VariantInternalType thisType)
{
  VariantHeader MyVariantHeader;

  // copy exposed struct type data to hidden array data
  memcpy(&MyVariantHeader, &MyVariant, sizeof(VariantHeader));

  return (MyVariant.VariantInternalType == thisType);
}

// -------

void main()
{
  Variant myVariantStr = CharPtrToVar("Hello World");
  Variant myVariantByte = ByteToVar(42);

  char* myString = null;
  byte  myByte = 0;

  if isVariantType(myVariantStr, vtCharPtr) {
    myString = VarToCharPtr(myVariantStr);
    // print variant string into screen
  }

  // ...    
}

这只是一个建议，未经测试。

Answer 3

也许您已经完成了计算，但查找表所需的内存量并没有那么多。

如果您只需要检查类型是否兼容，那么您需要 (256*256)/2 位。这需要 4k 内存。

如果您还需要一个指向转换函数的指针，那么您需要 (256*256)/2 个指针。这在 32 位机器上需要 128k 内存，在 64 位机器上需要 256k 内存。如果您愿意进行一些低级地址布局，则可能可以在 32 位和 64 位计算机上将其降至 64k。