Looking for right container

[10oTURfi]

I need a map-like container in which 1 value could be accessed by multiple keys(usually dozen), which could be dynamically added/removed.
Would such thing hurt performance? Am I better off just using map of pointers in which multiple pointers point to same object?

[hanst99]

How would the container you imagine behave differently than a map with multiple pointers to the same object?

[10oTURfi]

Actually, on second thought... It probably wouldnt. I have no clue what I was thinking when I posted this question...

[3TXyhbRD]

Think about this case:
3 keys: a, b, c and to each you assign a pointer that points to a dynamic variable. When I delete the value assigned to a (freeing the memory, because it's dynamically allocated), what would the assigned value for b and c point?

What your map-like container looks like is probably like this: for a value you can assign, not a single key, but a set of keys. By using this representation your performance won't be hurt because your search for a key will still take O(|K|), K being the actual key domain (a set of all keys that are being used at that moment).

[10oTURfi]

Yes! That was it. Thanks for reminding me.

By now i assume such container doesnt exist. Guess i should write one...

[Cubbi]

The boost library has multi-index containers: http://www.boost.org/doc/libs/release/libs/multi_index/doc/index.html , although it doesn't support dynamic addition/removal of keys.

If you really want that (even if you want to write your own), look into databases.

[3TXyhbRD]

You can use an ordinary map where your key is actually a set and override the equal and not equal operators to search for a key in the set.
Using an existing set from which you derive and add the functions you need will be the fastest way to go.

[viliml]

you could use map<vector</*the type of your keys*/>, /*the type of your values*/>

[rapidcoder]

An unordered_map of keys to pointers seems to be the right solution. If you want object sharing, use shared_ptrs. Really, why complicate things?

If you use vectors or sets as keys, you won't be able to search on keys.
Multiindex container and databases are overkill. It would be slower, heavier and you wouldn't use most of the functionality.

[10oTURfi]

I just wrote this one. Not sure if its best idea, but what do you guys think?

#include <iostream>
#include <vector>
#include <string>
using namespace std;

template<class K, class T>
class map
{
    struct Node
    {
        std::vector<K> vKeys;

        T data;
        Node* pNext;
    };

    Node* pFirst;
public:

    map()
    {
        pFirst = NULL;
    }
    ~map()
    {
        Node* pTemp;
        while(pFirst)
        {
            pTemp = pFirst;
            pFirst = pFirst->pNext;
            delete pTemp;
        }
    }
    T& operator[](K key)
    {
        if(!pFirst)
        {
            pFirst = new Node;
            pFirst->vKeys.push_back(key);
            pFirst->pNext = NULL;
            return pFirst->data;
        }
        Node* pIter = pFirst;
        Node* pTemp;
        while(pIter)
        {
            pTemp = pIter;
            for(unsigned i=0; i<pIter->vKeys.size(); ++i)
            {
                if(pIter->vKeys[i] == key)
                    return pIter->data;
            }
            pIter = pIter->pNext;
        }
        pIter = new Node;
        pIter->pNext = NULL;
        pIter->vKeys.push_back(key);
        pTemp->pNext = pIter;
        return pIter->data;
    }
    /*
    Note that T is always a pointer, 
    but that is not the case in this dummy example
    */
    void add_key(T where, K key)
    {
        Node* pIter = pFirst;
        while(pIter)
        {
            if(pIter->data == where)
            {
                pIter->vKeys.push_back(key);
                return;
            }
            pIter = pIter->pNext;
        }
        throw "This shouldn't happen";
    }
};

int main()
{
    map<int, string> m;

    m[5] = "foo";
    m[15] = "bar";
    m.add_key("foo", 14);

    cout << m[14] << endl << m[15];

    cin.get();
}