Initializing a std::map when the size is known in advance

Question

I would like to initialize a std::map. For now I am using ::insert but I feel I am wasting some computational time since I already know the size I

Answer 1

There are several good answers to this question already, but they miss some primary points.

Initialize the map directly

The map knows the size up front if initialized directly with iterators:

auto mymap = std::map(it_begin, it_end);

This is the best way to dodge the issue. If you are agnostic about the implementation, the map can then know the size up front from the iterators and you moved the issue to the std:: implementation to worry about.

Alternatively use insert with iterators instead, that is:

mymap.insert(it_begin, it_end);

See: https://en.cppreference.com/w/cpp/container/map/insert

Beware of Premature optimization

but I feel I am wasting some computational time.

This sounds a lot like you are optimization prematurely (meaning you do not know where the bottleneck is - you are gueessing or seeing an issue that isn't really one). Instead, measure first and then do optimization - repeat if neccesary.

Memory allocation could already be optimized, to a large degree

Rolling your own block allocator for the map could be close to fruitless. On modern system(her I include OS/hardware and the c++ language level) memory allocation is already very well optimized for the generel case and you could be looking at little or no improvement if rolling your own block allocator. Even if you take a lot of care and get the map into one contiguoes array - while an improvement in itself - you could still be facing the problem that in the end, the elements could be placed randomly in the array (eg. insertion order) and be less cache friendly anyway (this very much depending on your actual use case though - Im assuming a super large data-set).

Use another container or third party map

If you are still facing this issue - the best approach is probably to use another container (eg. a sorted std::vector - use std::lower_bound for lookups) or use a third party map optimized for how you are using the map. A good example is flat_map from boost - see this answer.

Conclusion

1. Let the std::map worry about the issue.
2. When performance is the main issue: use a data structure (perhaps 3rd party) that best suits how your data is being used (random inserts or bulk inserts / mostly iteration or mostly lookups / etc.). You then need to profile and gather performance metrics to compare.