Question

我有什么方法可以定义unordered_map<*,*> var并根据情况或其他方式使用适当的类型重新定义它？

我正在阅读一些二进制文件，每种文件的格式都不同，因此<int, string>, <short, string>, <int, int>, etc..

的格式可能会有所不同

我能想到的唯一方法是定义它<char *, char *>，但我必须定义散列和其他类似的东西。

还有其他选择吗？

修改。为问题添加更多内容：

我将迭代另一个列表并从ordered_maps中获取值，我将知道我用于键的数据类型，并使用它来生成JSON字符串作为结果。

对于更多上下文，文件的格式如下：

INT number of fields to use. Example: 3
-- now there is a for from 1 to 3 as we have 3 fields
CHAR type of data (1 = int8, 2 = int16, 3 = int32, 4=string)
STRING name of the field
STRING alias of the field
-- end for
-- now I do a while not EOF
    -- for each field
        read value from file (int8, int16, int32, string) depending the type of field
        first item of the for will be the KEY
        if item != first add the value to an unoredered_map using the first as key
    -- end for
-- end while

Answer 1

你打算在地图中存储什么？你将如何选择它？

您的问题有两种实用的解决方案：

参数多态性

这就是你应该首先尝试解决问题的方法。保留unordered_map通用的参数。

这主要是通过像

这样的结构来完成的

class Reader {
  virtual void readFile(const std::string& name) = 0;
};

template<typename K, typename V>
class RealReader {
private:
  std::unordered_map<K,V> data;

public:
  void readFile(const std::string& name) override {
    K key = // read key;
    V value = // read value
    data[key] = value;
  }
};

亚型多态性

定义您自己的Key和/或Value类，以便您可以定义std::unordered_map<Key*,Value*>，然后使用所需类型对这些自定义类型进行子类型化。

如果不知道如何使用这些内容，很难说出最佳效果。

Answer 2

我最终使用自定义类型和void *作为数据。

所以我在struct中设置了var的类型和它的数据。

结果如下：

struct fieldVariant {
    char type;
    void * data;
    fieldVariant(char _type, void * _data) {
        type = _type;
        data = _data;
    }
};
struct fieldHash {
    inline size_t operator()(const fieldVariant * val) const
    {
        unsigned long h = 0;
        unsigned long varSize = 0;
        switch (val->type) {
            case INT8:
                varSize = 1;
                break;
            case INT16:
                varSize = 2;
                break;
            case INT32:
                varSize = 4;
                break;
            case INT64:
                varSize = 8;
                break;
            case INT128:
                varSize = 16;
                break;
            case CHAR2:
                varSize = ((string *)val->data)->length();
                break;
        }

        for (int i=0; i < varSize; i++)
            h = 5 * h + *(char *)(val->data + i);
        return size_t(h);
    }
};


struct fieldEql {
    inline bool operator()(const fieldVariant *s1,const fieldVariant *s2) const {
        unsigned long varSize = 0;
        switch (s1->type) {
            case INT8:
                varSize = 1;
                break;
            case INT16:
                varSize = 2;
                break;
            case INT32:
                varSize = 4;
                break;
            case INT64:
                varSize = 8;
                break;
            case INT128:
                varSize = 16;
                break;
            case CHAR2:
                return *((string *)s1->data) == *((string *)s2->data);
        }
        return memcmp(s1->data, s2->data, varSize) == 0;
    }
};

unordered_map<fieldVariant *, fieldVariant *, fieldHash, fieldEql> data;
void add(fieldVariant * key, fieldVariant * value) {data[key] = value;};

C ++ unordered_map在运行时指定类型

2 个答案:

参数多态性

亚型多态性