C++ inserting in map() is taking a long time - c++

Question

I have a map with types <int, foo*> which I am populating from a database. int is a unique key so before populating I am checking if key is already in map if not than a new object of type foo is created and inserted in map.
The foo class also has another map as attribute with types <int, float> which also needs to be populated from the database. I have the below code which is supposedly simple:
std::map<int, foo> MAP;
while(getline(infile, line))
{ //reading records in data file
string item;
stringstream ss(line);
vector<string> splittedString;
int a = stoi(splittedString[0]); // cells after splitting data
int b = stoi(splittedString[1]);
float c = stof(splittedString[2]);
if (MAP.find(a) == MAP.end())
{
foo f = foo();
MAP.insert({a, &f});
f.fooMap.insert({b, c/100});
}
else
{
foo* f = MAP.at(a);
f->fooMap.insert({b, c/100});
}
}
This is taking a ridiculous amount of time to compute. There are about 50,000 records but that should not take forever. I am pretty sure I am doing something wrong since I am somewhat rusty with c++.
I know I have some redundancy when creating the foo object and I think a more efficient way of doing the above is the below 'incorrect' code:
while(getline(infile, line))
{//reading records in data file
string item;
stringstream ss(line);
vector<string> splittedString;
int a = stoi(splittedString[0]); //cells after splitting data
int b = stoi(splittedString[1]);
float c = stof(splittedString[2]);
foo f = *MAP[a];
if (f == NULL)
{
f = foo();
MAP.insert({a, &f});
}
f->fooMap.insert({b, c/100});
}
update
if I use MAP<int, foo> instead of MAP<int, foo*> (and arranging the insertion code accordingly), the code works normally. So I am doing something wrong with pointers. what is the best way to tackle this?

Answer 1

You code is a little bit more complicated than it needs to be. You should let std::map do the work instead of trying it yourself. What you want is the .emplace function of the container. It not only skips the insert if not necessary, but it also gives you the right entry to modify. For example, you could do something like:
#include <iostream>
#include <map>
#include <string>
int main()
{
//helper
auto print = [](auto MAP)
{
std::cout << "MAP:\n";
for (auto && each : MAP)
std::cout << each.first << "->" << each.second << '\n';
};
//work
std::map<int, std::string> MAP;
MAP.emplace(1,"").first->second = "one";
MAP.emplace(2,"").first->second = "two";
print(MAP);
MAP.emplace(1,"").first->second = "three";
print(MAP);
}
Which produces the following output:
MAP:
1->one
2->two
MAP:
1->three
2->two
Of course, this has this weird .first->second syntax, but we can refactor it into a new lambda:
auto update = [](auto& MAP, auto index, auto entry)
{
MAP.emplace(index,"").first->second = entry;
};
which lets you write the following:
update(MAP, 1, "one");
update(MAP, 2, "two");
print(MAP);
update(MAP, 1, "three");
print(MAP);
EDIT
Because you asked for a std::unique_ptr solution, here is it:
#include <iostream>
#include <map>
#include <string>
#include <memory>
int main()
{
//helper
auto print = [](const auto& MAP)
{
std::cout << "MAP:\n";
for (auto && each : MAP)
std::cout << each.first << "->" << *each.second.get() << '\n';
};
//work
std::map<int, std::unique_ptr<std::string>> MAP;
auto update = [](auto& MAP, auto index, auto entry)
{
*MAP.emplace(index, std::make_unique<std::string>()).first->second.get() = entry;
};
update(MAP, 1, "one");
update(MAP, 2, "two");
print(MAP);
update(MAP, 1, "three");
print(MAP);
}
It unfortunately gets a little bit unreadable and also annoying because std::unique_ptr cannot be copied. (This is just the way it is implemented.)