C ++中的容器：指针与引用

Question

I'm trying to understand the best practices for stl containers (specifically map) and wondering about the following:

map<string,blah> map1;
map<string,blah*> map2;

(1) blah a = = map2["a"]
a.foo = somethingelse;
map2["a"] = a;

(2) blah& a = map2.at("a")

(3) blah a = = map2.at("a")
a.foo = somethingelse;
map2["a"] = a;

(4) blah& a = map2["a"]
(5) blah& a = map2.at("a")

(6) blah* a = *map2.find("a")

(7) blah* a = map2["a"]

I understand that storing a reference over a pointer has the benefit of 1) not having to manage your own memory 2) behind able to access the objects from outside the map (their memory location doesn't change), while storing a pointer over a reference means that inserting elements into the map will be cheaper (copy the pointer, not the reference).

What about the other operations? For example, find is logarithmic in size which suggest that it's better to use references because the memory will be contiguous.

I'm assuming (1) and (3) are just bad ideas, but what about the others? Would it be correct to say that if my map is read-dominated I should use references, while if its write dominated (the objects are modified frequently), I should maybe use pointers?

Answer 1

Now, lets' deal with this, statement after statement...

1. I understand that storing a reference over a pointer has the benefit . Do you really store references? see std::reference_wraper . Do you know, underneath the hood, references are pointers, {just that on the front end, its a super strict type that binds once and on declaration}

2. not having to manage your own memory : No, so long it's an lvalue, memory must be managed. Either by you or the compiler (automatic storage duration)

3. behind able to access the objects from outside the map ..., while storing a pointer over a reference ... will be cheaper (copy the pointer, not the reference). : std::map manages it's own memory, you only want to store pointer if it shouldn't manage the memory of the objects. And Yes, it's cheaper to store pointers for non- integral types

4. What about the other operations? ... it's better to use references because the memory will be contiguous : Again, see point 1. Except if you meant values... Also, not all containers store their elements in a contiguous memory irrespective of what type they consume

5. Would it be correct to say that if my map is read-dominated I should use references, while if its write dominated (the objects are modified frequently), I should maybe use pointers? : No! See point 1 again... It doesn't really matter... just be const correct

Answer 2

You maybe saw "T& at(key)" for your map, or perhaps something else that talked about references? Containers do take values as references, but that's just for efficiency. They are then copied into the container.

If you decide to put values into the container (option 1), then your item has to be copied when inserted, but then can be modified by reference:

blah &a = map1["a"]
a.foo = somethingelse;
//  No need to do this: map1["a"] = a;

Or, shorter:

map1["a"].foo = somethingelse;

When you do this with values, the map owns the object and will delete it when the map is deleted (among other times).

If you store raw pointers, you must manage the memory. I wouldn't advise that. I would instead consider putting shared_ptr or unique_ptr into your map. You do that if you need to have the value outside of the map stay alive even if the map is destroyed.

map<string,shared_ptr<blah>> map3;
shared_ptr<blah> myPtr = make_shared<blah>();
map3["a"] = myPtr;

Here, I can still use myPtr even after the map goes away. After everything pointing to the object is gone, the object will be deleted.