I am using `map<MyStruct, I*> map1;`

. Apparently 9% of my total app time is spent in there. Specifically on one line of one of my major functions. The map isn't very big (<1k almost always, <20 is common).

Is there an alternative implementation i may want to use? I think i shouldn't write my own but i could if i thought it was a good idea.

Additional info: I always check before adding an element. If a key exist I need to report a problem. Than after a point i will be using map heavily for lookups and will not add any more elements.

## Best Solution

First you need to understand what a map is and what the operations that you are doing represent. A

`std::map`

is a balanced binary tree, lookup will take`O( log N )`

operations, each of which is a comparison of the keys plus some extra that you can ignore in most cases (pointer management). Insertion takes roughly the same time to locate the point of insertion, plus allocation of the new node, the actual insertion into the tree and rebalancing. The complexity is again`O( log N )`

although the hidden constants are higher.When you try to determine whether an key is in the map prior to insertion you are incurring the cost of the lookup and if it does not succeed, the same cost to locate the point of insertion. You can avoid the extra cost by using

`std::map::insert`

that return a pair with an iterator and a bool telling you whether the insertion actually happened or the element was already there.Beyond that, you need to understand how costly it is to compare your keys, which falls out of what the question shows (

`MyStruct`

could hold just one`int`

or a thousand of them), which is something you need to take into account.Finally, it might be the case that a

`map`

is not the most efficient data structure for your needs, and you might want to consider using either an`std::unordered_map`

(hash table) that has expected constant time insertions (if the hash function is nothorrible) or for small data sets even a plain ordered array (or`std::vector`

) on which you can use binary search to locate the elements (this will reduce the number of allocations, at the cost of more expensive insertions, but if the held types are small enough it might be worth it)As always with performance, measure and then try to understand where the time is being spent. Also note that a 10% of the time spent in a particular function or data structure might be a lot or almost nothing at all, depending on what your application is. For example, if your application is just performing lookups and insertions into a data set, and that takes only a 10% of the CPU you have a lot to optimize everywhere else!