unordered_map bugging out when assigning or inserting [closed] - c++

Question

Closed. This question needs debugging details. It is not currently accepting answers.
Edit the question to include desired behavior, a specific problem or error, and the shortest code necessary to reproduce the problem. This will help others answer the question.
Closed 3 years ago.
Improve this question
Whenever I try to initialise/assign or insert a lot of elements at once it won't insert the items and then will skip the rest of the function.
My map is of types int and a struct that holds 6 const char*'s, there are ~70 elements that I want to initialise my map with. Ive tried using less elements (~50) but it still bugs out.
Ive tried debugging it line by line and it will run for the first ~20 elements then after that it will start skipping them, e.g. insert(elem_20) then will skip to insert(elem_22) and {pair20, pair21, pair22} would skip pair21 and go straight to pair22, it seems random as far as I can tell.
I have tried the following :
// global scope, won't initialise the map
unordered_map<int, struct> my_map = {std::make_pair(...), ...};
// in a function
void init_map()
{
// my_map is defined in the global scope
// won't be assigned
my_map = { std::make_pair(...), ... };
// this will be skipped
other_func();
...
}
// in a function
void init_map_insert()
{
// will insert the first 20 or so then gets buggy after that
// my_map is defined in the global scope
my_map.insert(std::make_pair(...));
my_map.insert(std::make_pair(...));
my_map.insert(std::make_pair(...));
...
// this will be skipped
other_func();
...
}
Video of the problem : https://www.youtube.com/watch?v=pIg6bn6fB6E
You can see the first breakpoint getting triggered but then the breakpoints at the end of the of the function aren't triggered, as well as the breakpoint right after the function call.
I am using Xcode on MacOS 10.14.
Any help would be appreciated
Cheers
Edit : sorry, I'm not that good at explaining
Edit 2 : Added video

Answer 1

I'm going to leave this as an answer even though it shouldn't be because you didn't provide any reproducible code or enough information so I can only guess here. When using a map of any kind, including of course unordered_map, it will only allow one entry per key. You did not specify how your key is determined but my guess is that you have cases where a new value is entered but overwrites an existing key.

Answer 2

Your unordered_map is initialized here:
unordered_map<int, struct> my_map = {std::make_pair(...), ...};
then you re-initialized the map in init_map(), which wipes out the what was previously initialized in the list initialization.
// in a function
void init_map()
{
// my_map is defined in the global scope
// won't be assigned
my_map = { std::make_pair(...), ... };
Note that my_map = { blah } is equivalent to
my_map = unordered_map<int, struct>{blah}
which invokes assignment operator of my_map.
This is probably the bug you're talking about.