What is the quickest way of inserting/updating std::unordered_map elements without using an if?

Question

I currently have lots of code which looks like this:

std::unordered_map<int,int> my_dict;
.
.
.
// If the key does exist in the dictionary
if(my_dict.count(key) == 1){
    my_dict[key] = value;
}

// If its a new key
else{
    my_dict.insert(std::make_pair(key,value));
}

Is there any way I can speed this up by just overwriting the value every time?

@billz I want O(1) insertion time? I don't want a tree O log(N) — user997112, Oct 05 '13 at 12:29
the [] does this. http://www.cplusplus.com/reference/unordered_map/unordered_map/operator[]/ Of course, the complexity must be linear. If you want less insertion time, use a map — janoliver, Oct 05 '13 at 12:29
@janoliver: linear is only the worst case. if you are only interested in amortized cost, switching to map is a really bad idea. — Karoly Horvath, Oct 05 '13 at 12:36
@janoliver The odds of it being linear is an extremely derivative case. It most/all cases it will be O(1) or very close. — Joe, Oct 05 '13 at 12:37
You are right, I just realized that unordered map also uses some bucket like storage mechanism. — janoliver, Oct 05 '13 at 12:42
@user997112 Use `(*my_dict_ptr)[key]` or `my_dict_ptr->operator[](key)` then. — Daniel Frey, Oct 05 '13 at 13:06
If you want to update the value each time, then just go for my_dict[key] = value. However, if you don't want to update the value for an existing key, then your code is correct (and fastest). — user2015735, Sep 28 '17 at 07:45

score 78 · Accepted Answer · answered Oct 05 '13 at 12:35

78

You just do (for map and unordered_map)

mydict[key]=value;

answered Oct 05 '13 at 12:35

Joe

41,484
20
104
125

1

using `if-else` would be faster if and only if default construction of `value` is very expensive. Though, in most of the cases `operator[]` does the job. – letsBeePolite Aug 29 '17 at 16:14

score 28 · Answer 2 · edited May 16 '23 at 01:37

28

I think it might be fastest like this:

auto it = my_dict.find(key);
if( it != my_dict.end() ) {
    it->second = value;
}
else {
    my_dict.insert(std::make_pair(key, value));
}

that way you don't modify the structure of the unordered_map if the key already exists and you only have one lookup.

Note that the above, seemingly verbose code is more flexible than:

my_dict[key] = value;

This is because Value& std::unordered_map::operator [] (const Key& key); requires Value to have default constructor (in case of value not inserted by key - construct it first, than assign/replace) that maybe not present.

Another option in case you don't need/access value afterwards:

my_dict[key] = std::move(value);

This might be better in cases when the assignment of value is expensive and benefits from move-semantics.

edited May 16 '23 at 01:37

user16217248

3,119
19
19
37

answered Oct 05 '13 at 12:32

Daniel Frey

55,810
13
122
180

4

@us2012 Mostly, but in the insert-case, it first inserts a default constructed value, then assigns it. The above avoids that overhead. – Daniel Frey Oct 05 '13 at 12:35
5

I'd do some serious measurement of the simple case (`foo[key]=value;`) before I go this route. – Joe Oct 05 '13 at 12:37
1

@Joe Yes. Without a profile run that shows that this is a problem, go for the more readable code. That *would* have been my answer when this question would lack the "performance" tag :) – Daniel Frey Oct 05 '13 at 12:38
1

My general experience is most people misinterpret which things are drags on their performance. I'd expect the performance difference between the OP's code and either solution here to be very small in an `unordered_map`... – Joe Oct 05 '13 at 12:41
1

@DanielFrey: The `value_type` is `pair`. Any overhead will most likely be optimised away. – Marcelo Cantos Oct 05 '13 at 12:42
@MarceloCantos For this example, yes. I was thinking about the generic case. – Daniel Frey Oct 05 '13 at 12:47
If key is not present, this performs a search twice. You should just call `insert` and check the boolean return value. – Jorge Bellon Jul 29 '20 at 12:22

score 10 · Answer 3 · answered Apr 18 '18 at 16:05

10

To update for C++17, you can use:

std::unordered_map::insert_or_assign()

http://en.cppreference.com/w/cpp/container/unordered_map/insert_or_assign

answered Apr 18 '18 at 16:05

htmlboss

119
1
4
11

2

insert_or_assign() can be slower when using gcc. see https://gcc.gnu.org/bugzilla/show_bug.cgi?id=95079 – wreckgar23 Nov 10 '20 at 16:40

Jorge Bellon · Answer 4 · 2022-05-12T09:04:34.287

All of your map functions perform a search, so you always search the map twice regardless of the key being present or not. You can leverage the fact that insert retrieves whether the insertion took place (key did not exist) or not (key exists) and act accordingly:

std::unordered_map<int,int> mydict;
bool inserted = false;
auto position = mydict.end();
std::tie(position, inserted) = mydict.insert({key, value});
if (inserted) {
  pos->second = value;
}

This would be equivalent to mydict[key] = value, because we are assigning the new value no matter what. For types where default construction is cheap I would go with operator[] instead, if that's the only thing you need to do with the map.

All insert, emplace and operator[] can perform an additional construction of value_type in different situations: insert and emplace do this before the insertion takes place and operator[] default constructs the mapped value when key is not present. Thus, they are not ideal for types whose construction/copy/move is expensive (std::thread, very large std::array...). In this case, it is more appropriate to use try_emplace instead (C++17):

std::unordered_map<int, expensive_type> mydict;
bool inserted = false;
auto position = mydict.end();
std::tie(position, inserted) = mydict.try_emplace(key, expensive_constructor_args);
if (!inserted) {
  // no expensive_type has been constructed
  // pos->second references the existing value
}

score 1 · Answer 5 · answered Apr 18 '18 at 16:20

Usually you avoid extra typing by means of defining a function that saves you from typing the same again. If you don't have access to C++17's insert_or_assign(), you can implement something like this yourself:

bool InsertOrAssign(std::unordered_map& m, int key, int value) {
  // Your code or one of the suggested answers goes here
}

What is the quickest way of inserting/updating std::unordered_map elements without using an if?

5 Answers5