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

Question

Is there any way that I could define an unordered_map<*,*> var and depending a case or other redefine it with the appropriate types?

I'm reading some binaries files and the format is different for each so depending the formats it can by <int, string>, <short, string>, <int, int>, etc..

The only way I can think of is to define it <char *, char *> but I would have to define the hashing and other thing to work like that.

Is there any other option?

EDIT. ADD MORE CONTEXT FOR THE PROBLEM:

I will iterate another lists and get the values from the ordered_maps, I will know what type of data I'm using for the key and use that to generate a JSON string as result.

For more context the format of the files are like these:

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

What are you going to store inside the map and how are you going to choose it?

There are two practical solution to your problem:

Parametric Polymorphism

This is how you should try to solve your problem in the first place. By keeping the arguments of your unordered_map generic.

This is mostly done by having a structure like

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;
  }
};

Subtype Polymorphism

Define your own Key and/or Value classes so that you can define a std::unordered_map<Key*,Value*> and then subtype these custom types with your required types.

Without knowing how these are going to be used it's difficult to tell what's best.

Answer 2

I ended up using a self defined type and void * for the data.

So I set the type of the var in the struct and the data for it.

Here is the result:

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;};