std::reference_wrapper<T> usage in a container

Question

If I could I would remove all raw pointers * from my code, because using them may be not thread safe and intentions of the design are not clear (optional value, ownership, etc). Sometimes however it is not that easy to not use pointers. For example we tend to use pointers for a base type in a container of polymorphic types:

class A : noncopyable { ... };
class B : public A { ... };

std::vector<A*> v;
v.emplace_back(new B);

// temporary container for some operation
std::vector<A*> selected;
if(check())
   selected.emplace_back(v.front());

What can you say about above code? Who is the owner? Is it a shared ownership or not? It is why we should probably do that for v:

std::vector<std::unique_ptr<A>> v;
v.emplace_back(make_unique<B>());

Now it is clear that v owns the objects but I still do not like that selected has a raw pointer and makes my design not intuitive. Looking into Standard C++ library I think that there is only one type that could do the job - std::reference_wrapper:

std::vector<std::unique_ptr<A>> v;
v.emplace_back(make_unique<B>());

// temporary container for some operation
std::vector<std::reference_wrapper<A>> selected;
if(check())
  selected.emplace_back(*v.front());

How do you feel about that code? Is it a good practice? I know that std::ref() and std::cref where meant to primarily work with templates, but it seems that here we can also use it to clearly state our design intent. The only problem I see is that I have to dereference std::reference_wrapper with get() and there are no operator*() or operator->() inside to have the same interface like in a container with unique_ptr. Should I write something similar on my own? Or maybe a reference_wrapper could be extended for such use case in future C++ versions? Please share your feedback.

EDIT: I changed the code samples to maybe better show the intent.

What is the lifetime of selected? Is it guaranteed to be destroyed (or emptied) before the objects to which its elements point are destroyed? If so, then use raw pointers: there's no need for shared ownership. There is nothing wrong with using raw pointers in C++; just make sure that raw pointers don't own the pointed-to object. — James McNellis
– James McNellis, Commented Dec 14, 2012 at 7:55
@JamesMcNellis You are right. I think is it clear from such a small snippet what selected and v are meant for. However in a bigger scope/class it is not that easy to see the relationships in a design. In some method you start to work on selected only without the view on v and you start to wonder what that pointer here means. Is it an optional value, ownership or just base class pointer? I am looking for a nice way to present my design intent without the overhead in runtime. — Mateusz Pusz
– Mateusz Pusz, Commented Dec 14, 2012 at 8:13
@perreal std::shared_ptr would be probably a good solution in other cases however here I expect that v has strict ownership and other potential containers are temporaries to do some operations on the members (ie. sort, subset, etc). — Mateusz Pusz
– Mateusz Pusz, Commented Dec 14, 2012 at 8:15

Andrzej · Accepted Answer · 2012-12-14 09:36:55Z

6

You have already provided a solution which looks sound. I understand that the question is "How do you feel?"

My personal feeling is that there need to exist some balance between safety and unambiguity on the one hand and the simplicity of the code on the other. It looks like your solution may be pushing it too hard towards safety and compromising the simplicity too much. Whenever I used containers holding "weak references" I used raw pointers to represent these. True, this might make it less clear who the owner of the object is, but it has some advantages too: you do not have to study what a "reference_wrapper" is, and the code is clear. If you use them (a container of weak references) only temporarily and you encapsulate this usage, the ownership issue should be minimal.

But this is just a question of personal preference, I guess. Let me just propose using different types for the same purpose. This is provided that you can afford to use Boost. For "strong" references (which own the resource) you could use Steve Watanabe's Type Erasure library. It does not require an explicit usage of free-store memory, and i suppose for small types it can get away from using heap-memory altogether (using small-buffer optimization). It has been recently accepted to Boost, although has not been release yet, I think.

For weak references, consider using "optional references" with Boost.Optional:

int i = 0;
boost::optional<int&> oi = i; // note: int&
i = 2;
assert(*oi == 2);

It has same semantics as reference_wrapper.

answered Dec 14, 2012 at 9:36

Andrzej

5,1791 gold badge31 silver badges38 bronze badges

Sign up to request clarification or add additional context in comments.

1 Comment

underscore_d Over a year ago

Since C++17, we have std::optional<>, but it doesn't allow references because people couldn't agree on what semantics an optional reference should have when being copied/assigned. So, the closest thing in std:: is std::optional< std::reference_wrapper<T> >. The semantics in that case, as presumably for the boost:: version, are that copy-constructing and assigning rebind the reference held in the wrapper, rather than assigning the value between the referenced objects. (I'm not sure why that's preferable, but there must be very good reasons if everyone is arriving at the same conclusion)

perreal · Accepted Answer · 2012-12-14 08:21:06Z

1

I think calling them shared_ptr's is not logically wrong. However, looking at the definition of std::weak_ptr:

std::weak_ptr is a smart pointer that holds a non-owning ("weak") reference to an object that is managed by std::shared_ptr. It must be converted to std::shared_ptr in order to access the referenced object.

it might be a better candidate. At least when you are fiddling with the pointer through selected you will need to assume temporary ownership. Since the original pointer is stored in a shared pointer, using weak pointer will be safer.

answered Dec 14, 2012 at 8:21

perreal

98.7k23 gold badges159 silver badges187 bronze badges

4 Comments

Mateusz Pusz Over a year ago

Hmm, it would work. However I do not like the runtime and memory overhead of std::shared_ptr. I use them only when I really need them -> shared ownership.

perreal Over a year ago

It might be argued that at some point in time you are sharing the ownership. Otherwise keep on using bare pointers in selected.

Christian Rau Over a year ago

@MateuszPusz Not to forget the "conceptual overhead" of shared ownership when used for unique ownership.

perreal Over a year ago

@ChristianRau, do you the overhead of thinking twice before deleting the pointer, because there might be someone trying to use it?

Collectives™ on Stack Overflow

std::reference_wrapper<T> usage in a container

2 Answers 2

1 Comment

4 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

1 Comment

4 Comments

Your Answer

Sign up or log in

Post as a guest

Related